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


791e02fe3d5cf8253f7b6a8a0e5c3877963aa7fd
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3792 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3793 return wxPyTestDisplayAvailable();
3794 }
3795
3796 void wxApp_CleanUp() {
3797 __wxPyCleanup();
3798 }
3799
3800
3801 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3802
3803
3804
3805
3806
3807 SWIGINTERNINLINE PyObject *
3808 SWIG_FromCharPtr(const char *cptr)
3809 {
3810 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3811 }
3812
3813
3814 #if 0 // #ifdef __WXMAC__
3815
3816 // A dummy class that raises an exception if used...
3817 class wxEventLoop
3818 {
3819 public:
3820 wxEventLoop() { wxPyRaiseNotImplemented(); }
3821 int Run() { return 0; }
3822 void Exit(int rc = 0) {}
3823 bool Pending() const { return false; }
3824 bool Dispatch() { return false; }
3825 bool IsRunning() const { return false; }
3826 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3827 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3828 };
3829
3830 #else
3831
3832 #include <wx/evtloop.h>
3833
3834 #endif
3835
3836
3837
3838 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3839 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3840 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3841 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3842 wxWindowList& list = self->GetChildren();
3843 return wxPy_ConvertList(&list);
3844 }
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
3865 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3866
3867 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3868 return wxWindow::FindWindowById(id, parent);
3869 }
3870
3871 wxWindow* wxFindWindowByName( const wxString& name,
3872 const wxWindow *parent = NULL ) {
3873 return wxWindow::FindWindowByName(name, parent);
3874 }
3875
3876 wxWindow* wxFindWindowByLabel( const wxString& label,
3877 const wxWindow *parent = NULL ) {
3878 return wxWindow::FindWindowByLabel(label, parent);
3879 }
3880
3881
3882 #ifdef __WXMSW__
3883 #include <wx/msw/private.h> // to get wxGetWindowId
3884 #endif
3885
3886
3887 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3888 #ifdef __WXMSW__
3889 WXHWND hWnd = (WXHWND)_hWnd;
3890 long id = wxGetWindowId(hWnd);
3891 wxWindow* win = new wxWindow;
3892 if (parent)
3893 parent->AddChild(win);
3894 win->SetEventHandler(win);
3895 win->SetHWND(hWnd);
3896 win->SetId(id);
3897 win->SubclassWin(hWnd);
3898 win->AdoptAttributesFromHWND();
3899 win->SetupColours();
3900 return win;
3901 #else
3902 wxPyRaiseNotImplemented();
3903 return NULL;
3904 #endif
3905 }
3906
3907
3908 PyObject* GetTopLevelWindows() {
3909 return wxPy_ConvertList(&wxTopLevelWindows);
3910 }
3911
3912
3913 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3916
3917 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3918
3919
3920 SWIGINTERNINLINE int
3921 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3922 {
3923 unsigned long v;
3924 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3925 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3926 return res;
3927 }
3928
3929 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3930 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3931 wxMenuItemList& list = self->GetMenuItems();
3932 return wxPy_ConvertList(&list);
3933 }
3934 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3935 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3936 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3937 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3938 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3939 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3941 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3942 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3943 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3944 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3945 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3946 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3947 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3948 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3949 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3950 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3951 static const wxString wxPyControlNameStr(wxControlNameStr);
3952 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3953 if (clientData) {
3954 wxPyClientData* data = new wxPyClientData(clientData);
3955 return self->Append(item, data);
3956 } else
3957 return self->Append(item);
3958 }
3959 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3960 if (clientData) {
3961 wxPyClientData* data = new wxPyClientData(clientData);
3962 return self->Insert(item, pos, data);
3963 } else
3964 return self->Insert(item, pos);
3965 }
3966 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3967 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3968 if (data) {
3969 Py_INCREF(data->m_obj);
3970 return data->m_obj;
3971 } else {
3972 Py_INCREF(Py_None);
3973 return Py_None;
3974 }
3975 }
3976 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3977 wxPyClientData* data = new wxPyClientData(clientData);
3978 self->SetClientObject(n, data);
3979 }
3980
3981
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(window, proportion, flag, border, data);
3990 }
3991 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3992 wxPyUserData* data = NULL;
3993 if ( userData ) {
3994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3995 data = new wxPyUserData(userData);
3996 wxPyEndBlockThreads(blocked);
3997 }
3998 return new wxSizerItem(width, height, proportion, flag, border, data);
3999 }
4000 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4001 wxPyUserData* data = NULL;
4002 if ( userData ) {
4003 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4004 data = new wxPyUserData(userData);
4005 wxPyEndBlockThreads(blocked);
4006 }
4007 return new wxSizerItem(sizer, proportion, flag, border, data);
4008 }
4009
4010 SWIGINTERNINLINE PyObject *
4011 SWIG_From_float (float value)
4012 {
4013 return SWIG_From_double (value);
4014 }
4015
4016 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4017 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4018 if (data) {
4019 Py_INCREF(data->m_obj);
4020 return data->m_obj;
4021 } else {
4022 Py_INCREF(Py_None);
4023 return Py_None;
4024 }
4025 }
4026 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4027 wxPyUserData* data = NULL;
4028 if ( userData ) {
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 data = new wxPyUserData(userData);
4031 wxPyEndBlockThreads(blocked);
4032 }
4033 self->SetUserData(data);
4034 }
4035
4036 // Figure out the type of the sizer item
4037
4038 struct wxPySizerItemInfo {
4039 wxPySizerItemInfo()
4040 : window(NULL), sizer(NULL), gotSize(false),
4041 size(wxDefaultSize), gotPos(false), pos(-1)
4042 {}
4043
4044 wxWindow* window;
4045 wxSizer* sizer;
4046 bool gotSize;
4047 wxSize size;
4048 bool gotPos;
4049 int pos;
4050 };
4051
4052 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4053
4054 wxPySizerItemInfo info;
4055 wxSize size;
4056 wxSize* sizePtr = &size;
4057
4058 // Find out what the type of the item is
4059 // try wxWindow
4060 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4061 PyErr_Clear();
4062 info.window = NULL;
4063
4064 // try wxSizer
4065 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4066 PyErr_Clear();
4067 info.sizer = NULL;
4068
4069 // try wxSize or (w,h)
4070 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4071 info.size = *sizePtr;
4072 info.gotSize = true;
4073 }
4074
4075 // or a single int
4076 if (checkIdx && PyInt_Check(item)) {
4077 info.pos = PyInt_AsLong(item);
4078 info.gotPos = true;
4079 }
4080 }
4081 }
4082
4083 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4084 // no expected type, figure out what kind of error message to generate
4085 if ( !checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4087 else if ( checkSize && !checkIdx )
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4089 else if ( !checkSize && checkIdx)
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4091 else
4092 // can this one happen?
4093 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4094 }
4095
4096 return info;
4097 }
4098
4099 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4100 if (!self->GetClientObject())
4101 self->SetClientObject(new wxPyOORClientData(_self));
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4104
4105 wxPyUserData* data = NULL;
4106 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4107 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4108 if ( userData && (info.window || info.sizer || info.gotSize) )
4109 data = new wxPyUserData(userData);
4110 if ( info.sizer )
4111 PyObject_SetAttrString(item,"thisown",Py_False);
4112 wxPyEndBlockThreads(blocked);
4113
4114 // Now call the real Add method if a valid item type was found
4115 if ( info.window )
4116 return self->Add(info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Add(info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Insert method if a valid item type was found
4137 if ( info.window )
4138 return self->Insert(before, info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Insert(before, info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4148
4149 wxPyUserData* data = NULL;
4150 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4151 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4152 if ( userData && (info.window || info.sizer || info.gotSize) )
4153 data = new wxPyUserData(userData);
4154 if ( info.sizer )
4155 PyObject_SetAttrString(item,"thisown",Py_False);
4156 wxPyEndBlockThreads(blocked);
4157
4158 // Now call the real Prepend method if a valid item type was found
4159 if ( info.window )
4160 return self->Prepend(info.window, proportion, flag, border, data);
4161 else if ( info.sizer )
4162 return self->Prepend(info.sizer, proportion, flag, border, data);
4163 else if (info.gotSize)
4164 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4165 proportion, flag, border, data);
4166 else
4167 return NULL;
4168 }
4169 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4172 wxPyEndBlockThreads(blocked);
4173 if ( info.window )
4174 return self->Remove(info.window);
4175 else if ( info.sizer )
4176 return self->Remove(info.sizer);
4177 else if ( info.gotPos )
4178 return self->Remove(info.pos);
4179 else
4180 return false;
4181 }
4182 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4184 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4185 wxPyEndBlockThreads(blocked);
4186 if ( info.window )
4187 return self->Detach(info.window);
4188 else if ( info.sizer )
4189 return self->Detach(info.sizer);
4190 else if ( info.gotPos )
4191 return self->Detach(info.pos);
4192 else
4193 return false;
4194 }
4195 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4198 wxPyEndBlockThreads(blocked);
4199 if ( info.window )
4200 return self->GetItem(info.window);
4201 else if ( info.sizer )
4202 return self->GetItem(info.sizer);
4203 else if ( info.gotPos )
4204 return self->GetItem(info.pos);
4205 else
4206 return NULL;
4207 }
4208 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4211 wxPyEndBlockThreads(blocked);
4212 if ( info.window )
4213 self->SetItemMinSize(info.window, size);
4214 else if ( info.sizer )
4215 self->SetItemMinSize(info.sizer, size);
4216 else if ( info.gotPos )
4217 self->SetItemMinSize(info.pos, size);
4218 }
4219 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4220 wxSizerItemList& list = self->GetChildren();
4221 return wxPy_ConvertList(&list);
4222 }
4223 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4226 wxPyEndBlockThreads(blocked);
4227 if ( info.window )
4228 return self->Show(info.window, show, recursive);
4229 else if ( info.sizer )
4230 return self->Show(info.sizer, show, recursive);
4231 else if ( info.gotPos )
4232 return self->Show(info.pos, show);
4233 else
4234 return false;
4235 }
4236 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4237 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4238 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4239 wxPyEndBlockThreads(blocked);
4240 if ( info.window )
4241 return self->IsShown(info.window);
4242 else if ( info.sizer )
4243 return self->IsShown(info.sizer);
4244 else if ( info.gotPos )
4245 return self->IsShown(info.pos);
4246 else
4247 return false;
4248 }
4249
4250 // See pyclasses.h
4251 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4252 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4253 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4254
4255
4256
4257
4258 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4259 {
4260 if (source == Py_None) {
4261 **obj = wxGBPosition(-1,-1);
4262 return true;
4263 }
4264 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4265 }
4266
4267 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4268 {
4269 if (source == Py_None) {
4270 **obj = wxGBSpan(-1,-1);
4271 return true;
4272 }
4273 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4274 }
4275
4276
4277 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4278 wxGBPosition temp, *obj = &temp;
4279 if ( other == Py_None ) return false;
4280 if ( ! wxGBPosition_helper(other, &obj) ) {
4281 PyErr_Clear();
4282 return false;
4283 }
4284 return self->operator==(*obj);
4285 }
4286 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4287 wxGBPosition temp, *obj = &temp;
4288 if ( other == Py_None ) return true;
4289 if ( ! wxGBPosition_helper(other, &obj)) {
4290 PyErr_Clear();
4291 return true;
4292 }
4293 return self->operator!=(*obj);
4294 }
4295 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4296 self->SetRow(row);
4297 self->SetCol(col);
4298 }
4299 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4300 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4301 PyObject* tup = PyTuple_New(2);
4302 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4303 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4304 wxPyEndBlockThreads(blocked);
4305 return tup;
4306 }
4307 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4308 wxGBSpan temp, *obj = &temp;
4309 if ( other == Py_None ) return false;
4310 if ( ! wxGBSpan_helper(other, &obj) ) {
4311 PyErr_Clear();
4312 return false;
4313 }
4314 return self->operator==(*obj);
4315 }
4316 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4317 wxGBSpan temp, *obj = &temp;
4318 if ( other == Py_None ) return true;
4319 if ( ! wxGBSpan_helper(other, &obj)) {
4320 PyErr_Clear();
4321 return true;
4322 }
4323 return self->operator!=(*obj);
4324 }
4325 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4326 self->SetRowspan(rowspan);
4327 self->SetColspan(colspan);
4328 }
4329 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4331 PyObject* tup = PyTuple_New(2);
4332 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4333 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4334 wxPyEndBlockThreads(blocked);
4335 return tup;
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(window, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4347 wxPyUserData* data = NULL;
4348 if ( userData ) {
4349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4350 data = new wxPyUserData(userData);
4351 wxPyEndBlockThreads(blocked);
4352 }
4353 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4354 }
4355 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4356 wxPyUserData* data = NULL;
4357 if ( userData ) {
4358 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4359 data = new wxPyUserData(userData);
4360 wxPyEndBlockThreads(blocked);
4361 }
4362 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4363 }
4364 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4365 int row, col;
4366 self->GetEndPos(row, col);
4367 return wxGBPosition(row, col);
4368 }
4369 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4370
4371 wxPyUserData* data = NULL;
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4374 if ( userData && (info.window || info.sizer || info.gotSize) )
4375 data = new wxPyUserData(userData);
4376 if ( info.sizer )
4377 PyObject_SetAttrString(item,"thisown",Py_False);
4378 wxPyEndBlockThreads(blocked);
4379
4380 // Now call the real Add method if a valid item type was found
4381 if ( info.window )
4382 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4383 else if ( info.sizer )
4384 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4385 else if (info.gotSize)
4386 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4387 pos, span, flag, border, data);
4388 return NULL;
4389 }
4390
4391
4392 #ifdef __cplusplus
4393 extern "C" {
4394 #endif
4395 SWIGINTERN int EmptyString_set(PyObject *) {
4396 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4397 return 1;
4398 }
4399
4400
4401 SWIGINTERN PyObject *EmptyString_get(void) {
4402 PyObject *pyobj = 0;
4403
4404 {
4405 #if wxUSE_UNICODE
4406 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #else
4408 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4409 #endif
4410 }
4411 return pyobj;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4416 PyObject *resultobj = 0;
4417 wxObject *arg1 = (wxObject *) 0 ;
4418 wxString result;
4419 void *argp1 = 0 ;
4420 int res1 = 0 ;
4421 PyObject *swig_obj[1] ;
4422
4423 if (!args) SWIG_fail;
4424 swig_obj[0] = args;
4425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4426 if (!SWIG_IsOK(res1)) {
4427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4428 }
4429 arg1 = reinterpret_cast< wxObject * >(argp1);
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxObject_GetClassName(arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *resultobj = 0;
4451 wxObject *arg1 = (wxObject *) 0 ;
4452 void *argp1 = 0 ;
4453 int res1 = 0 ;
4454 PyObject *swig_obj[1] ;
4455
4456 if (!args) SWIG_fail;
4457 swig_obj[0] = args;
4458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4459 if (!SWIG_IsOK(res1)) {
4460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4461 }
4462 arg1 = reinterpret_cast< wxObject * >(argp1);
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 wxObject_Destroy(arg1);
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 resultobj = SWIG_Py_Void();
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *obj;
4478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4479 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4480 return SWIG_Py_Void();
4481 }
4482
4483 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4484 PyObject *resultobj = 0;
4485 wxSize *arg1 = (wxSize *) 0 ;
4486 int arg2 ;
4487 void *argp1 = 0 ;
4488 int res1 = 0 ;
4489 int val2 ;
4490 int ecode2 = 0 ;
4491 PyObject *swig_obj[2] ;
4492
4493 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4495 if (!SWIG_IsOK(res1)) {
4496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4497 }
4498 arg1 = reinterpret_cast< wxSize * >(argp1);
4499 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4500 if (!SWIG_IsOK(ecode2)) {
4501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4502 }
4503 arg2 = static_cast< int >(val2);
4504 if (arg1) (arg1)->x = arg2;
4505
4506 resultobj = SWIG_Py_Void();
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 wxSize *arg1 = (wxSize *) 0 ;
4516 int result;
4517 void *argp1 = 0 ;
4518 int res1 = 0 ;
4519 PyObject *swig_obj[1] ;
4520
4521 if (!args) SWIG_fail;
4522 swig_obj[0] = args;
4523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4524 if (!SWIG_IsOK(res1)) {
4525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4526 }
4527 arg1 = reinterpret_cast< wxSize * >(argp1);
4528 result = (int) ((arg1)->x);
4529 resultobj = SWIG_From_int(static_cast< int >(result));
4530 return resultobj;
4531 fail:
4532 return NULL;
4533 }
4534
4535
4536 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537 PyObject *resultobj = 0;
4538 wxSize *arg1 = (wxSize *) 0 ;
4539 int arg2 ;
4540 void *argp1 = 0 ;
4541 int res1 = 0 ;
4542 int val2 ;
4543 int ecode2 = 0 ;
4544 PyObject *swig_obj[2] ;
4545
4546 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4550 }
4551 arg1 = reinterpret_cast< wxSize * >(argp1);
4552 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4553 if (!SWIG_IsOK(ecode2)) {
4554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4555 }
4556 arg2 = static_cast< int >(val2);
4557 if (arg1) (arg1)->y = arg2;
4558
4559 resultobj = SWIG_Py_Void();
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567 PyObject *resultobj = 0;
4568 wxSize *arg1 = (wxSize *) 0 ;
4569 int result;
4570 void *argp1 = 0 ;
4571 int res1 = 0 ;
4572 PyObject *swig_obj[1] ;
4573
4574 if (!args) SWIG_fail;
4575 swig_obj[0] = args;
4576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4577 if (!SWIG_IsOK(res1)) {
4578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4579 }
4580 arg1 = reinterpret_cast< wxSize * >(argp1);
4581 result = (int) ((arg1)->y);
4582 resultobj = SWIG_From_int(static_cast< int >(result));
4583 return resultobj;
4584 fail:
4585 return NULL;
4586 }
4587
4588
4589 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4590 PyObject *resultobj = 0;
4591 int arg1 = (int) 0 ;
4592 int arg2 = (int) 0 ;
4593 wxSize *result = 0 ;
4594 int val1 ;
4595 int ecode1 = 0 ;
4596 int val2 ;
4597 int ecode2 = 0 ;
4598 PyObject * obj0 = 0 ;
4599 PyObject * obj1 = 0 ;
4600 char * kwnames[] = {
4601 (char *) "w",(char *) "h", NULL
4602 };
4603
4604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4605 if (obj0) {
4606 ecode1 = SWIG_AsVal_int(obj0, &val1);
4607 if (!SWIG_IsOK(ecode1)) {
4608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4609 }
4610 arg1 = static_cast< int >(val1);
4611 }
4612 if (obj1) {
4613 ecode2 = SWIG_AsVal_int(obj1, &val2);
4614 if (!SWIG_IsOK(ecode2)) {
4615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4616 }
4617 arg2 = static_cast< int >(val2);
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 result = (wxSize *)new wxSize(arg1,arg2);
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4633 PyObject *resultobj = 0;
4634 wxSize *arg1 = (wxSize *) 0 ;
4635 void *argp1 = 0 ;
4636 int res1 = 0 ;
4637 PyObject *swig_obj[1] ;
4638
4639 if (!args) SWIG_fail;
4640 swig_obj[0] = args;
4641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4644 }
4645 arg1 = reinterpret_cast< wxSize * >(argp1);
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 delete arg1;
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_Py_Void();
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 wxSize *arg1 = (wxSize *) 0 ;
4663 PyObject *arg2 = (PyObject *) 0 ;
4664 bool result;
4665 void *argp1 = 0 ;
4666 int res1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char * kwnames[] = {
4670 (char *) "self",(char *) "other", NULL
4671 };
4672
4673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4675 if (!SWIG_IsOK(res1)) {
4676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4677 }
4678 arg1 = reinterpret_cast< wxSize * >(argp1);
4679 arg2 = obj1;
4680 {
4681 result = (bool)wxSize___eq__(arg1,arg2);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 wxSize *arg1 = (wxSize *) 0 ;
4696 PyObject *arg2 = (PyObject *) 0 ;
4697 bool result;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char * kwnames[] = {
4703 (char *) "self",(char *) "other", NULL
4704 };
4705
4706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 arg2 = obj1;
4713 {
4714 result = (bool)wxSize___ne__(arg1,arg2);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 {
4718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4719 }
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 wxSize *arg2 = 0 ;
4730 wxSize result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 wxSize temp2 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "sz", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 {
4747 arg2 = &temp2;
4748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 result = (arg1)->operator +((wxSize const &)*arg2);
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4757 return resultobj;
4758 fail:
4759 return NULL;
4760 }
4761
4762
4763 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj = 0;
4765 wxSize *arg1 = (wxSize *) 0 ;
4766 wxSize *arg2 = 0 ;
4767 wxSize result;
4768 void *argp1 = 0 ;
4769 int res1 = 0 ;
4770 wxSize temp2 ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 char * kwnames[] = {
4774 (char *) "self",(char *) "sz", NULL
4775 };
4776
4777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4779 if (!SWIG_IsOK(res1)) {
4780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4781 }
4782 arg1 = reinterpret_cast< wxSize * >(argp1);
4783 {
4784 arg2 = &temp2;
4785 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = (arg1)->operator -((wxSize const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 wxSize *arg2 = 0 ;
4804 void *argp1 = 0 ;
4805 int res1 = 0 ;
4806 wxSize temp2 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "sz", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",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_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 {
4820 arg2 = &temp2;
4821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 (arg1)->IncTo((wxSize const &)*arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 resultobj = SWIG_Py_Void();
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 wxSize *arg1 = (wxSize *) 0 ;
4839 wxSize *arg2 = 0 ;
4840 void *argp1 = 0 ;
4841 int res1 = 0 ;
4842 wxSize temp2 ;
4843 PyObject * obj0 = 0 ;
4844 PyObject * obj1 = 0 ;
4845 char * kwnames[] = {
4846 (char *) "self",(char *) "sz", NULL
4847 };
4848
4849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4851 if (!SWIG_IsOK(res1)) {
4852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4853 }
4854 arg1 = reinterpret_cast< wxSize * >(argp1);
4855 {
4856 arg2 = &temp2;
4857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4858 }
4859 {
4860 PyThreadState* __tstate = wxPyBeginAllowThreads();
4861 (arg1)->DecTo((wxSize const &)*arg2);
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 resultobj = SWIG_Py_Void();
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 wxSize *arg1 = (wxSize *) 0 ;
4875 int arg2 ;
4876 int arg3 ;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 int val2 ;
4880 int ecode2 = 0 ;
4881 int val3 ;
4882 int ecode3 = 0 ;
4883 PyObject * obj0 = 0 ;
4884 PyObject * obj1 = 0 ;
4885 PyObject * obj2 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "dx",(char *) "dy", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4894 }
4895 arg1 = reinterpret_cast< wxSize * >(argp1);
4896 ecode2 = SWIG_AsVal_int(obj1, &val2);
4897 if (!SWIG_IsOK(ecode2)) {
4898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4899 }
4900 arg2 = static_cast< int >(val2);
4901 ecode3 = SWIG_AsVal_int(obj2, &val3);
4902 if (!SWIG_IsOK(ecode3)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4904 }
4905 arg3 = static_cast< int >(val3);
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 (arg1)->IncBy(arg2,arg3);
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 wxSize *arg1 = (wxSize *) 0 ;
4922 int arg2 ;
4923 int arg3 ;
4924 void *argp1 = 0 ;
4925 int res1 = 0 ;
4926 int val2 ;
4927 int ecode2 = 0 ;
4928 int val3 ;
4929 int ecode3 = 0 ;
4930 PyObject * obj0 = 0 ;
4931 PyObject * obj1 = 0 ;
4932 PyObject * obj2 = 0 ;
4933 char * kwnames[] = {
4934 (char *) "self",(char *) "dx",(char *) "dy", NULL
4935 };
4936
4937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4939 if (!SWIG_IsOK(res1)) {
4940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4941 }
4942 arg1 = reinterpret_cast< wxSize * >(argp1);
4943 ecode2 = SWIG_AsVal_int(obj1, &val2);
4944 if (!SWIG_IsOK(ecode2)) {
4945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4946 }
4947 arg2 = static_cast< int >(val2);
4948 ecode3 = SWIG_AsVal_int(obj2, &val3);
4949 if (!SWIG_IsOK(ecode3)) {
4950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4951 }
4952 arg3 = static_cast< int >(val3);
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->DecBy(arg2,arg3);
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 resultobj = SWIG_Py_Void();
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj = 0;
4968 wxSize *arg1 = (wxSize *) 0 ;
4969 float arg2 ;
4970 float arg3 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 float val2 ;
4974 int ecode2 = 0 ;
4975 float val3 ;
4976 int ecode3 = 0 ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 PyObject * obj2 = 0 ;
4980 char * kwnames[] = {
4981 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4982 };
4983
4984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4986 if (!SWIG_IsOK(res1)) {
4987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4988 }
4989 arg1 = reinterpret_cast< wxSize * >(argp1);
4990 ecode2 = SWIG_AsVal_float(obj1, &val2);
4991 if (!SWIG_IsOK(ecode2)) {
4992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4993 }
4994 arg2 = static_cast< float >(val2);
4995 ecode3 = SWIG_AsVal_float(obj2, &val3);
4996 if (!SWIG_IsOK(ecode3)) {
4997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4998 }
4999 arg3 = static_cast< float >(val3);
5000 {
5001 PyThreadState* __tstate = wxPyBeginAllowThreads();
5002 (arg1)->Scale(arg2,arg3);
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_Py_Void();
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj = 0;
5015 wxSize *arg1 = (wxSize *) 0 ;
5016 int arg2 ;
5017 int arg3 ;
5018 void *argp1 = 0 ;
5019 int res1 = 0 ;
5020 int val2 ;
5021 int ecode2 = 0 ;
5022 int val3 ;
5023 int ecode3 = 0 ;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 PyObject * obj2 = 0 ;
5027 char * kwnames[] = {
5028 (char *) "self",(char *) "w",(char *) "h", NULL
5029 };
5030
5031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5033 if (!SWIG_IsOK(res1)) {
5034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5035 }
5036 arg1 = reinterpret_cast< wxSize * >(argp1);
5037 ecode2 = SWIG_AsVal_int(obj1, &val2);
5038 if (!SWIG_IsOK(ecode2)) {
5039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5040 }
5041 arg2 = static_cast< int >(val2);
5042 ecode3 = SWIG_AsVal_int(obj2, &val3);
5043 if (!SWIG_IsOK(ecode3)) {
5044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5045 }
5046 arg3 = static_cast< int >(val3);
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 (arg1)->Set(arg2,arg3);
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 resultobj = SWIG_Py_Void();
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5061 PyObject *resultobj = 0;
5062 wxSize *arg1 = (wxSize *) 0 ;
5063 int arg2 ;
5064 void *argp1 = 0 ;
5065 int res1 = 0 ;
5066 int val2 ;
5067 int ecode2 = 0 ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5070 char * kwnames[] = {
5071 (char *) "self",(char *) "w", NULL
5072 };
5073
5074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5076 if (!SWIG_IsOK(res1)) {
5077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5078 }
5079 arg1 = reinterpret_cast< wxSize * >(argp1);
5080 ecode2 = SWIG_AsVal_int(obj1, &val2);
5081 if (!SWIG_IsOK(ecode2)) {
5082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5083 }
5084 arg2 = static_cast< int >(val2);
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 (arg1)->SetWidth(arg2);
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 resultobj = SWIG_Py_Void();
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5099 PyObject *resultobj = 0;
5100 wxSize *arg1 = (wxSize *) 0 ;
5101 int arg2 ;
5102 void *argp1 = 0 ;
5103 int res1 = 0 ;
5104 int val2 ;
5105 int ecode2 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "self",(char *) "h", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) 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_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5116 }
5117 arg1 = reinterpret_cast< wxSize * >(argp1);
5118 ecode2 = SWIG_AsVal_int(obj1, &val2);
5119 if (!SWIG_IsOK(ecode2)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5121 }
5122 arg2 = static_cast< int >(val2);
5123 {
5124 PyThreadState* __tstate = wxPyBeginAllowThreads();
5125 (arg1)->SetHeight(arg2);
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 resultobj = SWIG_Py_Void();
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 wxSize *arg1 = (wxSize *) 0 ;
5139 int result;
5140 void *argp1 = 0 ;
5141 int res1 = 0 ;
5142 PyObject *swig_obj[1] ;
5143
5144 if (!args) SWIG_fail;
5145 swig_obj[0] = args;
5146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5147 if (!SWIG_IsOK(res1)) {
5148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5149 }
5150 arg1 = reinterpret_cast< wxSize * >(argp1);
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 result = (int)((wxSize const *)arg1)->GetWidth();
5154 wxPyEndAllowThreads(__tstate);
5155 if (PyErr_Occurred()) SWIG_fail;
5156 }
5157 resultobj = SWIG_From_int(static_cast< int >(result));
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxSize *arg1 = (wxSize *) 0 ;
5167 int result;
5168 void *argp1 = 0 ;
5169 int res1 = 0 ;
5170 PyObject *swig_obj[1] ;
5171
5172 if (!args) SWIG_fail;
5173 swig_obj[0] = args;
5174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5175 if (!SWIG_IsOK(res1)) {
5176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5177 }
5178 arg1 = reinterpret_cast< wxSize * >(argp1);
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 result = (int)((wxSize const *)arg1)->GetHeight();
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_From_int(static_cast< int >(result));
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5193 PyObject *resultobj = 0;
5194 wxSize *arg1 = (wxSize *) 0 ;
5195 bool result;
5196 void *argp1 = 0 ;
5197 int res1 = 0 ;
5198 PyObject *swig_obj[1] ;
5199
5200 if (!args) SWIG_fail;
5201 swig_obj[0] = args;
5202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5203 if (!SWIG_IsOK(res1)) {
5204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5205 }
5206 arg1 = reinterpret_cast< wxSize * >(argp1);
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 {
5214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxSize *arg1 = (wxSize *) 0 ;
5225 wxSize *arg2 = 0 ;
5226 void *argp1 = 0 ;
5227 int res1 = 0 ;
5228 wxSize temp2 ;
5229 PyObject * obj0 = 0 ;
5230 PyObject * obj1 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "self",(char *) "size", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5237 if (!SWIG_IsOK(res1)) {
5238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5239 }
5240 arg1 = reinterpret_cast< wxSize * >(argp1);
5241 {
5242 arg2 = &temp2;
5243 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5244 }
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 (arg1)->SetDefaults((wxSize const &)*arg2);
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 resultobj = SWIG_Py_Void();
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5259 PyObject *resultobj = 0;
5260 wxSize *arg1 = (wxSize *) 0 ;
5261 PyObject *result = 0 ;
5262 void *argp1 = 0 ;
5263 int res1 = 0 ;
5264 PyObject *swig_obj[1] ;
5265
5266 if (!args) SWIG_fail;
5267 swig_obj[0] = args;
5268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5269 if (!SWIG_IsOK(res1)) {
5270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5271 }
5272 arg1 = reinterpret_cast< wxSize * >(argp1);
5273 {
5274 PyThreadState* __tstate = wxPyBeginAllowThreads();
5275 result = (PyObject *)wxSize_Get(arg1);
5276 wxPyEndAllowThreads(__tstate);
5277 if (PyErr_Occurred()) SWIG_fail;
5278 }
5279 resultobj = result;
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5287 PyObject *obj;
5288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5290 return SWIG_Py_Void();
5291 }
5292
5293 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5294 return SWIG_Python_InitShadowInstance(args);
5295 }
5296
5297 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5300 double arg2 ;
5301 void *argp1 = 0 ;
5302 int res1 = 0 ;
5303 double val2 ;
5304 int ecode2 = 0 ;
5305 PyObject *swig_obj[2] ;
5306
5307 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5309 if (!SWIG_IsOK(res1)) {
5310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5311 }
5312 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5313 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5314 if (!SWIG_IsOK(ecode2)) {
5315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5316 }
5317 arg2 = static_cast< double >(val2);
5318 if (arg1) (arg1)->x = arg2;
5319
5320 resultobj = SWIG_Py_Void();
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *resultobj = 0;
5329 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5330 double result;
5331 void *argp1 = 0 ;
5332 int res1 = 0 ;
5333 PyObject *swig_obj[1] ;
5334
5335 if (!args) SWIG_fail;
5336 swig_obj[0] = args;
5337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5338 if (!SWIG_IsOK(res1)) {
5339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5340 }
5341 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5342 result = (double) ((arg1)->x);
5343 resultobj = SWIG_From_double(static_cast< double >(result));
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 double arg2 ;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 double val2 ;
5357 int ecode2 = 0 ;
5358 PyObject *swig_obj[2] ;
5359
5360 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5362 if (!SWIG_IsOK(res1)) {
5363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5364 }
5365 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5366 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5367 if (!SWIG_IsOK(ecode2)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5369 }
5370 arg2 = static_cast< double >(val2);
5371 if (arg1) (arg1)->y = arg2;
5372
5373 resultobj = SWIG_Py_Void();
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5383 double result;
5384 void *argp1 = 0 ;
5385 int res1 = 0 ;
5386 PyObject *swig_obj[1] ;
5387
5388 if (!args) SWIG_fail;
5389 swig_obj[0] = args;
5390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5393 }
5394 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5395 result = (double) ((arg1)->y);
5396 resultobj = SWIG_From_double(static_cast< double >(result));
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj = 0;
5405 double arg1 = (double) 0.0 ;
5406 double arg2 = (double) 0.0 ;
5407 wxRealPoint *result = 0 ;
5408 double val1 ;
5409 int ecode1 = 0 ;
5410 double val2 ;
5411 int ecode2 = 0 ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char * kwnames[] = {
5415 (char *) "x",(char *) "y", NULL
5416 };
5417
5418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5419 if (obj0) {
5420 ecode1 = SWIG_AsVal_double(obj0, &val1);
5421 if (!SWIG_IsOK(ecode1)) {
5422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5423 }
5424 arg1 = static_cast< double >(val1);
5425 }
5426 if (obj1) {
5427 ecode2 = SWIG_AsVal_double(obj1, &val2);
5428 if (!SWIG_IsOK(ecode2)) {
5429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5430 }
5431 arg2 = static_cast< double >(val2);
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 PyObject *swig_obj[1] ;
5452
5453 if (!args) SWIG_fail;
5454 swig_obj[0] = args;
5455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5456 if (!SWIG_IsOK(res1)) {
5457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5458 }
5459 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 delete arg1;
5463
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 resultobj = SWIG_Py_Void();
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj = 0;
5476 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5477 PyObject *arg2 = (PyObject *) 0 ;
5478 bool result;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 PyObject * obj0 = 0 ;
5482 PyObject * obj1 = 0 ;
5483 char * kwnames[] = {
5484 (char *) "self",(char *) "other", NULL
5485 };
5486
5487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5489 if (!SWIG_IsOK(res1)) {
5490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5491 }
5492 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5493 arg2 = obj1;
5494 {
5495 result = (bool)wxRealPoint___eq__(arg1,arg2);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj = 0;
5509 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5510 PyObject *arg2 = (PyObject *) 0 ;
5511 bool result;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "other", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 arg2 = obj1;
5527 {
5528 result = (bool)wxRealPoint___ne__(arg1,arg2);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj = 0;
5542 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5543 wxRealPoint *arg2 = 0 ;
5544 wxRealPoint result;
5545 void *argp1 = 0 ;
5546 int res1 = 0 ;
5547 wxRealPoint temp2 ;
5548 PyObject * obj0 = 0 ;
5549 PyObject * obj1 = 0 ;
5550 char * kwnames[] = {
5551 (char *) "self",(char *) "pt", NULL
5552 };
5553
5554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 arg2 = &temp2;
5562 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5563 }
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj = 0;
5579 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5580 wxRealPoint *arg2 = 0 ;
5581 wxRealPoint result;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 wxRealPoint temp2 ;
5585 PyObject * obj0 = 0 ;
5586 PyObject * obj1 = 0 ;
5587 char * kwnames[] = {
5588 (char *) "self",(char *) "pt", NULL
5589 };
5590
5591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5593 if (!SWIG_IsOK(res1)) {
5594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5595 }
5596 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5597 {
5598 arg2 = &temp2;
5599 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5600 }
5601 {
5602 PyThreadState* __tstate = wxPyBeginAllowThreads();
5603 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj = 0;
5616 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5617 double arg2 ;
5618 double arg3 ;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 double val2 ;
5622 int ecode2 = 0 ;
5623 double val3 ;
5624 int ecode3 = 0 ;
5625 PyObject * obj0 = 0 ;
5626 PyObject * obj1 = 0 ;
5627 PyObject * obj2 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "self",(char *) "x",(char *) "y", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5638 ecode2 = SWIG_AsVal_double(obj1, &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5641 }
5642 arg2 = static_cast< double >(val2);
5643 ecode3 = SWIG_AsVal_double(obj2, &val3);
5644 if (!SWIG_IsOK(ecode3)) {
5645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5646 }
5647 arg3 = static_cast< double >(val3);
5648 {
5649 PyThreadState* __tstate = wxPyBeginAllowThreads();
5650 wxRealPoint_Set(arg1,arg2,arg3);
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 resultobj = SWIG_Py_Void();
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5662 PyObject *resultobj = 0;
5663 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5664 PyObject *result = 0 ;
5665 void *argp1 = 0 ;
5666 int res1 = 0 ;
5667 PyObject *swig_obj[1] ;
5668
5669 if (!args) SWIG_fail;
5670 swig_obj[0] = args;
5671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5672 if (!SWIG_IsOK(res1)) {
5673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5674 }
5675 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5676 {
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 result = (PyObject *)wxRealPoint_Get(arg1);
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 resultobj = result;
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5690 PyObject *obj;
5691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5692 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5693 return SWIG_Py_Void();
5694 }
5695
5696 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5697 return SWIG_Python_InitShadowInstance(args);
5698 }
5699
5700 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5701 PyObject *resultobj = 0;
5702 wxPoint *arg1 = (wxPoint *) 0 ;
5703 int arg2 ;
5704 void *argp1 = 0 ;
5705 int res1 = 0 ;
5706 int val2 ;
5707 int ecode2 = 0 ;
5708 PyObject *swig_obj[2] ;
5709
5710 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5712 if (!SWIG_IsOK(res1)) {
5713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5714 }
5715 arg1 = reinterpret_cast< wxPoint * >(argp1);
5716 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5717 if (!SWIG_IsOK(ecode2)) {
5718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5719 }
5720 arg2 = static_cast< int >(val2);
5721 if (arg1) (arg1)->x = arg2;
5722
5723 resultobj = SWIG_Py_Void();
5724 return resultobj;
5725 fail:
5726 return NULL;
5727 }
5728
5729
5730 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5731 PyObject *resultobj = 0;
5732 wxPoint *arg1 = (wxPoint *) 0 ;
5733 int result;
5734 void *argp1 = 0 ;
5735 int res1 = 0 ;
5736 PyObject *swig_obj[1] ;
5737
5738 if (!args) SWIG_fail;
5739 swig_obj[0] = args;
5740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5741 if (!SWIG_IsOK(res1)) {
5742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5743 }
5744 arg1 = reinterpret_cast< wxPoint * >(argp1);
5745 result = (int) ((arg1)->x);
5746 resultobj = SWIG_From_int(static_cast< int >(result));
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 int arg2 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 int val2 ;
5760 int ecode2 = 0 ;
5761 PyObject *swig_obj[2] ;
5762
5763 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5765 if (!SWIG_IsOK(res1)) {
5766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5767 }
5768 arg1 = reinterpret_cast< wxPoint * >(argp1);
5769 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5770 if (!SWIG_IsOK(ecode2)) {
5771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5772 }
5773 arg2 = static_cast< int >(val2);
5774 if (arg1) (arg1)->y = arg2;
5775
5776 resultobj = SWIG_Py_Void();
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5784 PyObject *resultobj = 0;
5785 wxPoint *arg1 = (wxPoint *) 0 ;
5786 int result;
5787 void *argp1 = 0 ;
5788 int res1 = 0 ;
5789 PyObject *swig_obj[1] ;
5790
5791 if (!args) SWIG_fail;
5792 swig_obj[0] = args;
5793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5796 }
5797 arg1 = reinterpret_cast< wxPoint * >(argp1);
5798 result = (int) ((arg1)->y);
5799 resultobj = SWIG_From_int(static_cast< int >(result));
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj = 0;
5808 int arg1 = (int) 0 ;
5809 int arg2 = (int) 0 ;
5810 wxPoint *result = 0 ;
5811 int val1 ;
5812 int ecode1 = 0 ;
5813 int val2 ;
5814 int ecode2 = 0 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char * kwnames[] = {
5818 (char *) "x",(char *) "y", NULL
5819 };
5820
5821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5822 if (obj0) {
5823 ecode1 = SWIG_AsVal_int(obj0, &val1);
5824 if (!SWIG_IsOK(ecode1)) {
5825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5826 }
5827 arg1 = static_cast< int >(val1);
5828 }
5829 if (obj1) {
5830 ecode2 = SWIG_AsVal_int(obj1, &val2);
5831 if (!SWIG_IsOK(ecode2)) {
5832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5833 }
5834 arg2 = static_cast< int >(val2);
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (wxPoint *)new wxPoint(arg1,arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 PyObject *swig_obj[1] ;
5855
5856 if (!args) SWIG_fail;
5857 swig_obj[0] = args;
5858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5859 if (!SWIG_IsOK(res1)) {
5860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5861 }
5862 arg1 = reinterpret_cast< wxPoint * >(argp1);
5863 {
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 delete arg1;
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_Py_Void();
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj = 0;
5879 wxPoint *arg1 = (wxPoint *) 0 ;
5880 PyObject *arg2 = (PyObject *) 0 ;
5881 bool result;
5882 void *argp1 = 0 ;
5883 int res1 = 0 ;
5884 PyObject * obj0 = 0 ;
5885 PyObject * obj1 = 0 ;
5886 char * kwnames[] = {
5887 (char *) "self",(char *) "other", NULL
5888 };
5889
5890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5892 if (!SWIG_IsOK(res1)) {
5893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5894 }
5895 arg1 = reinterpret_cast< wxPoint * >(argp1);
5896 arg2 = obj1;
5897 {
5898 result = (bool)wxPoint___eq__(arg1,arg2);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 {
5902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5903 }
5904 return resultobj;
5905 fail:
5906 return NULL;
5907 }
5908
5909
5910 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5911 PyObject *resultobj = 0;
5912 wxPoint *arg1 = (wxPoint *) 0 ;
5913 PyObject *arg2 = (PyObject *) 0 ;
5914 bool result;
5915 void *argp1 = 0 ;
5916 int res1 = 0 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 char * kwnames[] = {
5920 (char *) "self",(char *) "other", NULL
5921 };
5922
5923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5925 if (!SWIG_IsOK(res1)) {
5926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5927 }
5928 arg1 = reinterpret_cast< wxPoint * >(argp1);
5929 arg2 = obj1;
5930 {
5931 result = (bool)wxPoint___ne__(arg1,arg2);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5936 }
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj = 0;
5945 wxPoint *arg1 = (wxPoint *) 0 ;
5946 wxPoint *arg2 = 0 ;
5947 wxPoint result;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 wxPoint temp2 ;
5951 PyObject * obj0 = 0 ;
5952 PyObject * obj1 = 0 ;
5953 char * kwnames[] = {
5954 (char *) "self",(char *) "pt", NULL
5955 };
5956
5957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5959 if (!SWIG_IsOK(res1)) {
5960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5961 }
5962 arg1 = reinterpret_cast< wxPoint * >(argp1);
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (arg1)->operator +((wxPoint const &)*arg2);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 wxPoint *arg2 = 0 ;
5984 wxPoint result;
5985 void *argp1 = 0 ;
5986 int res1 = 0 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "self",(char *) "pt", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5996 if (!SWIG_IsOK(res1)) {
5997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5998 }
5999 arg1 = reinterpret_cast< wxPoint * >(argp1);
6000 {
6001 arg2 = &temp2;
6002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6003 }
6004 {
6005 PyThreadState* __tstate = wxPyBeginAllowThreads();
6006 result = (arg1)->operator -((wxPoint const &)*arg2);
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj = 0;
6019 wxPoint *arg1 = (wxPoint *) 0 ;
6020 wxPoint *arg2 = 0 ;
6021 wxPoint *result = 0 ;
6022 void *argp1 = 0 ;
6023 int res1 = 0 ;
6024 wxPoint temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "self",(char *) "pt", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6033 if (!SWIG_IsOK(res1)) {
6034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6035 }
6036 arg1 = reinterpret_cast< wxPoint * >(argp1);
6037 {
6038 arg2 = &temp2;
6039 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6040 }
6041 {
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 {
6044 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6045 result = (wxPoint *) &_result_ref;
6046 }
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6058 PyObject *resultobj = 0;
6059 wxPoint *arg1 = (wxPoint *) 0 ;
6060 wxPoint *arg2 = 0 ;
6061 wxPoint *result = 0 ;
6062 void *argp1 = 0 ;
6063 int res1 = 0 ;
6064 wxPoint temp2 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 char * kwnames[] = {
6068 (char *) "self",(char *) "pt", NULL
6069 };
6070
6071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6073 if (!SWIG_IsOK(res1)) {
6074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6075 }
6076 arg1 = reinterpret_cast< wxPoint * >(argp1);
6077 {
6078 arg2 = &temp2;
6079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6080 }
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 {
6084 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6085 result = (wxPoint *) &_result_ref;
6086 }
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6091 return resultobj;
6092 fail:
6093 return NULL;
6094 }
6095
6096
6097 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6098 PyObject *resultobj = 0;
6099 wxPoint *arg1 = (wxPoint *) 0 ;
6100 long arg2 ;
6101 long arg3 ;
6102 void *argp1 = 0 ;
6103 int res1 = 0 ;
6104 long val2 ;
6105 int ecode2 = 0 ;
6106 long val3 ;
6107 int ecode3 = 0 ;
6108 PyObject * obj0 = 0 ;
6109 PyObject * obj1 = 0 ;
6110 PyObject * obj2 = 0 ;
6111 char * kwnames[] = {
6112 (char *) "self",(char *) "x",(char *) "y", NULL
6113 };
6114
6115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6117 if (!SWIG_IsOK(res1)) {
6118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6119 }
6120 arg1 = reinterpret_cast< wxPoint * >(argp1);
6121 ecode2 = SWIG_AsVal_long(obj1, &val2);
6122 if (!SWIG_IsOK(ecode2)) {
6123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6124 }
6125 arg2 = static_cast< long >(val2);
6126 ecode3 = SWIG_AsVal_long(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6129 }
6130 arg3 = static_cast< long >(val3);
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 wxPoint_Set(arg1,arg2,arg3);
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 resultobj = SWIG_Py_Void();
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6145 PyObject *resultobj = 0;
6146 wxPoint *arg1 = (wxPoint *) 0 ;
6147 PyObject *result = 0 ;
6148 void *argp1 = 0 ;
6149 int res1 = 0 ;
6150 PyObject *swig_obj[1] ;
6151
6152 if (!args) SWIG_fail;
6153 swig_obj[0] = args;
6154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6155 if (!SWIG_IsOK(res1)) {
6156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6157 }
6158 arg1 = reinterpret_cast< wxPoint * >(argp1);
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (PyObject *)wxPoint_Get(arg1);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = result;
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6173 PyObject *obj;
6174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6175 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6176 return SWIG_Py_Void();
6177 }
6178
6179 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 return SWIG_Python_InitShadowInstance(args);
6181 }
6182
6183 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 int arg1 = (int) 0 ;
6186 int arg2 = (int) 0 ;
6187 int arg3 = (int) 0 ;
6188 int arg4 = (int) 0 ;
6189 wxRect *result = 0 ;
6190 int val1 ;
6191 int ecode1 = 0 ;
6192 int val2 ;
6193 int ecode2 = 0 ;
6194 int val3 ;
6195 int ecode3 = 0 ;
6196 int val4 ;
6197 int ecode4 = 0 ;
6198 PyObject * obj0 = 0 ;
6199 PyObject * obj1 = 0 ;
6200 PyObject * obj2 = 0 ;
6201 PyObject * obj3 = 0 ;
6202 char * kwnames[] = {
6203 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6204 };
6205
6206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6207 if (obj0) {
6208 ecode1 = SWIG_AsVal_int(obj0, &val1);
6209 if (!SWIG_IsOK(ecode1)) {
6210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6211 }
6212 arg1 = static_cast< int >(val1);
6213 }
6214 if (obj1) {
6215 ecode2 = SWIG_AsVal_int(obj1, &val2);
6216 if (!SWIG_IsOK(ecode2)) {
6217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6218 }
6219 arg2 = static_cast< int >(val2);
6220 }
6221 if (obj2) {
6222 ecode3 = SWIG_AsVal_int(obj2, &val3);
6223 if (!SWIG_IsOK(ecode3)) {
6224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6225 }
6226 arg3 = static_cast< int >(val3);
6227 }
6228 if (obj3) {
6229 ecode4 = SWIG_AsVal_int(obj3, &val4);
6230 if (!SWIG_IsOK(ecode4)) {
6231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6232 }
6233 arg4 = static_cast< int >(val4);
6234 }
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj = 0;
6250 wxPoint *arg1 = 0 ;
6251 wxPoint *arg2 = 0 ;
6252 wxRect *result = 0 ;
6253 wxPoint temp1 ;
6254 wxPoint temp2 ;
6255 PyObject * obj0 = 0 ;
6256 PyObject * obj1 = 0 ;
6257 char * kwnames[] = {
6258 (char *) "topLeft",(char *) "bottomRight", NULL
6259 };
6260
6261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6262 {
6263 arg1 = &temp1;
6264 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6265 }
6266 {
6267 arg2 = &temp2;
6268 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6269 }
6270 {
6271 PyThreadState* __tstate = wxPyBeginAllowThreads();
6272 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6273 wxPyEndAllowThreads(__tstate);
6274 if (PyErr_Occurred()) SWIG_fail;
6275 }
6276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj = 0;
6285 wxPoint *arg1 = 0 ;
6286 wxSize *arg2 = 0 ;
6287 wxRect *result = 0 ;
6288 wxPoint temp1 ;
6289 wxSize temp2 ;
6290 PyObject * obj0 = 0 ;
6291 PyObject * obj1 = 0 ;
6292 char * kwnames[] = {
6293 (char *) "pos",(char *) "size", NULL
6294 };
6295
6296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6297 {
6298 arg1 = &temp1;
6299 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6300 }
6301 {
6302 arg2 = &temp2;
6303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6304 }
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj = 0;
6320 wxSize *arg1 = 0 ;
6321 wxRect *result = 0 ;
6322 wxSize temp1 ;
6323 PyObject * obj0 = 0 ;
6324 char * kwnames[] = {
6325 (char *) "size", NULL
6326 };
6327
6328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6329 {
6330 arg1 = &temp1;
6331 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6332 }
6333 {
6334 PyThreadState* __tstate = wxPyBeginAllowThreads();
6335 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6336 wxPyEndAllowThreads(__tstate);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 delete arg1;
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_Py_Void();
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6375 PyObject *resultobj = 0;
6376 wxRect *arg1 = (wxRect *) 0 ;
6377 int result;
6378 void *argp1 = 0 ;
6379 int res1 = 0 ;
6380 PyObject *swig_obj[1] ;
6381
6382 if (!args) SWIG_fail;
6383 swig_obj[0] = args;
6384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6385 if (!SWIG_IsOK(res1)) {
6386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6387 }
6388 arg1 = reinterpret_cast< wxRect * >(argp1);
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 result = (int)((wxRect const *)arg1)->GetX();
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 resultobj = SWIG_From_int(static_cast< int >(result));
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj = 0;
6404 wxRect *arg1 = (wxRect *) 0 ;
6405 int arg2 ;
6406 void *argp1 = 0 ;
6407 int res1 = 0 ;
6408 int val2 ;
6409 int ecode2 = 0 ;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char * kwnames[] = {
6413 (char *) "self",(char *) "x", NULL
6414 };
6415
6416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6418 if (!SWIG_IsOK(res1)) {
6419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6420 }
6421 arg1 = reinterpret_cast< wxRect * >(argp1);
6422 ecode2 = SWIG_AsVal_int(obj1, &val2);
6423 if (!SWIG_IsOK(ecode2)) {
6424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6425 }
6426 arg2 = static_cast< int >(val2);
6427 {
6428 PyThreadState* __tstate = wxPyBeginAllowThreads();
6429 (arg1)->SetX(arg2);
6430 wxPyEndAllowThreads(__tstate);
6431 if (PyErr_Occurred()) SWIG_fail;
6432 }
6433 resultobj = SWIG_Py_Void();
6434 return resultobj;
6435 fail:
6436 return NULL;
6437 }
6438
6439
6440 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6441 PyObject *resultobj = 0;
6442 wxRect *arg1 = (wxRect *) 0 ;
6443 int result;
6444 void *argp1 = 0 ;
6445 int res1 = 0 ;
6446 PyObject *swig_obj[1] ;
6447
6448 if (!args) SWIG_fail;
6449 swig_obj[0] = args;
6450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6451 if (!SWIG_IsOK(res1)) {
6452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6453 }
6454 arg1 = reinterpret_cast< wxRect * >(argp1);
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (int)(arg1)->GetY();
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 resultobj = SWIG_From_int(static_cast< int >(result));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj = 0;
6470 wxRect *arg1 = (wxRect *) 0 ;
6471 int arg2 ;
6472 void *argp1 = 0 ;
6473 int res1 = 0 ;
6474 int val2 ;
6475 int ecode2 = 0 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char * kwnames[] = {
6479 (char *) "self",(char *) "y", NULL
6480 };
6481
6482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6484 if (!SWIG_IsOK(res1)) {
6485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6486 }
6487 arg1 = reinterpret_cast< wxRect * >(argp1);
6488 ecode2 = SWIG_AsVal_int(obj1, &val2);
6489 if (!SWIG_IsOK(ecode2)) {
6490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6491 }
6492 arg2 = static_cast< int >(val2);
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 (arg1)->SetY(arg2);
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 resultobj = SWIG_Py_Void();
6500 return resultobj;
6501 fail:
6502 return NULL;
6503 }
6504
6505
6506 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6507 PyObject *resultobj = 0;
6508 wxRect *arg1 = (wxRect *) 0 ;
6509 int result;
6510 void *argp1 = 0 ;
6511 int res1 = 0 ;
6512 PyObject *swig_obj[1] ;
6513
6514 if (!args) SWIG_fail;
6515 swig_obj[0] = args;
6516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6519 }
6520 arg1 = reinterpret_cast< wxRect * >(argp1);
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (int)((wxRect const *)arg1)->GetWidth();
6524 wxPyEndAllowThreads(__tstate);
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_SetWidth(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 *) "w", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",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_SetWidth" "', 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_SetWidth" "', expected argument " "2"" of type '" "int""'");
6557 }
6558 arg2 = static_cast< int >(val2);
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 (arg1)->SetWidth(arg2);
6562 wxPyEndAllowThreads(__tstate);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 resultobj = SWIG_Py_Void();
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6573 PyObject *resultobj = 0;
6574 wxRect *arg1 = (wxRect *) 0 ;
6575 int result;
6576 void *argp1 = 0 ;
6577 int res1 = 0 ;
6578 PyObject *swig_obj[1] ;
6579
6580 if (!args) SWIG_fail;
6581 swig_obj[0] = args;
6582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6583 if (!SWIG_IsOK(res1)) {
6584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6585 }
6586 arg1 = reinterpret_cast< wxRect * >(argp1);
6587 {
6588 PyThreadState* __tstate = wxPyBeginAllowThreads();
6589 result = (int)((wxRect const *)arg1)->GetHeight();
6590 wxPyEndAllowThreads(__tstate);
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 (arg1)->SetHeight(arg2);
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 resultobj = SWIG_Py_Void();
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639 PyObject *resultobj = 0;
6640 wxRect *arg1 = (wxRect *) 0 ;
6641 wxPoint result;
6642 void *argp1 = 0 ;
6643 int res1 = 0 ;
6644 PyObject *swig_obj[1] ;
6645
6646 if (!args) SWIG_fail;
6647 swig_obj[0] = args;
6648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 result = ((wxRect const *)arg1)->GetPosition();
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6660 return resultobj;
6661 fail:
6662 return NULL;
6663 }
6664
6665
6666 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6667 PyObject *resultobj = 0;
6668 wxRect *arg1 = (wxRect *) 0 ;
6669 wxPoint *arg2 = 0 ;
6670 void *argp1 = 0 ;
6671 int res1 = 0 ;
6672 wxPoint temp2 ;
6673 PyObject * obj0 = 0 ;
6674 PyObject * obj1 = 0 ;
6675 char * kwnames[] = {
6676 (char *) "self",(char *) "p", NULL
6677 };
6678
6679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 arg2 = &temp2;
6687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->SetPosition((wxPoint const &)*arg2);
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 resultobj = SWIG_Py_Void();
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6703 PyObject *resultobj = 0;
6704 wxRect *arg1 = (wxRect *) 0 ;
6705 wxSize result;
6706 void *argp1 = 0 ;
6707 int res1 = 0 ;
6708 PyObject *swig_obj[1] ;
6709
6710 if (!args) SWIG_fail;
6711 swig_obj[0] = args;
6712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6713 if (!SWIG_IsOK(res1)) {
6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6715 }
6716 arg1 = reinterpret_cast< wxRect * >(argp1);
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = ((wxRect const *)arg1)->GetSize();
6720 wxPyEndAllowThreads(__tstate);
6721 if (PyErr_Occurred()) SWIG_fail;
6722 }
6723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6724 return resultobj;
6725 fail:
6726 return NULL;
6727 }
6728
6729
6730 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6731 PyObject *resultobj = 0;
6732 wxRect *arg1 = (wxRect *) 0 ;
6733 wxSize *arg2 = 0 ;
6734 void *argp1 = 0 ;
6735 int res1 = 0 ;
6736 wxSize temp2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char * kwnames[] = {
6740 (char *) "self",(char *) "s", NULL
6741 };
6742
6743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6745 if (!SWIG_IsOK(res1)) {
6746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6747 }
6748 arg1 = reinterpret_cast< wxRect * >(argp1);
6749 {
6750 arg2 = &temp2;
6751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6752 }
6753 {
6754 PyThreadState* __tstate = wxPyBeginAllowThreads();
6755 (arg1)->SetSize((wxSize const &)*arg2);
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 resultobj = SWIG_Py_Void();
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 wxRect *arg1 = (wxRect *) 0 ;
6769 bool result;
6770 void *argp1 = 0 ;
6771 int res1 = 0 ;
6772 PyObject *swig_obj[1] ;
6773
6774 if (!args) SWIG_fail;
6775 swig_obj[0] = args;
6776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6777 if (!SWIG_IsOK(res1)) {
6778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6779 }
6780 arg1 = reinterpret_cast< wxRect * >(argp1);
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 result = (bool)((wxRect const *)arg1)->IsEmpty();
6784 wxPyEndAllowThreads(__tstate);
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 {
6788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6789 }
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6797 PyObject *resultobj = 0;
6798 wxRect *arg1 = (wxRect *) 0 ;
6799 wxPoint result;
6800 void *argp1 = 0 ;
6801 int res1 = 0 ;
6802 PyObject *swig_obj[1] ;
6803
6804 if (!args) SWIG_fail;
6805 swig_obj[0] = args;
6806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 PyThreadState* __tstate = wxPyBeginAllowThreads();
6813 result = ((wxRect const *)arg1)->GetTopLeft();
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj = 0;
6826 wxRect *arg1 = (wxRect *) 0 ;
6827 wxPoint *arg2 = 0 ;
6828 void *argp1 = 0 ;
6829 int res1 = 0 ;
6830 wxPoint temp2 ;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 char * kwnames[] = {
6834 (char *) "self",(char *) "p", NULL
6835 };
6836
6837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 arg2 = &temp2;
6845 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6846 }
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 resultobj = SWIG_Py_Void();
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 wxRect *arg1 = (wxRect *) 0 ;
6863 wxPoint result;
6864 void *argp1 = 0 ;
6865 int res1 = 0 ;
6866 PyObject *swig_obj[1] ;
6867
6868 if (!args) SWIG_fail;
6869 swig_obj[0] = args;
6870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6871 if (!SWIG_IsOK(res1)) {
6872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6873 }
6874 arg1 = reinterpret_cast< wxRect * >(argp1);
6875 {
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = ((wxRect const *)arg1)->GetBottomRight();
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj = 0;
6890 wxRect *arg1 = (wxRect *) 0 ;
6891 wxPoint *arg2 = 0 ;
6892 void *argp1 = 0 ;
6893 int res1 = 0 ;
6894 wxPoint temp2 ;
6895 PyObject * obj0 = 0 ;
6896 PyObject * obj1 = 0 ;
6897 char * kwnames[] = {
6898 (char *) "self",(char *) "p", NULL
6899 };
6900
6901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 arg2 = &temp2;
6909 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6910 }
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_Py_Void();
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxRect *arg1 = (wxRect *) 0 ;
6927 wxPoint result;
6928 void *argp1 = 0 ;
6929 int res1 = 0 ;
6930 PyObject *swig_obj[1] ;
6931
6932 if (!args) SWIG_fail;
6933 swig_obj[0] = args;
6934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6935 if (!SWIG_IsOK(res1)) {
6936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6937 }
6938 arg1 = reinterpret_cast< wxRect * >(argp1);
6939 {
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = ((wxRect const *)arg1)->GetTopRight();
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6953 PyObject *resultobj = 0;
6954 wxRect *arg1 = (wxRect *) 0 ;
6955 wxPoint *arg2 = 0 ;
6956 void *argp1 = 0 ;
6957 int res1 = 0 ;
6958 wxPoint temp2 ;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char * kwnames[] = {
6962 (char *) "self",(char *) "p", NULL
6963 };
6964
6965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6967 if (!SWIG_IsOK(res1)) {
6968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6969 }
6970 arg1 = reinterpret_cast< wxRect * >(argp1);
6971 {
6972 arg2 = &temp2;
6973 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 (arg1)->SetTopRight((wxPoint const &)*arg2);
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 resultobj = SWIG_Py_Void();
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6989 PyObject *resultobj = 0;
6990 wxRect *arg1 = (wxRect *) 0 ;
6991 wxPoint result;
6992 void *argp1 = 0 ;
6993 int res1 = 0 ;
6994 PyObject *swig_obj[1] ;
6995
6996 if (!args) SWIG_fail;
6997 swig_obj[0] = args;
6998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7001 }
7002 arg1 = reinterpret_cast< wxRect * >(argp1);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = ((wxRect const *)arg1)->GetBottomLeft();
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 wxPoint *arg2 = 0 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 wxPoint temp2 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "p", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 {
7036 arg2 = &temp2;
7037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7038 }
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_Py_Void();
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7053 PyObject *resultobj = 0;
7054 wxRect *arg1 = (wxRect *) 0 ;
7055 int result;
7056 void *argp1 = 0 ;
7057 int res1 = 0 ;
7058 PyObject *swig_obj[1] ;
7059
7060 if (!args) SWIG_fail;
7061 swig_obj[0] = args;
7062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7063 if (!SWIG_IsOK(res1)) {
7064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7065 }
7066 arg1 = reinterpret_cast< wxRect * >(argp1);
7067 {
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (int)((wxRect const *)arg1)->GetLeft();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_From_int(static_cast< int >(result));
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7081 PyObject *resultobj = 0;
7082 wxRect *arg1 = (wxRect *) 0 ;
7083 int result;
7084 void *argp1 = 0 ;
7085 int res1 = 0 ;
7086 PyObject *swig_obj[1] ;
7087
7088 if (!args) SWIG_fail;
7089 swig_obj[0] = args;
7090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7091 if (!SWIG_IsOK(res1)) {
7092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7093 }
7094 arg1 = reinterpret_cast< wxRect * >(argp1);
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (int)((wxRect const *)arg1)->GetTop();
7098 wxPyEndAllowThreads(__tstate);
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_GetBottom(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_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7121 }
7122 arg1 = reinterpret_cast< wxRect * >(argp1);
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (int)((wxRect const *)arg1)->GetBottom();
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_From_int(static_cast< int >(result));
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxRect *arg1 = (wxRect *) 0 ;
7139 int result;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 PyObject *swig_obj[1] ;
7143
7144 if (!args) SWIG_fail;
7145 swig_obj[0] = args;
7146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7147 if (!SWIG_IsOK(res1)) {
7148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7149 }
7150 arg1 = reinterpret_cast< wxRect * >(argp1);
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (int)((wxRect const *)arg1)->GetRight();
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_From_int(static_cast< int >(result));
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "left", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 (arg1)->SetLeft(arg2);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_Py_Void();
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 int arg2 ;
7206 void *argp1 = 0 ;
7207 int res1 = 0 ;
7208 int val2 ;
7209 int ecode2 = 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "right", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 ecode2 = SWIG_AsVal_int(obj1, &val2);
7223 if (!SWIG_IsOK(ecode2)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7225 }
7226 arg2 = static_cast< int >(val2);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->SetRight(arg2);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 int arg2 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 int val2 ;
7247 int ecode2 = 0 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "top", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 ecode2 = SWIG_AsVal_int(obj1, &val2);
7261 if (!SWIG_IsOK(ecode2)) {
7262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7263 }
7264 arg2 = static_cast< int >(val2);
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 (arg1)->SetTop(arg2);
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 resultobj = SWIG_Py_Void();
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj = 0;
7280 wxRect *arg1 = (wxRect *) 0 ;
7281 int arg2 ;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 int val2 ;
7285 int ecode2 = 0 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "bottom", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7296 }
7297 arg1 = reinterpret_cast< wxRect * >(argp1);
7298 ecode2 = SWIG_AsVal_int(obj1, &val2);
7299 if (!SWIG_IsOK(ecode2)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7301 }
7302 arg2 = static_cast< int >(val2);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->SetBottom(arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_Py_Void();
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 int arg2 ;
7320 int arg3 ;
7321 wxRect *result = 0 ;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 int val2 ;
7325 int ecode2 = 0 ;
7326 int val3 ;
7327 int ecode3 = 0 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 PyObject * obj2 = 0 ;
7331 char * kwnames[] = {
7332 (char *) "self",(char *) "dx",(char *) "dy", NULL
7333 };
7334
7335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7337 if (!SWIG_IsOK(res1)) {
7338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7339 }
7340 arg1 = reinterpret_cast< wxRect * >(argp1);
7341 ecode2 = SWIG_AsVal_int(obj1, &val2);
7342 if (!SWIG_IsOK(ecode2)) {
7343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7344 }
7345 arg2 = static_cast< int >(val2);
7346 ecode3 = SWIG_AsVal_int(obj2, &val3);
7347 if (!SWIG_IsOK(ecode3)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7349 }
7350 arg3 = static_cast< int >(val3);
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 {
7354 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7355 result = (wxRect *) &_result_ref;
7356 }
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 int arg2 ;
7371 int arg3 ;
7372 wxRect *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 int val2 ;
7376 int ecode2 = 0 ;
7377 int val3 ;
7378 int ecode3 = 0 ;
7379 PyObject * obj0 = 0 ;
7380 PyObject * obj1 = 0 ;
7381 PyObject * obj2 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "dx",(char *) "dy", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 ecode2 = SWIG_AsVal_int(obj1, &val2);
7393 if (!SWIG_IsOK(ecode2)) {
7394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7395 }
7396 arg2 = static_cast< int >(val2);
7397 ecode3 = SWIG_AsVal_int(obj2, &val3);
7398 if (!SWIG_IsOK(ecode3)) {
7399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7400 }
7401 arg3 = static_cast< int >(val3);
7402 {
7403 PyThreadState* __tstate = wxPyBeginAllowThreads();
7404 {
7405 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7406 result = (wxRect *) &_result_ref;
7407 }
7408 wxPyEndAllowThreads(__tstate);
7409 if (PyErr_Occurred()) SWIG_fail;
7410 }
7411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7412 return resultobj;
7413 fail:
7414 return NULL;
7415 }
7416
7417
7418 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7419 PyObject *resultobj = 0;
7420 wxRect *arg1 = (wxRect *) 0 ;
7421 int arg2 ;
7422 int arg3 ;
7423 void *argp1 = 0 ;
7424 int res1 = 0 ;
7425 int val2 ;
7426 int ecode2 = 0 ;
7427 int val3 ;
7428 int ecode3 = 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 PyObject * obj2 = 0 ;
7432 char * kwnames[] = {
7433 (char *) "self",(char *) "dx",(char *) "dy", NULL
7434 };
7435
7436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7440 }
7441 arg1 = reinterpret_cast< wxRect * >(argp1);
7442 ecode2 = SWIG_AsVal_int(obj1, &val2);
7443 if (!SWIG_IsOK(ecode2)) {
7444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7445 }
7446 arg2 = static_cast< int >(val2);
7447 ecode3 = SWIG_AsVal_int(obj2, &val3);
7448 if (!SWIG_IsOK(ecode3)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7450 }
7451 arg3 = static_cast< int >(val3);
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 (arg1)->Offset(arg2,arg3);
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 resultobj = SWIG_Py_Void();
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxPoint *arg2 = 0 ;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxPoint temp2 ;
7472 PyObject * obj0 = 0 ;
7473 PyObject * obj1 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "pt", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7480 if (!SWIG_IsOK(res1)) {
7481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7482 }
7483 arg1 = reinterpret_cast< wxRect * >(argp1);
7484 {
7485 arg2 = &temp2;
7486 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7487 }
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->Offset((wxPoint const &)*arg2);
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 resultobj = SWIG_Py_Void();
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj = 0;
7503 wxRect *arg1 = (wxRect *) 0 ;
7504 wxRect *arg2 = 0 ;
7505 wxRect result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 wxRect temp2 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "rect", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7519 }
7520 arg1 = reinterpret_cast< wxRect * >(argp1);
7521 {
7522 arg2 = &temp2;
7523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7524 }
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 result = (arg1)->Intersect((wxRect const &)*arg2);
7528 wxPyEndAllowThreads(__tstate);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj = 0;
7540 wxRect *arg1 = (wxRect *) 0 ;
7541 wxRect *arg2 = 0 ;
7542 wxRect result;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 wxRect temp2 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char * kwnames[] = {
7549 (char *) "self",(char *) "rect", NULL
7550 };
7551
7552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 {
7559 arg2 = &temp2;
7560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 result = (arg1)->Union((wxRect const &)*arg2);
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj = 0;
7577 wxRect *arg1 = (wxRect *) 0 ;
7578 wxRect *arg2 = 0 ;
7579 wxRect result;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 wxRect temp2 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char * kwnames[] = {
7586 (char *) "self",(char *) "rect", NULL
7587 };
7588
7589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7593 }
7594 arg1 = reinterpret_cast< wxRect * >(argp1);
7595 {
7596 arg2 = &temp2;
7597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7598 }
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = 0;
7614 wxRect *arg1 = (wxRect *) 0 ;
7615 wxRect *arg2 = 0 ;
7616 wxRect *result = 0 ;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 wxRect temp2 ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char * kwnames[] = {
7623 (char *) "self",(char *) "rect", NULL
7624 };
7625
7626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7630 }
7631 arg1 = reinterpret_cast< wxRect * >(argp1);
7632 {
7633 arg2 = &temp2;
7634 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 {
7639 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7640 result = (wxRect *) &_result_ref;
7641 }
7642 wxPyEndAllowThreads(__tstate);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj = 0;
7654 wxRect *arg1 = (wxRect *) 0 ;
7655 PyObject *arg2 = (PyObject *) 0 ;
7656 bool result;
7657 void *argp1 = 0 ;
7658 int res1 = 0 ;
7659 PyObject * obj0 = 0 ;
7660 PyObject * obj1 = 0 ;
7661 char * kwnames[] = {
7662 (char *) "self",(char *) "other", NULL
7663 };
7664
7665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 arg2 = obj1;
7672 {
7673 result = (bool)wxRect___eq__(arg1,arg2);
7674 if (PyErr_Occurred()) SWIG_fail;
7675 }
7676 {
7677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7678 }
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 PyObject *arg2 = (PyObject *) 0 ;
7689 bool result;
7690 void *argp1 = 0 ;
7691 int res1 = 0 ;
7692 PyObject * obj0 = 0 ;
7693 PyObject * obj1 = 0 ;
7694 char * kwnames[] = {
7695 (char *) "self",(char *) "other", NULL
7696 };
7697
7698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7702 }
7703 arg1 = reinterpret_cast< wxRect * >(argp1);
7704 arg2 = obj1;
7705 {
7706 result = (bool)wxRect___ne__(arg1,arg2);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj = 0;
7720 wxRect *arg1 = (wxRect *) 0 ;
7721 int arg2 ;
7722 int arg3 ;
7723 bool result;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 int val2 ;
7727 int ecode2 = 0 ;
7728 int val3 ;
7729 int ecode3 = 0 ;
7730 PyObject * obj0 = 0 ;
7731 PyObject * obj1 = 0 ;
7732 PyObject * obj2 = 0 ;
7733 char * kwnames[] = {
7734 (char *) "self",(char *) "x",(char *) "y", NULL
7735 };
7736
7737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7739 if (!SWIG_IsOK(res1)) {
7740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7741 }
7742 arg1 = reinterpret_cast< wxRect * >(argp1);
7743 ecode2 = SWIG_AsVal_int(obj1, &val2);
7744 if (!SWIG_IsOK(ecode2)) {
7745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7746 }
7747 arg2 = static_cast< int >(val2);
7748 ecode3 = SWIG_AsVal_int(obj2, &val3);
7749 if (!SWIG_IsOK(ecode3)) {
7750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7751 }
7752 arg3 = static_cast< int >(val3);
7753 {
7754 PyThreadState* __tstate = wxPyBeginAllowThreads();
7755 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7761 }
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj = 0;
7770 wxRect *arg1 = (wxRect *) 0 ;
7771 wxPoint *arg2 = 0 ;
7772 bool result;
7773 void *argp1 = 0 ;
7774 int res1 = 0 ;
7775 wxPoint temp2 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "pt", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7786 }
7787 arg1 = reinterpret_cast< wxRect * >(argp1);
7788 {
7789 arg2 = &temp2;
7790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7795 wxPyEndAllowThreads(__tstate);
7796 if (PyErr_Occurred()) SWIG_fail;
7797 }
7798 {
7799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7800 }
7801 return resultobj;
7802 fail:
7803 return NULL;
7804 }
7805
7806
7807 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7808 PyObject *resultobj = 0;
7809 wxRect *arg1 = (wxRect *) 0 ;
7810 wxRect *arg2 = 0 ;
7811 bool result;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 wxRect temp2 ;
7815 PyObject * obj0 = 0 ;
7816 PyObject * obj1 = 0 ;
7817 char * kwnames[] = {
7818 (char *) "self",(char *) "rect", NULL
7819 };
7820
7821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7823 if (!SWIG_IsOK(res1)) {
7824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7825 }
7826 arg1 = reinterpret_cast< wxRect * >(argp1);
7827 {
7828 arg2 = &temp2;
7829 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7830 }
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj = 0;
7848 wxRect *arg1 = (wxRect *) 0 ;
7849 wxRect *arg2 = 0 ;
7850 bool result;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 wxRect temp2 ;
7854 PyObject * obj0 = 0 ;
7855 PyObject * obj1 = 0 ;
7856 char * kwnames[] = {
7857 (char *) "self",(char *) "rect", NULL
7858 };
7859
7860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7862 if (!SWIG_IsOK(res1)) {
7863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7864 }
7865 arg1 = reinterpret_cast< wxRect * >(argp1);
7866 {
7867 arg2 = &temp2;
7868 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7869 }
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 {
7877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7878 }
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7886 PyObject *resultobj = 0;
7887 wxRect *arg1 = (wxRect *) 0 ;
7888 wxRect *arg2 = 0 ;
7889 int arg3 = (int) wxBOTH ;
7890 wxRect result;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 wxRect temp2 ;
7894 int val3 ;
7895 int ecode3 = 0 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 PyObject * obj2 = 0 ;
7899 char * kwnames[] = {
7900 (char *) "self",(char *) "r",(char *) "dir", NULL
7901 };
7902
7903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7905 if (!SWIG_IsOK(res1)) {
7906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7907 }
7908 arg1 = reinterpret_cast< wxRect * >(argp1);
7909 {
7910 arg2 = &temp2;
7911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7912 }
7913 if (obj2) {
7914 ecode3 = SWIG_AsVal_int(obj2, &val3);
7915 if (!SWIG_IsOK(ecode3)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7917 }
7918 arg3 = static_cast< int >(val3);
7919 }
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 PyObject *resultobj = 0;
7935 wxRect *arg1 = (wxRect *) 0 ;
7936 int arg2 ;
7937 void *argp1 = 0 ;
7938 int res1 = 0 ;
7939 int val2 ;
7940 int ecode2 = 0 ;
7941 PyObject *swig_obj[2] ;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7947 }
7948 arg1 = reinterpret_cast< wxRect * >(argp1);
7949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7952 }
7953 arg2 = static_cast< int >(val2);
7954 if (arg1) (arg1)->x = arg2;
7955
7956 resultobj = SWIG_Py_Void();
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *resultobj = 0;
7965 wxRect *arg1 = (wxRect *) 0 ;
7966 int result;
7967 void *argp1 = 0 ;
7968 int res1 = 0 ;
7969 PyObject *swig_obj[1] ;
7970
7971 if (!args) SWIG_fail;
7972 swig_obj[0] = args;
7973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7976 }
7977 arg1 = reinterpret_cast< wxRect * >(argp1);
7978 result = (int) ((arg1)->x);
7979 resultobj = SWIG_From_int(static_cast< int >(result));
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxRect *arg1 = (wxRect *) 0 ;
7989 int arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 int val2 ;
7993 int ecode2 = 0 ;
7994 PyObject *swig_obj[2] ;
7995
7996 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8003 if (!SWIG_IsOK(ecode2)) {
8004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8005 }
8006 arg2 = static_cast< int >(val2);
8007 if (arg1) (arg1)->y = arg2;
8008
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxRect *arg1 = (wxRect *) 0 ;
8019 int result;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 PyObject *swig_obj[1] ;
8023
8024 if (!args) SWIG_fail;
8025 swig_obj[0] = args;
8026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8027 if (!SWIG_IsOK(res1)) {
8028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8029 }
8030 arg1 = reinterpret_cast< wxRect * >(argp1);
8031 result = (int) ((arg1)->y);
8032 resultobj = SWIG_From_int(static_cast< int >(result));
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxRect *arg1 = (wxRect *) 0 ;
8042 int arg2 ;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 int val2 ;
8046 int ecode2 = 0 ;
8047 PyObject *swig_obj[2] ;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8056 if (!SWIG_IsOK(ecode2)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8058 }
8059 arg2 = static_cast< int >(val2);
8060 if (arg1) (arg1)->width = arg2;
8061
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxRect *arg1 = (wxRect *) 0 ;
8072 int result;
8073 void *argp1 = 0 ;
8074 int res1 = 0 ;
8075 PyObject *swig_obj[1] ;
8076
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8082 }
8083 arg1 = reinterpret_cast< wxRect * >(argp1);
8084 result = (int) ((arg1)->width);
8085 resultobj = SWIG_From_int(static_cast< int >(result));
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxRect *arg1 = (wxRect *) 0 ;
8095 int arg2 ;
8096 void *argp1 = 0 ;
8097 int res1 = 0 ;
8098 int val2 ;
8099 int ecode2 = 0 ;
8100 PyObject *swig_obj[2] ;
8101
8102 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 if (arg1) (arg1)->height = arg2;
8114
8115 resultobj = SWIG_Py_Void();
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxRect *arg1 = (wxRect *) 0 ;
8125 int result;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 PyObject *swig_obj[1] ;
8129
8130 if (!args) SWIG_fail;
8131 swig_obj[0] = args;
8132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8133 if (!SWIG_IsOK(res1)) {
8134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8135 }
8136 arg1 = reinterpret_cast< wxRect * >(argp1);
8137 result = (int) ((arg1)->height);
8138 resultobj = SWIG_From_int(static_cast< int >(result));
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 int arg2 = (int) 0 ;
8149 int arg3 = (int) 0 ;
8150 int arg4 = (int) 0 ;
8151 int arg5 = (int) 0 ;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 int val2 ;
8155 int ecode2 = 0 ;
8156 int val3 ;
8157 int ecode3 = 0 ;
8158 int val4 ;
8159 int ecode4 = 0 ;
8160 int val5 ;
8161 int ecode5 = 0 ;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 PyObject * obj2 = 0 ;
8165 PyObject * obj3 = 0 ;
8166 PyObject * obj4 = 0 ;
8167 char * kwnames[] = {
8168 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8169 };
8170
8171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8173 if (!SWIG_IsOK(res1)) {
8174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8175 }
8176 arg1 = reinterpret_cast< wxRect * >(argp1);
8177 if (obj1) {
8178 ecode2 = SWIG_AsVal_int(obj1, &val2);
8179 if (!SWIG_IsOK(ecode2)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8181 }
8182 arg2 = static_cast< int >(val2);
8183 }
8184 if (obj2) {
8185 ecode3 = SWIG_AsVal_int(obj2, &val3);
8186 if (!SWIG_IsOK(ecode3)) {
8187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8188 }
8189 arg3 = static_cast< int >(val3);
8190 }
8191 if (obj3) {
8192 ecode4 = SWIG_AsVal_int(obj3, &val4);
8193 if (!SWIG_IsOK(ecode4)) {
8194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8195 }
8196 arg4 = static_cast< int >(val4);
8197 }
8198 if (obj4) {
8199 ecode5 = SWIG_AsVal_int(obj4, &val5);
8200 if (!SWIG_IsOK(ecode5)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8202 }
8203 arg5 = static_cast< int >(val5);
8204 }
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 resultobj = SWIG_Py_Void();
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxRect *arg1 = (wxRect *) 0 ;
8221 PyObject *result = 0 ;
8222 void *argp1 = 0 ;
8223 int res1 = 0 ;
8224 PyObject *swig_obj[1] ;
8225
8226 if (!args) SWIG_fail;
8227 swig_obj[0] = args;
8228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8229 if (!SWIG_IsOK(res1)) {
8230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8231 }
8232 arg1 = reinterpret_cast< wxRect * >(argp1);
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 result = (PyObject *)wxRect_Get(arg1);
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = result;
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8247 PyObject *obj;
8248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8249 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8250 return SWIG_Py_Void();
8251 }
8252
8253 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8254 return SWIG_Python_InitShadowInstance(args);
8255 }
8256
8257 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj = 0;
8259 wxRect *arg1 = (wxRect *) 0 ;
8260 wxRect *arg2 = (wxRect *) 0 ;
8261 PyObject *result = 0 ;
8262 void *argp1 = 0 ;
8263 int res1 = 0 ;
8264 void *argp2 = 0 ;
8265 int res2 = 0 ;
8266 PyObject * obj0 = 0 ;
8267 PyObject * obj1 = 0 ;
8268 char * kwnames[] = {
8269 (char *) "r1",(char *) "r2", NULL
8270 };
8271
8272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8274 if (!SWIG_IsOK(res1)) {
8275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8276 }
8277 arg1 = reinterpret_cast< wxRect * >(argp1);
8278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8279 if (!SWIG_IsOK(res2)) {
8280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8281 }
8282 arg2 = reinterpret_cast< wxRect * >(argp2);
8283 {
8284 if (!wxPyCheckForApp()) SWIG_fail;
8285 PyThreadState* __tstate = wxPyBeginAllowThreads();
8286 result = (PyObject *)wxIntersectRect(arg1,arg2);
8287 wxPyEndAllowThreads(__tstate);
8288 if (PyErr_Occurred()) SWIG_fail;
8289 }
8290 resultobj = result;
8291 return resultobj;
8292 fail:
8293 return NULL;
8294 }
8295
8296
8297 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8298 PyObject *resultobj = 0;
8299 double arg1 = (double) 0.0 ;
8300 double arg2 = (double) 0.0 ;
8301 wxPoint2D *result = 0 ;
8302 double val1 ;
8303 int ecode1 = 0 ;
8304 double val2 ;
8305 int ecode2 = 0 ;
8306 PyObject * obj0 = 0 ;
8307 PyObject * obj1 = 0 ;
8308 char * kwnames[] = {
8309 (char *) "x",(char *) "y", NULL
8310 };
8311
8312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8313 if (obj0) {
8314 ecode1 = SWIG_AsVal_double(obj0, &val1);
8315 if (!SWIG_IsOK(ecode1)) {
8316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8317 }
8318 arg1 = static_cast< double >(val1);
8319 }
8320 if (obj1) {
8321 ecode2 = SWIG_AsVal_double(obj1, &val2);
8322 if (!SWIG_IsOK(ecode2)) {
8323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8324 }
8325 arg2 = static_cast< double >(val2);
8326 }
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = 0 ;
8343 wxPoint2D *result = 0 ;
8344 wxPoint2D temp1 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "pt", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8351 {
8352 arg1 = &temp1;
8353 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8354 }
8355 {
8356 PyThreadState* __tstate = wxPyBeginAllowThreads();
8357 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj = 0;
8370 wxPoint *arg1 = 0 ;
8371 wxPoint2D *result = 0 ;
8372 wxPoint temp1 ;
8373 PyObject * obj0 = 0 ;
8374 char * kwnames[] = {
8375 (char *) "pt", NULL
8376 };
8377
8378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8379 {
8380 arg1 = &temp1;
8381 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8382 }
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8397 PyObject *resultobj = 0;
8398 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 PyObject *swig_obj[1] ;
8402
8403 if (!args) SWIG_fail;
8404 swig_obj[0] = args;
8405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8406 if (!SWIG_IsOK(res1)) {
8407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8408 }
8409 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 delete arg1;
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_Py_Void();
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 PyObject *resultobj = 0;
8426 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8427 int *arg2 = (int *) 0 ;
8428 int *arg3 = (int *) 0 ;
8429 void *argp1 = 0 ;
8430 int res1 = 0 ;
8431 int temp2 ;
8432 int res2 = SWIG_TMPOBJ ;
8433 int temp3 ;
8434 int res3 = SWIG_TMPOBJ ;
8435 PyObject *swig_obj[1] ;
8436
8437 arg2 = &temp2;
8438 arg3 = &temp3;
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8444 }
8445 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_Py_Void();
8453 if (SWIG_IsTmpObj(res2)) {
8454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8455 } else {
8456 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8458 }
8459 if (SWIG_IsTmpObj(res3)) {
8460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8461 } else {
8462 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8464 }
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 int *arg2 = (int *) 0 ;
8475 int *arg3 = (int *) 0 ;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 int temp2 ;
8479 int res2 = SWIG_TMPOBJ ;
8480 int temp3 ;
8481 int res3 = SWIG_TMPOBJ ;
8482 PyObject *swig_obj[1] ;
8483
8484 arg2 = &temp2;
8485 arg3 = &temp3;
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8491 }
8492 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_Py_Void();
8500 if (SWIG_IsTmpObj(res2)) {
8501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8502 } else {
8503 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8505 }
8506 if (SWIG_IsTmpObj(res3)) {
8507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8508 } else {
8509 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8511 }
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8519 PyObject *resultobj = 0;
8520 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8521 double result;
8522 void *argp1 = 0 ;
8523 int res1 = 0 ;
8524 PyObject *swig_obj[1] ;
8525
8526 if (!args) SWIG_fail;
8527 swig_obj[0] = args;
8528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8529 if (!SWIG_IsOK(res1)) {
8530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8531 }
8532 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 double result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_From_double(static_cast< double >(result));
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 double arg2 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 double val2 ;
8581 int ecode2 = 0 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "length", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 ecode2 = SWIG_AsVal_double(obj1, &val2);
8595 if (!SWIG_IsOK(ecode2)) {
8596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8597 }
8598 arg2 = static_cast< double >(val2);
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 (arg1)->SetVectorLength(arg2);
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 resultobj = SWIG_Py_Void();
8606 return resultobj;
8607 fail:
8608 return NULL;
8609 }
8610
8611
8612 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8613 PyObject *resultobj = 0;
8614 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8615 double arg2 ;
8616 void *argp1 = 0 ;
8617 int res1 = 0 ;
8618 double val2 ;
8619 int ecode2 = 0 ;
8620 PyObject * obj0 = 0 ;
8621 PyObject * obj1 = 0 ;
8622 char * kwnames[] = {
8623 (char *) "self",(char *) "degrees", NULL
8624 };
8625
8626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8630 }
8631 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8632 ecode2 = SWIG_AsVal_double(obj1, &val2);
8633 if (!SWIG_IsOK(ecode2)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8635 }
8636 arg2 = static_cast< double >(val2);
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 (arg1)->SetVectorAngle(arg2);
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_Py_Void();
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 wxPoint2D *arg2 = 0 ;
8654 double result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 wxPoint2D temp2 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "pt", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 {
8671 arg2 = &temp2;
8672 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8673 }
8674 {
8675 PyThreadState* __tstate = wxPyBeginAllowThreads();
8676 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 resultobj = SWIG_From_double(static_cast< double >(result));
8681 return resultobj;
8682 fail:
8683 return NULL;
8684 }
8685
8686
8687 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8688 PyObject *resultobj = 0;
8689 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8690 wxPoint2D *arg2 = 0 ;
8691 double result;
8692 void *argp1 = 0 ;
8693 int res1 = 0 ;
8694 wxPoint2D temp2 ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char * kwnames[] = {
8698 (char *) "self",(char *) "pt", NULL
8699 };
8700
8701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8705 }
8706 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8707 {
8708 arg2 = &temp2;
8709 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8714 wxPyEndAllowThreads(__tstate);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 resultobj = SWIG_From_double(static_cast< double >(result));
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8725 PyObject *resultobj = 0;
8726 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8727 wxPoint2D *arg2 = 0 ;
8728 double result;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 wxPoint2D temp2 ;
8732 PyObject * obj0 = 0 ;
8733 PyObject * obj1 = 0 ;
8734 char * kwnames[] = {
8735 (char *) "self",(char *) "vec", NULL
8736 };
8737
8738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8742 }
8743 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8744 {
8745 arg2 = &temp2;
8746 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8747 }
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 resultobj = SWIG_From_double(static_cast< double >(result));
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj = 0;
8763 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8764 wxPoint2D *arg2 = 0 ;
8765 double result;
8766 void *argp1 = 0 ;
8767 int res1 = 0 ;
8768 wxPoint2D temp2 ;
8769 PyObject * obj0 = 0 ;
8770 PyObject * obj1 = 0 ;
8771 char * kwnames[] = {
8772 (char *) "self",(char *) "vec", NULL
8773 };
8774
8775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 {
8782 arg2 = &temp2;
8783 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8784 }
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_From_double(static_cast< double >(result));
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8799 PyObject *resultobj = 0;
8800 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8801 wxPoint2D result;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 PyObject *swig_obj[1] ;
8805
8806 if (!args) SWIG_fail;
8807 swig_obj[0] = args;
8808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 result = (arg1)->operator -();
8816 wxPyEndAllowThreads(__tstate);
8817 if (PyErr_Occurred()) SWIG_fail;
8818 }
8819 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8820 return resultobj;
8821 fail:
8822 return NULL;
8823 }
8824
8825
8826 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj = 0;
8828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8829 wxPoint2D *arg2 = 0 ;
8830 wxPoint2D *result = 0 ;
8831 void *argp1 = 0 ;
8832 int res1 = 0 ;
8833 wxPoint2D temp2 ;
8834 PyObject * obj0 = 0 ;
8835 PyObject * obj1 = 0 ;
8836 char * kwnames[] = {
8837 (char *) "self",(char *) "pt", NULL
8838 };
8839
8840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8842 if (!SWIG_IsOK(res1)) {
8843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8844 }
8845 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8846 {
8847 arg2 = &temp2;
8848 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8849 }
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 {
8853 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8854 result = (wxPoint2D *) &_result_ref;
8855 }
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8860 return resultobj;
8861 fail:
8862 return NULL;
8863 }
8864
8865
8866 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj = 0;
8868 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8869 wxPoint2D *arg2 = 0 ;
8870 wxPoint2D *result = 0 ;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 wxPoint2D temp2 ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 char * kwnames[] = {
8877 (char *) "self",(char *) "pt", NULL
8878 };
8879
8880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8882 if (!SWIG_IsOK(res1)) {
8883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8884 }
8885 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8886 {
8887 arg2 = &temp2;
8888 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8889 }
8890 {
8891 PyThreadState* __tstate = wxPyBeginAllowThreads();
8892 {
8893 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8894 result = (wxPoint2D *) &_result_ref;
8895 }
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 wxPoint2D *arg2 = 0 ;
8910 wxPoint2D *result = 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 wxPoint2D temp2 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "pt", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 {
8927 arg2 = &temp2;
8928 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 {
8933 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8934 result = (wxPoint2D *) &_result_ref;
8935 }
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj = 0;
8948 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8949 wxPoint2D *arg2 = 0 ;
8950 wxPoint2D *result = 0 ;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 wxPoint2D temp2 ;
8954 PyObject * obj0 = 0 ;
8955 PyObject * obj1 = 0 ;
8956 char * kwnames[] = {
8957 (char *) "self",(char *) "pt", NULL
8958 };
8959
8960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8964 }
8965 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8966 {
8967 arg2 = &temp2;
8968 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8969 }
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 {
8973 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8974 result = (wxPoint2D *) &_result_ref;
8975 }
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj = 0;
8988 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8989 PyObject *arg2 = (PyObject *) 0 ;
8990 bool result;
8991 void *argp1 = 0 ;
8992 int res1 = 0 ;
8993 PyObject * obj0 = 0 ;
8994 PyObject * obj1 = 0 ;
8995 char * kwnames[] = {
8996 (char *) "self",(char *) "other", NULL
8997 };
8998
8999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
9000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9001 if (!SWIG_IsOK(res1)) {
9002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9003 }
9004 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9005 arg2 = obj1;
9006 {
9007 result = (bool)wxPoint2D___eq__(arg1,arg2);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 {
9011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9012 }
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj = 0;
9021 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9022 PyObject *arg2 = (PyObject *) 0 ;
9023 bool result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 PyObject * obj0 = 0 ;
9027 PyObject * obj1 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "self",(char *) "other", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 arg2 = obj1;
9039 {
9040 result = (bool)wxPoint2D___ne__(arg1,arg2);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 {
9044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9045 }
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 PyObject *resultobj = 0;
9054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9055 double arg2 ;
9056 void *argp1 = 0 ;
9057 int res1 = 0 ;
9058 double val2 ;
9059 int ecode2 = 0 ;
9060 PyObject *swig_obj[2] ;
9061
9062 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9066 }
9067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9068 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9069 if (!SWIG_IsOK(ecode2)) {
9070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9071 }
9072 arg2 = static_cast< double >(val2);
9073 if (arg1) (arg1)->m_x = arg2;
9074
9075 resultobj = SWIG_Py_Void();
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9083 PyObject *resultobj = 0;
9084 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9085 double result;
9086 void *argp1 = 0 ;
9087 int res1 = 0 ;
9088 PyObject *swig_obj[1] ;
9089
9090 if (!args) SWIG_fail;
9091 swig_obj[0] = args;
9092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9093 if (!SWIG_IsOK(res1)) {
9094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9095 }
9096 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9097 result = (double) ((arg1)->m_x);
9098 resultobj = SWIG_From_double(static_cast< double >(result));
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *resultobj = 0;
9107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9108 double arg2 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 double val2 ;
9112 int ecode2 = 0 ;
9113 PyObject *swig_obj[2] ;
9114
9115 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9121 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9122 if (!SWIG_IsOK(ecode2)) {
9123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9124 }
9125 arg2 = static_cast< double >(val2);
9126 if (arg1) (arg1)->m_y = arg2;
9127
9128 resultobj = SWIG_Py_Void();
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9136 PyObject *resultobj = 0;
9137 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9138 double result;
9139 void *argp1 = 0 ;
9140 int res1 = 0 ;
9141 PyObject *swig_obj[1] ;
9142
9143 if (!args) SWIG_fail;
9144 swig_obj[0] = args;
9145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9146 if (!SWIG_IsOK(res1)) {
9147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9148 }
9149 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9150 result = (double) ((arg1)->m_y);
9151 resultobj = SWIG_From_double(static_cast< double >(result));
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj = 0;
9160 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9161 double arg2 = (double) 0 ;
9162 double arg3 = (double) 0 ;
9163 void *argp1 = 0 ;
9164 int res1 = 0 ;
9165 double val2 ;
9166 int ecode2 = 0 ;
9167 double val3 ;
9168 int ecode3 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 PyObject * obj2 = 0 ;
9172 char * kwnames[] = {
9173 (char *) "self",(char *) "x",(char *) "y", NULL
9174 };
9175
9176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9178 if (!SWIG_IsOK(res1)) {
9179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9180 }
9181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9182 if (obj1) {
9183 ecode2 = SWIG_AsVal_double(obj1, &val2);
9184 if (!SWIG_IsOK(ecode2)) {
9185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9186 }
9187 arg2 = static_cast< double >(val2);
9188 }
9189 if (obj2) {
9190 ecode3 = SWIG_AsVal_double(obj2, &val3);
9191 if (!SWIG_IsOK(ecode3)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9193 }
9194 arg3 = static_cast< double >(val3);
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 wxPoint2D_Set(arg1,arg2,arg3);
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = SWIG_Py_Void();
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9210 PyObject *resultobj = 0;
9211 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9212 PyObject *result = 0 ;
9213 void *argp1 = 0 ;
9214 int res1 = 0 ;
9215 PyObject *swig_obj[1] ;
9216
9217 if (!args) SWIG_fail;
9218 swig_obj[0] = args;
9219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9220 if (!SWIG_IsOK(res1)) {
9221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9222 }
9223 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = (PyObject *)wxPoint2D_Get(arg1);
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = result;
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *obj;
9239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9240 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9241 return SWIG_Py_Void();
9242 }
9243
9244 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 return SWIG_Python_InitShadowInstance(args);
9246 }
9247
9248 SWIGINTERN int DefaultPosition_set(PyObject *) {
9249 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9250 return 1;
9251 }
9252
9253
9254 SWIGINTERN PyObject *DefaultPosition_get(void) {
9255 PyObject *pyobj = 0;
9256
9257 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9258 return pyobj;
9259 }
9260
9261
9262 SWIGINTERN int DefaultSize_set(PyObject *) {
9263 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9264 return 1;
9265 }
9266
9267
9268 SWIGINTERN PyObject *DefaultSize_get(void) {
9269 PyObject *pyobj = 0;
9270
9271 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9272 return pyobj;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj = 0;
9278 PyObject *arg1 = (PyObject *) 0 ;
9279 wxPyInputStream *result = 0 ;
9280 PyObject * obj0 = 0 ;
9281 char * kwnames[] = {
9282 (char *) "p", NULL
9283 };
9284
9285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9286 arg1 = obj0;
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 PyObject *swig_obj[1] ;
9306
9307 if (!args) SWIG_fail;
9308 swig_obj[0] = args;
9309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9312 }
9313 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 delete arg1;
9317
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_Py_Void();
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9340 }
9341 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 (arg1)->close();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_Py_Void();
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9356 PyObject *resultobj = 0;
9357 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9358 void *argp1 = 0 ;
9359 int res1 = 0 ;
9360 PyObject *swig_obj[1] ;
9361
9362 if (!args) SWIG_fail;
9363 swig_obj[0] = args;
9364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 (arg1)->flush();
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 resultobj = SWIG_Py_Void();
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9383 PyObject *resultobj = 0;
9384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9385 bool result;
9386 void *argp1 = 0 ;
9387 int res1 = 0 ;
9388 PyObject *swig_obj[1] ;
9389
9390 if (!args) SWIG_fail;
9391 swig_obj[0] = args;
9392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9393 if (!SWIG_IsOK(res1)) {
9394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9395 }
9396 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (bool)(arg1)->eof();
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 {
9404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9405 }
9406 return resultobj;
9407 fail:
9408 return NULL;
9409 }
9410
9411
9412 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj = 0;
9414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9415 int arg2 = (int) -1 ;
9416 PyObject *result = 0 ;
9417 void *argp1 = 0 ;
9418 int res1 = 0 ;
9419 int val2 ;
9420 int ecode2 = 0 ;
9421 PyObject * obj0 = 0 ;
9422 PyObject * obj1 = 0 ;
9423 char * kwnames[] = {
9424 (char *) "self",(char *) "size", NULL
9425 };
9426
9427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9431 }
9432 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9433 if (obj1) {
9434 ecode2 = SWIG_AsVal_int(obj1, &val2);
9435 if (!SWIG_IsOK(ecode2)) {
9436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9437 }
9438 arg2 = static_cast< int >(val2);
9439 }
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (PyObject *)(arg1)->read(arg2);
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = result;
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9456 int arg2 = (int) -1 ;
9457 PyObject *result = 0 ;
9458 void *argp1 = 0 ;
9459 int res1 = 0 ;
9460 int val2 ;
9461 int ecode2 = 0 ;
9462 PyObject * obj0 = 0 ;
9463 PyObject * obj1 = 0 ;
9464 char * kwnames[] = {
9465 (char *) "self",(char *) "size", NULL
9466 };
9467
9468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9472 }
9473 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9474 if (obj1) {
9475 ecode2 = SWIG_AsVal_int(obj1, &val2);
9476 if (!SWIG_IsOK(ecode2)) {
9477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9478 }
9479 arg2 = static_cast< int >(val2);
9480 }
9481 {
9482 PyThreadState* __tstate = wxPyBeginAllowThreads();
9483 result = (PyObject *)(arg1)->readline(arg2);
9484 wxPyEndAllowThreads(__tstate);
9485 if (PyErr_Occurred()) SWIG_fail;
9486 }
9487 resultobj = result;
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj = 0;
9496 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9497 int arg2 = (int) -1 ;
9498 PyObject *result = 0 ;
9499 void *argp1 = 0 ;
9500 int res1 = 0 ;
9501 int val2 ;
9502 int ecode2 = 0 ;
9503 PyObject * obj0 = 0 ;
9504 PyObject * obj1 = 0 ;
9505 char * kwnames[] = {
9506 (char *) "self",(char *) "sizehint", NULL
9507 };
9508
9509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9511 if (!SWIG_IsOK(res1)) {
9512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9513 }
9514 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9515 if (obj1) {
9516 ecode2 = SWIG_AsVal_int(obj1, &val2);
9517 if (!SWIG_IsOK(ecode2)) {
9518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9519 }
9520 arg2 = static_cast< int >(val2);
9521 }
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (PyObject *)(arg1)->readlines(arg2);
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = result;
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj = 0;
9537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9538 int arg2 ;
9539 int arg3 = (int) 0 ;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 int val2 ;
9543 int ecode2 = 0 ;
9544 int val3 ;
9545 int ecode3 = 0 ;
9546 PyObject * obj0 = 0 ;
9547 PyObject * obj1 = 0 ;
9548 PyObject * obj2 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "offset",(char *) "whence", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9557 }
9558 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9559 ecode2 = SWIG_AsVal_int(obj1, &val2);
9560 if (!SWIG_IsOK(ecode2)) {
9561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9562 }
9563 arg2 = static_cast< int >(val2);
9564 if (obj2) {
9565 ecode3 = SWIG_AsVal_int(obj2, &val3);
9566 if (!SWIG_IsOK(ecode3)) {
9567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9568 }
9569 arg3 = static_cast< int >(val3);
9570 }
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 (arg1)->seek(arg2,arg3);
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_Py_Void();
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9585 PyObject *resultobj = 0;
9586 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9587 int result;
9588 void *argp1 = 0 ;
9589 int res1 = 0 ;
9590 PyObject *swig_obj[1] ;
9591
9592 if (!args) SWIG_fail;
9593 swig_obj[0] = args;
9594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9595 if (!SWIG_IsOK(res1)) {
9596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9597 }
9598 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (int)(arg1)->tell();
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 resultobj = SWIG_From_int(static_cast< int >(result));
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9613 PyObject *resultobj = 0;
9614 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9615 char result;
9616 void *argp1 = 0 ;
9617 int res1 = 0 ;
9618 PyObject *swig_obj[1] ;
9619
9620 if (!args) SWIG_fail;
9621 swig_obj[0] = args;
9622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9623 if (!SWIG_IsOK(res1)) {
9624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9625 }
9626 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = (char)(arg1)->Peek();
9630 wxPyEndAllowThreads(__tstate);
9631 if (PyErr_Occurred()) SWIG_fail;
9632 }
9633 resultobj = SWIG_From_char(static_cast< char >(result));
9634 return resultobj;
9635 fail:
9636 return NULL;
9637 }
9638
9639
9640 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9641 PyObject *resultobj = 0;
9642 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9643 char result;
9644 void *argp1 = 0 ;
9645 int res1 = 0 ;
9646 PyObject *swig_obj[1] ;
9647
9648 if (!args) SWIG_fail;
9649 swig_obj[0] = args;
9650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9651 if (!SWIG_IsOK(res1)) {
9652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9653 }
9654 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (char)(arg1)->GetC();
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_From_char(static_cast< char >(result));
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669 PyObject *resultobj = 0;
9670 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9671 size_t result;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 PyObject *swig_obj[1] ;
9675
9676 if (!args) SWIG_fail;
9677 swig_obj[0] = args;
9678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9681 }
9682 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 result = (size_t)(arg1)->LastRead();
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9697 PyObject *resultobj = 0;
9698 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9699 bool result;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 PyObject *swig_obj[1] ;
9703
9704 if (!args) SWIG_fail;
9705 swig_obj[0] = args;
9706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9707 if (!SWIG_IsOK(res1)) {
9708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9709 }
9710 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (bool)(arg1)->CanRead();
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9719 }
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727 PyObject *resultobj = 0;
9728 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9729 bool result;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 PyObject *swig_obj[1] ;
9733
9734 if (!args) SWIG_fail;
9735 swig_obj[0] = args;
9736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9737 if (!SWIG_IsOK(res1)) {
9738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9739 }
9740 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 result = (bool)(arg1)->Eof();
9744 wxPyEndAllowThreads(__tstate);
9745 if (PyErr_Occurred()) SWIG_fail;
9746 }
9747 {
9748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9749 }
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj = 0;
9758 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9759 char arg2 ;
9760 bool result;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 char val2 ;
9764 int ecode2 = 0 ;
9765 PyObject * obj0 = 0 ;
9766 PyObject * obj1 = 0 ;
9767 char * kwnames[] = {
9768 (char *) "self",(char *) "c", NULL
9769 };
9770
9771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9773 if (!SWIG_IsOK(res1)) {
9774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9775 }
9776 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9777 ecode2 = SWIG_AsVal_char(obj1, &val2);
9778 if (!SWIG_IsOK(ecode2)) {
9779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9780 }
9781 arg2 = static_cast< char >(val2);
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (bool)(arg1)->Ungetch(arg2);
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 {
9789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9790 }
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj = 0;
9799 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9800 long arg2 ;
9801 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9802 long result;
9803 void *argp1 = 0 ;
9804 int res1 = 0 ;
9805 long val2 ;
9806 int ecode2 = 0 ;
9807 int val3 ;
9808 int ecode3 = 0 ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char * kwnames[] = {
9813 (char *) "self",(char *) "pos",(char *) "mode", NULL
9814 };
9815
9816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9820 }
9821 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9822 ecode2 = SWIG_AsVal_long(obj1, &val2);
9823 if (!SWIG_IsOK(ecode2)) {
9824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9825 }
9826 arg2 = static_cast< long >(val2);
9827 if (obj2) {
9828 ecode3 = SWIG_AsVal_int(obj2, &val3);
9829 if (!SWIG_IsOK(ecode3)) {
9830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9831 }
9832 arg3 = static_cast< wxSeekMode >(val3);
9833 }
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 result = (long)(arg1)->SeekI(arg2,arg3);
9837 wxPyEndAllowThreads(__tstate);
9838 if (PyErr_Occurred()) SWIG_fail;
9839 }
9840 resultobj = SWIG_From_long(static_cast< long >(result));
9841 return resultobj;
9842 fail:
9843 return NULL;
9844 }
9845
9846
9847 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9848 PyObject *resultobj = 0;
9849 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9850 long result;
9851 void *argp1 = 0 ;
9852 int res1 = 0 ;
9853 PyObject *swig_obj[1] ;
9854
9855 if (!args) SWIG_fail;
9856 swig_obj[0] = args;
9857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9858 if (!SWIG_IsOK(res1)) {
9859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9860 }
9861 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9862 {
9863 PyThreadState* __tstate = wxPyBeginAllowThreads();
9864 result = (long)(arg1)->TellI();
9865 wxPyEndAllowThreads(__tstate);
9866 if (PyErr_Occurred()) SWIG_fail;
9867 }
9868 resultobj = SWIG_From_long(static_cast< long >(result));
9869 return resultobj;
9870 fail:
9871 return NULL;
9872 }
9873
9874
9875 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9876 PyObject *obj;
9877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9879 return SWIG_Py_Void();
9880 }
9881
9882 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 return SWIG_Python_InitShadowInstance(args);
9884 }
9885
9886 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9887 PyObject *resultobj = 0;
9888 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9889 PyObject *arg2 = (PyObject *) 0 ;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject * obj0 = 0 ;
9893 PyObject * obj1 = 0 ;
9894 char * kwnames[] = {
9895 (char *) "self",(char *) "obj", NULL
9896 };
9897
9898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9902 }
9903 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9904 arg2 = obj1;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 wxOutputStream_write(arg1,arg2);
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 resultobj = SWIG_Py_Void();
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9921 size_t result;
9922 void *argp1 = 0 ;
9923 int res1 = 0 ;
9924 PyObject *swig_obj[1] ;
9925
9926 if (!args) SWIG_fail;
9927 swig_obj[0] = args;
9928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9931 }
9932 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *obj;
9948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9949 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9950 return SWIG_Py_Void();
9951 }
9952
9953 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxInputStream *arg1 = (wxInputStream *) 0 ;
9956 wxString *arg2 = 0 ;
9957 wxString *arg3 = 0 ;
9958 wxString *arg4 = 0 ;
9959 wxDateTime arg5 ;
9960 wxFSFile *result = 0 ;
9961 wxPyInputStream *temp1 ;
9962 bool temp2 = false ;
9963 bool temp3 = false ;
9964 bool temp4 = false ;
9965 void *argp5 ;
9966 int res5 = 0 ;
9967 PyObject * obj0 = 0 ;
9968 PyObject * obj1 = 0 ;
9969 PyObject * obj2 = 0 ;
9970 PyObject * obj3 = 0 ;
9971 PyObject * obj4 = 0 ;
9972 char * kwnames[] = {
9973 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9974 };
9975
9976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9977 {
9978 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9979 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9980 } else {
9981 PyErr_Clear(); // clear the failure of the wxPyConvert above
9982 arg1 = wxPyCBInputStream_create(obj0, true);
9983 if (arg1 == NULL) {
9984 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9985 SWIG_fail;
9986 }
9987 }
9988 }
9989 {
9990 arg2 = wxString_in_helper(obj1);
9991 if (arg2 == NULL) SWIG_fail;
9992 temp2 = true;
9993 }
9994 {
9995 arg3 = wxString_in_helper(obj2);
9996 if (arg3 == NULL) SWIG_fail;
9997 temp3 = true;
9998 }
9999 {
10000 arg4 = wxString_in_helper(obj3);
10001 if (arg4 == NULL) SWIG_fail;
10002 temp4 = true;
10003 }
10004 {
10005 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
10006 if (!SWIG_IsOK(res5)) {
10007 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10008 }
10009 if (!argp5) {
10010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10011 } else {
10012 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
10013 arg5 = *temp;
10014 if (SWIG_IsNewObj(res5)) delete temp;
10015 }
10016 }
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10024 {
10025 if (temp2)
10026 delete arg2;
10027 }
10028 {
10029 if (temp3)
10030 delete arg3;
10031 }
10032 {
10033 if (temp4)
10034 delete arg4;
10035 }
10036 return resultobj;
10037 fail:
10038 {
10039 if (temp2)
10040 delete arg2;
10041 }
10042 {
10043 if (temp3)
10044 delete arg3;
10045 }
10046 {
10047 if (temp4)
10048 delete arg4;
10049 }
10050 return NULL;
10051 }
10052
10053
10054 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10055 PyObject *resultobj = 0;
10056 wxFSFile *arg1 = (wxFSFile *) 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 PyObject *swig_obj[1] ;
10060
10061 if (!args) SWIG_fail;
10062 swig_obj[0] = args;
10063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10066 }
10067 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10068 {
10069 PyThreadState* __tstate = wxPyBeginAllowThreads();
10070 delete arg1;
10071
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 resultobj = SWIG_Py_Void();
10076 return resultobj;
10077 fail:
10078 return NULL;
10079 }
10080
10081
10082 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10083 PyObject *resultobj = 0;
10084 wxFSFile *arg1 = (wxFSFile *) 0 ;
10085 wxInputStream *result = 0 ;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 PyObject *swig_obj[1] ;
10089
10090 if (!args) SWIG_fail;
10091 swig_obj[0] = args;
10092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10093 if (!SWIG_IsOK(res1)) {
10094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10095 }
10096 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10097 {
10098 PyThreadState* __tstate = wxPyBeginAllowThreads();
10099 result = (wxInputStream *)(arg1)->GetStream();
10100 wxPyEndAllowThreads(__tstate);
10101 if (PyErr_Occurred()) SWIG_fail;
10102 }
10103 {
10104 wxPyInputStream * _ptr = NULL;
10105
10106 if (result) {
10107 _ptr = new wxPyInputStream(result);
10108 }
10109 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10110 }
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 PyObject *resultobj = 0;
10119 wxFSFile *arg1 = (wxFSFile *) 0 ;
10120 void *argp1 = 0 ;
10121 int res1 = 0 ;
10122 PyObject *swig_obj[1] ;
10123
10124 if (!args) SWIG_fail;
10125 swig_obj[0] = args;
10126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10127 if (!SWIG_IsOK(res1)) {
10128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10129 }
10130 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 (arg1)->DetachStream();
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 resultobj = SWIG_Py_Void();
10138 return resultobj;
10139 fail:
10140 return NULL;
10141 }
10142
10143
10144 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *resultobj = 0;
10146 wxFSFile *arg1 = (wxFSFile *) 0 ;
10147 wxString *result = 0 ;
10148 void *argp1 = 0 ;
10149 int res1 = 0 ;
10150 PyObject *swig_obj[1] ;
10151
10152 if (!args) SWIG_fail;
10153 swig_obj[0] = args;
10154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10157 }
10158 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 {
10162 wxString const &_result_ref = (arg1)->GetMimeType();
10163 result = (wxString *) &_result_ref;
10164 }
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 {
10169 #if wxUSE_UNICODE
10170 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10171 #else
10172 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10173 #endif
10174 }
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10182 PyObject *resultobj = 0;
10183 wxFSFile *arg1 = (wxFSFile *) 0 ;
10184 wxString *result = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 PyObject *swig_obj[1] ;
10188
10189 if (!args) SWIG_fail;
10190 swig_obj[0] = args;
10191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10194 }
10195 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10196 {
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 {
10199 wxString const &_result_ref = (arg1)->GetLocation();
10200 result = (wxString *) &_result_ref;
10201 }
10202 wxPyEndAllowThreads(__tstate);
10203 if (PyErr_Occurred()) SWIG_fail;
10204 }
10205 {
10206 #if wxUSE_UNICODE
10207 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10208 #else
10209 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10210 #endif
10211 }
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10219 PyObject *resultobj = 0;
10220 wxFSFile *arg1 = (wxFSFile *) 0 ;
10221 wxString *result = 0 ;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 PyObject *swig_obj[1] ;
10225
10226 if (!args) SWIG_fail;
10227 swig_obj[0] = args;
10228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10231 }
10232 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10233 {
10234 PyThreadState* __tstate = wxPyBeginAllowThreads();
10235 {
10236 wxString const &_result_ref = (arg1)->GetAnchor();
10237 result = (wxString *) &_result_ref;
10238 }
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 {
10243 #if wxUSE_UNICODE
10244 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10245 #else
10246 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10247 #endif
10248 }
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10256 PyObject *resultobj = 0;
10257 wxFSFile *arg1 = (wxFSFile *) 0 ;
10258 wxDateTime result;
10259 void *argp1 = 0 ;
10260 int res1 = 0 ;
10261 PyObject *swig_obj[1] ;
10262
10263 if (!args) SWIG_fail;
10264 swig_obj[0] = args;
10265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10268 }
10269 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (arg1)->GetModificationTime();
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10277 return resultobj;
10278 fail:
10279 return NULL;
10280 }
10281
10282
10283 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10284 PyObject *obj;
10285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10286 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10287 return SWIG_Py_Void();
10288 }
10289
10290 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291 return SWIG_Python_InitShadowInstance(args);
10292 }
10293
10294 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 PyObject *swig_obj[1] ;
10300
10301 if (!args) SWIG_fail;
10302 swig_obj[0] = args;
10303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10306 }
10307 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 delete arg1;
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 resultobj = SWIG_Py_Void();
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10323 PyObject *obj;
10324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10325 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10326 return SWIG_Py_Void();
10327 }
10328
10329 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10330 PyObject *resultobj = 0;
10331 wxPyFileSystemHandler *result = 0 ;
10332
10333 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10350 PyObject *arg2 = (PyObject *) 0 ;
10351 PyObject *arg3 = (PyObject *) 0 ;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 PyObject * obj2 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "self",(char *) "self",(char *) "_class", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10365 }
10366 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10367 arg2 = obj1;
10368 arg3 = obj2;
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 (arg1)->_setCallbackInfo(arg2,arg3);
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 resultobj = SWIG_Py_Void();
10376 return resultobj;
10377 fail:
10378 return NULL;
10379 }
10380
10381
10382 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10383 PyObject *resultobj = 0;
10384 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10385 wxString *arg2 = 0 ;
10386 bool result;
10387 void *argp1 = 0 ;
10388 int res1 = 0 ;
10389 bool temp2 = false ;
10390 PyObject * obj0 = 0 ;
10391 PyObject * obj1 = 0 ;
10392 char * kwnames[] = {
10393 (char *) "self",(char *) "location", NULL
10394 };
10395
10396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10398 if (!SWIG_IsOK(res1)) {
10399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10400 }
10401 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10402 {
10403 arg2 = wxString_in_helper(obj1);
10404 if (arg2 == NULL) SWIG_fail;
10405 temp2 = true;
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 {
10414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10415 }
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return resultobj;
10421 fail:
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return NULL;
10427 }
10428
10429
10430 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj = 0;
10432 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10433 wxFileSystem *arg2 = 0 ;
10434 wxString *arg3 = 0 ;
10435 wxFSFile *result = 0 ;
10436 void *argp1 = 0 ;
10437 int res1 = 0 ;
10438 void *argp2 = 0 ;
10439 int res2 = 0 ;
10440 bool temp3 = false ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 PyObject * obj2 = 0 ;
10444 char * kwnames[] = {
10445 (char *) "self",(char *) "fs",(char *) "location", NULL
10446 };
10447
10448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10450 if (!SWIG_IsOK(res1)) {
10451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10452 }
10453 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10455 if (!SWIG_IsOK(res2)) {
10456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10457 }
10458 if (!argp2) {
10459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10460 }
10461 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10462 {
10463 arg3 = wxString_in_helper(obj2);
10464 if (arg3 == NULL) SWIG_fail;
10465 temp3 = true;
10466 }
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10475 }
10476 {
10477 if (temp3)
10478 delete arg3;
10479 }
10480 return resultobj;
10481 fail:
10482 {
10483 if (temp3)
10484 delete arg3;
10485 }
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10493 wxString *arg2 = 0 ;
10494 int arg3 = (int) 0 ;
10495 wxString result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 bool temp2 = false ;
10499 int val3 ;
10500 int ecode3 = 0 ;
10501 PyObject * obj0 = 0 ;
10502 PyObject * obj1 = 0 ;
10503 PyObject * obj2 = 0 ;
10504 char * kwnames[] = {
10505 (char *) "self",(char *) "spec",(char *) "flags", NULL
10506 };
10507
10508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10512 }
10513 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10514 {
10515 arg2 = wxString_in_helper(obj1);
10516 if (arg2 == NULL) SWIG_fail;
10517 temp2 = true;
10518 }
10519 if (obj2) {
10520 ecode3 = SWIG_AsVal_int(obj2, &val3);
10521 if (!SWIG_IsOK(ecode3)) {
10522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10523 }
10524 arg3 = static_cast< int >(val3);
10525 }
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 {
10533 #if wxUSE_UNICODE
10534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10535 #else
10536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10537 #endif
10538 }
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10554 PyObject *resultobj = 0;
10555 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10556 wxString result;
10557 void *argp1 = 0 ;
10558 int res1 = 0 ;
10559 PyObject *swig_obj[1] ;
10560
10561 if (!args) SWIG_fail;
10562 swig_obj[0] = args;
10563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10564 if (!SWIG_IsOK(res1)) {
10565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10566 }
10567 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->FindNext();
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 #if wxUSE_UNICODE
10576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10577 #else
10578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10579 #endif
10580 }
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj = 0;
10589 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10590 wxString *arg2 = 0 ;
10591 wxString result;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 bool temp2 = false ;
10595 PyObject * obj0 = 0 ;
10596 PyObject * obj1 = 0 ;
10597 char * kwnames[] = {
10598 (char *) "self",(char *) "location", NULL
10599 };
10600
10601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10603 if (!SWIG_IsOK(res1)) {
10604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10605 }
10606 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10607 {
10608 arg2 = wxString_in_helper(obj1);
10609 if (arg2 == NULL) SWIG_fail;
10610 temp2 = true;
10611 }
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = (arg1)->GetProtocol((wxString const &)*arg2);
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 #if wxUSE_UNICODE
10620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10621 #else
10622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10623 #endif
10624 }
10625 {
10626 if (temp2)
10627 delete arg2;
10628 }
10629 return resultobj;
10630 fail:
10631 {
10632 if (temp2)
10633 delete arg2;
10634 }
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10642 wxString *arg2 = 0 ;
10643 wxString result;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 bool temp2 = false ;
10647 PyObject * obj0 = 0 ;
10648 PyObject * obj1 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "location", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10657 }
10658 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10659 {
10660 arg2 = wxString_in_helper(obj1);
10661 if (arg2 == NULL) SWIG_fail;
10662 temp2 = true;
10663 }
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 #if wxUSE_UNICODE
10672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10673 #else
10674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10675 #endif
10676 }
10677 {
10678 if (temp2)
10679 delete arg2;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj = 0;
10693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10694 wxString *arg2 = 0 ;
10695 wxString result;
10696 void *argp1 = 0 ;
10697 int res1 = 0 ;
10698 bool temp2 = false ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 char * kwnames[] = {
10702 (char *) "self",(char *) "location", NULL
10703 };
10704
10705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10707 if (!SWIG_IsOK(res1)) {
10708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10709 }
10710 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10711 {
10712 arg2 = wxString_in_helper(obj1);
10713 if (arg2 == NULL) SWIG_fail;
10714 temp2 = true;
10715 }
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 result = (arg1)->GetAnchor((wxString const &)*arg2);
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 {
10723 #if wxUSE_UNICODE
10724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10725 #else
10726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10727 #endif
10728 }
10729 {
10730 if (temp2)
10731 delete arg2;
10732 }
10733 return resultobj;
10734 fail:
10735 {
10736 if (temp2)
10737 delete arg2;
10738 }
10739 return NULL;
10740 }
10741
10742
10743 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj = 0;
10745 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10746 wxString *arg2 = 0 ;
10747 wxString result;
10748 void *argp1 = 0 ;
10749 int res1 = 0 ;
10750 bool temp2 = false ;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 char * kwnames[] = {
10754 (char *) "self",(char *) "location", NULL
10755 };
10756
10757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10761 }
10762 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10763 {
10764 arg2 = wxString_in_helper(obj1);
10765 if (arg2 == NULL) SWIG_fail;
10766 temp2 = true;
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 {
10775 #if wxUSE_UNICODE
10776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10777 #else
10778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10779 #endif
10780 }
10781 {
10782 if (temp2)
10783 delete arg2;
10784 }
10785 return resultobj;
10786 fail:
10787 {
10788 if (temp2)
10789 delete arg2;
10790 }
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = 0;
10797 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10798 wxString *arg2 = 0 ;
10799 wxString result;
10800 void *argp1 = 0 ;
10801 int res1 = 0 ;
10802 bool temp2 = false ;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 char * kwnames[] = {
10806 (char *) "self",(char *) "location", NULL
10807 };
10808
10809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10811 if (!SWIG_IsOK(res1)) {
10812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10813 }
10814 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10815 {
10816 arg2 = wxString_in_helper(obj1);
10817 if (arg2 == NULL) SWIG_fail;
10818 temp2 = true;
10819 }
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 {
10827 #if wxUSE_UNICODE
10828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10829 #else
10830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10831 #endif
10832 }
10833 {
10834 if (temp2)
10835 delete arg2;
10836 }
10837 return resultobj;
10838 fail:
10839 {
10840 if (temp2)
10841 delete arg2;
10842 }
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10848 PyObject *obj;
10849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10850 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10851 return SWIG_Py_Void();
10852 }
10853
10854 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10855 return SWIG_Python_InitShadowInstance(args);
10856 }
10857
10858 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10859 PyObject *resultobj = 0;
10860 wxFileSystem *result = 0 ;
10861
10862 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = (wxFileSystem *)new wxFileSystem();
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10877 PyObject *resultobj = 0;
10878 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10879 void *argp1 = 0 ;
10880 int res1 = 0 ;
10881 PyObject *swig_obj[1] ;
10882
10883 if (!args) SWIG_fail;
10884 swig_obj[0] = args;
10885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10886 if (!SWIG_IsOK(res1)) {
10887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10888 }
10889 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 delete arg1;
10893
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 resultobj = SWIG_Py_Void();
10898 return resultobj;
10899 fail:
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj = 0;
10906 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10907 wxString *arg2 = 0 ;
10908 bool arg3 = (bool) false ;
10909 void *argp1 = 0 ;
10910 int res1 = 0 ;
10911 bool temp2 = false ;
10912 bool val3 ;
10913 int ecode3 = 0 ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 PyObject * obj2 = 0 ;
10917 char * kwnames[] = {
10918 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10919 };
10920
10921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10923 if (!SWIG_IsOK(res1)) {
10924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10925 }
10926 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10927 {
10928 arg2 = wxString_in_helper(obj1);
10929 if (arg2 == NULL) SWIG_fail;
10930 temp2 = true;
10931 }
10932 if (obj2) {
10933 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10934 if (!SWIG_IsOK(ecode3)) {
10935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10936 }
10937 arg3 = static_cast< bool >(val3);
10938 }
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 resultobj = SWIG_Py_Void();
10946 {
10947 if (temp2)
10948 delete arg2;
10949 }
10950 return resultobj;
10951 fail:
10952 {
10953 if (temp2)
10954 delete arg2;
10955 }
10956 return NULL;
10957 }
10958
10959
10960 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10961 PyObject *resultobj = 0;
10962 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10963 wxString result;
10964 void *argp1 = 0 ;
10965 int res1 = 0 ;
10966 PyObject *swig_obj[1] ;
10967
10968 if (!args) SWIG_fail;
10969 swig_obj[0] = args;
10970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10971 if (!SWIG_IsOK(res1)) {
10972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10973 }
10974 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10975 {
10976 PyThreadState* __tstate = wxPyBeginAllowThreads();
10977 result = (arg1)->GetPath();
10978 wxPyEndAllowThreads(__tstate);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 {
10982 #if wxUSE_UNICODE
10983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10984 #else
10985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10986 #endif
10987 }
10988 return resultobj;
10989 fail:
10990 return NULL;
10991 }
10992
10993
10994 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10995 PyObject *resultobj = 0;
10996 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10997 wxString *arg2 = 0 ;
10998 wxFSFile *result = 0 ;
10999 void *argp1 = 0 ;
11000 int res1 = 0 ;
11001 bool temp2 = false ;
11002 PyObject * obj0 = 0 ;
11003 PyObject * obj1 = 0 ;
11004 char * kwnames[] = {
11005 (char *) "self",(char *) "location", NULL
11006 };
11007
11008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
11009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11010 if (!SWIG_IsOK(res1)) {
11011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11012 }
11013 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11014 {
11015 arg2 = wxString_in_helper(obj1);
11016 if (arg2 == NULL) SWIG_fail;
11017 temp2 = true;
11018 }
11019 {
11020 PyThreadState* __tstate = wxPyBeginAllowThreads();
11021 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11022 wxPyEndAllowThreads(__tstate);
11023 if (PyErr_Occurred()) SWIG_fail;
11024 }
11025 {
11026 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11027 }
11028 {
11029 if (temp2)
11030 delete arg2;
11031 }
11032 return resultobj;
11033 fail:
11034 {
11035 if (temp2)
11036 delete arg2;
11037 }
11038 return NULL;
11039 }
11040
11041
11042 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj = 0;
11044 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11045 wxString *arg2 = 0 ;
11046 int arg3 = (int) 0 ;
11047 wxString result;
11048 void *argp1 = 0 ;
11049 int res1 = 0 ;
11050 bool temp2 = false ;
11051 int val3 ;
11052 int ecode3 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 PyObject * obj2 = 0 ;
11056 char * kwnames[] = {
11057 (char *) "self",(char *) "spec",(char *) "flags", NULL
11058 };
11059
11060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11062 if (!SWIG_IsOK(res1)) {
11063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11064 }
11065 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11066 {
11067 arg2 = wxString_in_helper(obj1);
11068 if (arg2 == NULL) SWIG_fail;
11069 temp2 = true;
11070 }
11071 if (obj2) {
11072 ecode3 = SWIG_AsVal_int(obj2, &val3);
11073 if (!SWIG_IsOK(ecode3)) {
11074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11075 }
11076 arg3 = static_cast< int >(val3);
11077 }
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 {
11085 #if wxUSE_UNICODE
11086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11087 #else
11088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11089 #endif
11090 }
11091 {
11092 if (temp2)
11093 delete arg2;
11094 }
11095 return resultobj;
11096 fail:
11097 {
11098 if (temp2)
11099 delete arg2;
11100 }
11101 return NULL;
11102 }
11103
11104
11105 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11106 PyObject *resultobj = 0;
11107 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11108 wxString result;
11109 void *argp1 = 0 ;
11110 int res1 = 0 ;
11111 PyObject *swig_obj[1] ;
11112
11113 if (!args) SWIG_fail;
11114 swig_obj[0] = args;
11115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11116 if (!SWIG_IsOK(res1)) {
11117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11118 }
11119 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11120 {
11121 PyThreadState* __tstate = wxPyBeginAllowThreads();
11122 result = (arg1)->FindNext();
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 {
11127 #if wxUSE_UNICODE
11128 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11129 #else
11130 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11131 #endif
11132 }
11133 return resultobj;
11134 fail:
11135 return NULL;
11136 }
11137
11138
11139 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11140 PyObject *resultobj = 0;
11141 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11142 int res1 = 0 ;
11143 PyObject * obj0 = 0 ;
11144 char * kwnames[] = {
11145 (char *) "handler", NULL
11146 };
11147
11148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11149 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11150 if (!SWIG_IsOK(res1)) {
11151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11152 }
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 wxFileSystem::AddHandler(arg1);
11156 wxPyEndAllowThreads(__tstate);
11157 if (PyErr_Occurred()) SWIG_fail;
11158 }
11159 resultobj = SWIG_Py_Void();
11160 return resultobj;
11161 fail:
11162 return NULL;
11163 }
11164
11165
11166 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11167 PyObject *resultobj = 0;
11168 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11169 wxFileSystemHandler *result = 0 ;
11170 void *argp1 = 0 ;
11171 int res1 = 0 ;
11172 PyObject * obj0 = 0 ;
11173 char * kwnames[] = {
11174 (char *) "handler", NULL
11175 };
11176
11177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11179 if (!SWIG_IsOK(res1)) {
11180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11181 }
11182 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11186 wxPyEndAllowThreads(__tstate);
11187 if (PyErr_Occurred()) SWIG_fail;
11188 }
11189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11197 PyObject *resultobj = 0;
11198
11199 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 wxFileSystem::CleanUpHandlers();
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 resultobj = SWIG_Py_Void();
11207 return resultobj;
11208 fail:
11209 return NULL;
11210 }
11211
11212
11213 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj = 0;
11215 wxString *arg1 = 0 ;
11216 wxString result;
11217 bool temp1 = false ;
11218 PyObject * obj0 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "filename", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11224 {
11225 arg1 = wxString_in_helper(obj0);
11226 if (arg1 == NULL) SWIG_fail;
11227 temp1 = true;
11228 }
11229 {
11230 PyThreadState* __tstate = wxPyBeginAllowThreads();
11231 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 {
11236 #if wxUSE_UNICODE
11237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11238 #else
11239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11240 #endif
11241 }
11242 {
11243 if (temp1)
11244 delete arg1;
11245 }
11246 return resultobj;
11247 fail:
11248 {
11249 if (temp1)
11250 delete arg1;
11251 }
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj = 0;
11258 wxString *arg1 = 0 ;
11259 wxString result;
11260 bool temp1 = false ;
11261 PyObject * obj0 = 0 ;
11262 char * kwnames[] = {
11263 (char *) "url", NULL
11264 };
11265
11266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11267 {
11268 arg1 = wxString_in_helper(obj0);
11269 if (arg1 == NULL) SWIG_fail;
11270 temp1 = true;
11271 }
11272 {
11273 PyThreadState* __tstate = wxPyBeginAllowThreads();
11274 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11275 wxPyEndAllowThreads(__tstate);
11276 if (PyErr_Occurred()) SWIG_fail;
11277 }
11278 {
11279 #if wxUSE_UNICODE
11280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11281 #else
11282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11283 #endif
11284 }
11285 {
11286 if (temp1)
11287 delete arg1;
11288 }
11289 return resultobj;
11290 fail:
11291 {
11292 if (temp1)
11293 delete arg1;
11294 }
11295 return NULL;
11296 }
11297
11298
11299 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11300 PyObject *obj;
11301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11302 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11303 return SWIG_Py_Void();
11304 }
11305
11306 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11307 return SWIG_Python_InitShadowInstance(args);
11308 }
11309
11310 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11311 PyObject *resultobj = 0;
11312 wxInternetFSHandler *result = 0 ;
11313
11314 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11315 {
11316 PyThreadState* __tstate = wxPyBeginAllowThreads();
11317 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11318 wxPyEndAllowThreads(__tstate);
11319 if (PyErr_Occurred()) SWIG_fail;
11320 }
11321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11322 return resultobj;
11323 fail:
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11329 PyObject *resultobj = 0;
11330 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11331 wxString *arg2 = 0 ;
11332 bool result;
11333 void *argp1 = 0 ;
11334 int res1 = 0 ;
11335 bool temp2 = false ;
11336 PyObject * obj0 = 0 ;
11337 PyObject * obj1 = 0 ;
11338 char * kwnames[] = {
11339 (char *) "self",(char *) "location", NULL
11340 };
11341
11342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11344 if (!SWIG_IsOK(res1)) {
11345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11346 }
11347 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11348 {
11349 arg2 = wxString_in_helper(obj1);
11350 if (arg2 == NULL) SWIG_fail;
11351 temp2 = true;
11352 }
11353 {
11354 PyThreadState* __tstate = wxPyBeginAllowThreads();
11355 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11356 wxPyEndAllowThreads(__tstate);
11357 if (PyErr_Occurred()) SWIG_fail;
11358 }
11359 {
11360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11361 }
11362 {
11363 if (temp2)
11364 delete arg2;
11365 }
11366 return resultobj;
11367 fail:
11368 {
11369 if (temp2)
11370 delete arg2;
11371 }
11372 return NULL;
11373 }
11374
11375
11376 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11377 PyObject *resultobj = 0;
11378 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11379 wxFileSystem *arg2 = 0 ;
11380 wxString *arg3 = 0 ;
11381 wxFSFile *result = 0 ;
11382 void *argp1 = 0 ;
11383 int res1 = 0 ;
11384 void *argp2 = 0 ;
11385 int res2 = 0 ;
11386 bool temp3 = false ;
11387 PyObject * obj0 = 0 ;
11388 PyObject * obj1 = 0 ;
11389 PyObject * obj2 = 0 ;
11390 char * kwnames[] = {
11391 (char *) "self",(char *) "fs",(char *) "location", NULL
11392 };
11393
11394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11396 if (!SWIG_IsOK(res1)) {
11397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11398 }
11399 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11400 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11401 if (!SWIG_IsOK(res2)) {
11402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11403 }
11404 if (!argp2) {
11405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11406 }
11407 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11408 {
11409 arg3 = wxString_in_helper(obj2);
11410 if (arg3 == NULL) SWIG_fail;
11411 temp3 = true;
11412 }
11413 {
11414 PyThreadState* __tstate = wxPyBeginAllowThreads();
11415 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11416 wxPyEndAllowThreads(__tstate);
11417 if (PyErr_Occurred()) SWIG_fail;
11418 }
11419 {
11420 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11421 }
11422 {
11423 if (temp3)
11424 delete arg3;
11425 }
11426 return resultobj;
11427 fail:
11428 {
11429 if (temp3)
11430 delete arg3;
11431 }
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11437 PyObject *obj;
11438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11439 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11440 return SWIG_Py_Void();
11441 }
11442
11443 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11444 return SWIG_Python_InitShadowInstance(args);
11445 }
11446
11447 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11448 PyObject *resultobj = 0;
11449 wxZipFSHandler *result = 0 ;
11450
11451 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 result = (wxZipFSHandler *)new wxZipFSHandler();
11455 wxPyEndAllowThreads(__tstate);
11456 if (PyErr_Occurred()) SWIG_fail;
11457 }
11458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11459 return resultobj;
11460 fail:
11461 return NULL;
11462 }
11463
11464
11465 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11466 PyObject *resultobj = 0;
11467 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11468 wxString *arg2 = 0 ;
11469 bool result;
11470 void *argp1 = 0 ;
11471 int res1 = 0 ;
11472 bool temp2 = false ;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 char * kwnames[] = {
11476 (char *) "self",(char *) "location", NULL
11477 };
11478
11479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11481 if (!SWIG_IsOK(res1)) {
11482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11483 }
11484 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11485 {
11486 arg2 = wxString_in_helper(obj1);
11487 if (arg2 == NULL) SWIG_fail;
11488 temp2 = true;
11489 }
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11493 wxPyEndAllowThreads(__tstate);
11494 if (PyErr_Occurred()) SWIG_fail;
11495 }
11496 {
11497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11498 }
11499 {
11500 if (temp2)
11501 delete arg2;
11502 }
11503 return resultobj;
11504 fail:
11505 {
11506 if (temp2)
11507 delete arg2;
11508 }
11509 return NULL;
11510 }
11511
11512
11513 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11514 PyObject *resultobj = 0;
11515 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11516 wxFileSystem *arg2 = 0 ;
11517 wxString *arg3 = 0 ;
11518 wxFSFile *result = 0 ;
11519 void *argp1 = 0 ;
11520 int res1 = 0 ;
11521 void *argp2 = 0 ;
11522 int res2 = 0 ;
11523 bool temp3 = false ;
11524 PyObject * obj0 = 0 ;
11525 PyObject * obj1 = 0 ;
11526 PyObject * obj2 = 0 ;
11527 char * kwnames[] = {
11528 (char *) "self",(char *) "fs",(char *) "location", NULL
11529 };
11530
11531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11533 if (!SWIG_IsOK(res1)) {
11534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11535 }
11536 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11538 if (!SWIG_IsOK(res2)) {
11539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11540 }
11541 if (!argp2) {
11542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11543 }
11544 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11545 {
11546 arg3 = wxString_in_helper(obj2);
11547 if (arg3 == NULL) SWIG_fail;
11548 temp3 = true;
11549 }
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 {
11557 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11558 }
11559 {
11560 if (temp3)
11561 delete arg3;
11562 }
11563 return resultobj;
11564 fail:
11565 {
11566 if (temp3)
11567 delete arg3;
11568 }
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj = 0;
11575 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11576 wxString *arg2 = 0 ;
11577 int arg3 = (int) 0 ;
11578 wxString result;
11579 void *argp1 = 0 ;
11580 int res1 = 0 ;
11581 bool temp2 = false ;
11582 int val3 ;
11583 int ecode3 = 0 ;
11584 PyObject * obj0 = 0 ;
11585 PyObject * obj1 = 0 ;
11586 PyObject * obj2 = 0 ;
11587 char * kwnames[] = {
11588 (char *) "self",(char *) "spec",(char *) "flags", NULL
11589 };
11590
11591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11593 if (!SWIG_IsOK(res1)) {
11594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11595 }
11596 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11597 {
11598 arg2 = wxString_in_helper(obj1);
11599 if (arg2 == NULL) SWIG_fail;
11600 temp2 = true;
11601 }
11602 if (obj2) {
11603 ecode3 = SWIG_AsVal_int(obj2, &val3);
11604 if (!SWIG_IsOK(ecode3)) {
11605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11606 }
11607 arg3 = static_cast< int >(val3);
11608 }
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 {
11616 #if wxUSE_UNICODE
11617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11618 #else
11619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11620 #endif
11621 }
11622 {
11623 if (temp2)
11624 delete arg2;
11625 }
11626 return resultobj;
11627 fail:
11628 {
11629 if (temp2)
11630 delete arg2;
11631 }
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11637 PyObject *resultobj = 0;
11638 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11639 wxString result;
11640 void *argp1 = 0 ;
11641 int res1 = 0 ;
11642 PyObject *swig_obj[1] ;
11643
11644 if (!args) SWIG_fail;
11645 swig_obj[0] = args;
11646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11647 if (!SWIG_IsOK(res1)) {
11648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11649 }
11650 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 result = (arg1)->FindNext();
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 {
11658 #if wxUSE_UNICODE
11659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11660 #else
11661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11662 #endif
11663 }
11664 return resultobj;
11665 fail:
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11671 PyObject *obj;
11672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11673 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11674 return SWIG_Py_Void();
11675 }
11676
11677 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11678 return SWIG_Python_InitShadowInstance(args);
11679 }
11680
11681 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11682 PyObject *resultobj = 0;
11683 wxString *arg1 = 0 ;
11684 wxImage *arg2 = 0 ;
11685 long arg3 ;
11686 bool temp1 = false ;
11687 void *argp2 = 0 ;
11688 int res2 = 0 ;
11689 long val3 ;
11690 int ecode3 = 0 ;
11691 PyObject * obj0 = 0 ;
11692 PyObject * obj1 = 0 ;
11693 PyObject * obj2 = 0 ;
11694 char * kwnames[] = {
11695 (char *) "filename",(char *) "image",(char *) "type", NULL
11696 };
11697
11698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11699 {
11700 arg1 = wxString_in_helper(obj0);
11701 if (arg1 == NULL) SWIG_fail;
11702 temp1 = true;
11703 }
11704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11705 if (!SWIG_IsOK(res2)) {
11706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11707 }
11708 if (!argp2) {
11709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11710 }
11711 arg2 = reinterpret_cast< wxImage * >(argp2);
11712 ecode3 = SWIG_AsVal_long(obj2, &val3);
11713 if (!SWIG_IsOK(ecode3)) {
11714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11715 }
11716 arg3 = static_cast< long >(val3);
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11720 wxPyEndAllowThreads(__tstate);
11721 if (PyErr_Occurred()) SWIG_fail;
11722 }
11723 resultobj = SWIG_Py_Void();
11724 {
11725 if (temp1)
11726 delete arg1;
11727 }
11728 return resultobj;
11729 fail:
11730 {
11731 if (temp1)
11732 delete arg1;
11733 }
11734 return NULL;
11735 }
11736
11737
11738 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11739 PyObject *resultobj = 0;
11740 wxString *arg1 = 0 ;
11741 wxBitmap *arg2 = 0 ;
11742 long arg3 ;
11743 bool temp1 = false ;
11744 void *argp2 = 0 ;
11745 int res2 = 0 ;
11746 long val3 ;
11747 int ecode3 = 0 ;
11748 PyObject * obj0 = 0 ;
11749 PyObject * obj1 = 0 ;
11750 PyObject * obj2 = 0 ;
11751 char * kwnames[] = {
11752 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11753 };
11754
11755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11756 {
11757 arg1 = wxString_in_helper(obj0);
11758 if (arg1 == NULL) SWIG_fail;
11759 temp1 = true;
11760 }
11761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11762 if (!SWIG_IsOK(res2)) {
11763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11764 }
11765 if (!argp2) {
11766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11767 }
11768 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11769 ecode3 = SWIG_AsVal_long(obj2, &val3);
11770 if (!SWIG_IsOK(ecode3)) {
11771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11772 }
11773 arg3 = static_cast< long >(val3);
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_Py_Void();
11781 {
11782 if (temp1)
11783 delete arg1;
11784 }
11785 return resultobj;
11786 fail:
11787 {
11788 if (temp1)
11789 delete arg1;
11790 }
11791 return NULL;
11792 }
11793
11794
11795 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj = 0;
11797 wxString *arg1 = 0 ;
11798 PyObject *arg2 = (PyObject *) 0 ;
11799 bool temp1 = false ;
11800 PyObject * obj0 = 0 ;
11801 PyObject * obj1 = 0 ;
11802 char * kwnames[] = {
11803 (char *) "filename",(char *) "data", NULL
11804 };
11805
11806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11807 {
11808 arg1 = wxString_in_helper(obj0);
11809 if (arg1 == NULL) SWIG_fail;
11810 temp1 = true;
11811 }
11812 arg2 = obj1;
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 resultobj = SWIG_Py_Void();
11820 {
11821 if (temp1)
11822 delete arg1;
11823 }
11824 return resultobj;
11825 fail:
11826 {
11827 if (temp1)
11828 delete arg1;
11829 }
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxMemoryFSHandler *result = 0 ;
11837
11838 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11839 {
11840 PyThreadState* __tstate = wxPyBeginAllowThreads();
11841 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11842 wxPyEndAllowThreads(__tstate);
11843 if (PyErr_Occurred()) SWIG_fail;
11844 }
11845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11846 return resultobj;
11847 fail:
11848 return NULL;
11849 }
11850
11851
11852 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11853 PyObject *resultobj = 0;
11854 wxString *arg1 = 0 ;
11855 bool temp1 = false ;
11856 PyObject * obj0 = 0 ;
11857 char * kwnames[] = {
11858 (char *) "filename", NULL
11859 };
11860
11861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11862 {
11863 arg1 = wxString_in_helper(obj0);
11864 if (arg1 == NULL) SWIG_fail;
11865 temp1 = true;
11866 }
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 resultobj = SWIG_Py_Void();
11874 {
11875 if (temp1)
11876 delete arg1;
11877 }
11878 return resultobj;
11879 fail:
11880 {
11881 if (temp1)
11882 delete arg1;
11883 }
11884 return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj = 0;
11890 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11891 wxString *arg2 = 0 ;
11892 bool result;
11893 void *argp1 = 0 ;
11894 int res1 = 0 ;
11895 bool temp2 = false ;
11896 PyObject * obj0 = 0 ;
11897 PyObject * obj1 = 0 ;
11898 char * kwnames[] = {
11899 (char *) "self",(char *) "location", NULL
11900 };
11901
11902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11906 }
11907 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11908 {
11909 arg2 = wxString_in_helper(obj1);
11910 if (arg2 == NULL) SWIG_fail;
11911 temp2 = true;
11912 }
11913 {
11914 PyThreadState* __tstate = wxPyBeginAllowThreads();
11915 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 {
11920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11921 }
11922 {
11923 if (temp2)
11924 delete arg2;
11925 }
11926 return resultobj;
11927 fail:
11928 {
11929 if (temp2)
11930 delete arg2;
11931 }
11932 return NULL;
11933 }
11934
11935
11936 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11937 PyObject *resultobj = 0;
11938 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11939 wxFileSystem *arg2 = 0 ;
11940 wxString *arg3 = 0 ;
11941 wxFSFile *result = 0 ;
11942 void *argp1 = 0 ;
11943 int res1 = 0 ;
11944 void *argp2 = 0 ;
11945 int res2 = 0 ;
11946 bool temp3 = false ;
11947 PyObject * obj0 = 0 ;
11948 PyObject * obj1 = 0 ;
11949 PyObject * obj2 = 0 ;
11950 char * kwnames[] = {
11951 (char *) "self",(char *) "fs",(char *) "location", NULL
11952 };
11953
11954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11956 if (!SWIG_IsOK(res1)) {
11957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11958 }
11959 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11961 if (!SWIG_IsOK(res2)) {
11962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11963 }
11964 if (!argp2) {
11965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11966 }
11967 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11968 {
11969 arg3 = wxString_in_helper(obj2);
11970 if (arg3 == NULL) SWIG_fail;
11971 temp3 = true;
11972 }
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 {
11980 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11981 }
11982 {
11983 if (temp3)
11984 delete arg3;
11985 }
11986 return resultobj;
11987 fail:
11988 {
11989 if (temp3)
11990 delete arg3;
11991 }
11992 return NULL;
11993 }
11994
11995
11996 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11997 PyObject *resultobj = 0;
11998 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11999 wxString *arg2 = 0 ;
12000 int arg3 = (int) 0 ;
12001 wxString result;
12002 void *argp1 = 0 ;
12003 int res1 = 0 ;
12004 bool temp2 = false ;
12005 int val3 ;
12006 int ecode3 = 0 ;
12007 PyObject * obj0 = 0 ;
12008 PyObject * obj1 = 0 ;
12009 PyObject * obj2 = 0 ;
12010 char * kwnames[] = {
12011 (char *) "self",(char *) "spec",(char *) "flags", NULL
12012 };
12013
12014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12016 if (!SWIG_IsOK(res1)) {
12017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12018 }
12019 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12020 {
12021 arg2 = wxString_in_helper(obj1);
12022 if (arg2 == NULL) SWIG_fail;
12023 temp2 = true;
12024 }
12025 if (obj2) {
12026 ecode3 = SWIG_AsVal_int(obj2, &val3);
12027 if (!SWIG_IsOK(ecode3)) {
12028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12029 }
12030 arg3 = static_cast< int >(val3);
12031 }
12032 {
12033 PyThreadState* __tstate = wxPyBeginAllowThreads();
12034 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 #if wxUSE_UNICODE
12040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12041 #else
12042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12043 #endif
12044 }
12045 {
12046 if (temp2)
12047 delete arg2;
12048 }
12049 return resultobj;
12050 fail:
12051 {
12052 if (temp2)
12053 delete arg2;
12054 }
12055 return NULL;
12056 }
12057
12058
12059 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12060 PyObject *resultobj = 0;
12061 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12062 wxString result;
12063 void *argp1 = 0 ;
12064 int res1 = 0 ;
12065 PyObject *swig_obj[1] ;
12066
12067 if (!args) SWIG_fail;
12068 swig_obj[0] = args;
12069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12070 if (!SWIG_IsOK(res1)) {
12071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12072 }
12073 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12074 {
12075 PyThreadState* __tstate = wxPyBeginAllowThreads();
12076 result = (arg1)->FindNext();
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 {
12081 #if wxUSE_UNICODE
12082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12083 #else
12084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12085 #endif
12086 }
12087 return resultobj;
12088 fail:
12089 return NULL;
12090 }
12091
12092
12093 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12094 PyObject *obj;
12095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12096 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12097 return SWIG_Py_Void();
12098 }
12099
12100 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 return SWIG_Python_InitShadowInstance(args);
12102 }
12103
12104 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12105 PyObject *resultobj = 0;
12106 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12107 wxString result;
12108 void *argp1 = 0 ;
12109 int res1 = 0 ;
12110 PyObject *swig_obj[1] ;
12111
12112 if (!args) SWIG_fail;
12113 swig_obj[0] = args;
12114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12117 }
12118 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (arg1)->GetName();
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 #if wxUSE_UNICODE
12127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12128 #else
12129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12130 #endif
12131 }
12132 return resultobj;
12133 fail:
12134 return NULL;
12135 }
12136
12137
12138 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12139 PyObject *resultobj = 0;
12140 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12141 wxString result;
12142 void *argp1 = 0 ;
12143 int res1 = 0 ;
12144 PyObject *swig_obj[1] ;
12145
12146 if (!args) SWIG_fail;
12147 swig_obj[0] = args;
12148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12149 if (!SWIG_IsOK(res1)) {
12150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12151 }
12152 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (arg1)->GetExtension();
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 {
12160 #if wxUSE_UNICODE
12161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12162 #else
12163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12164 #endif
12165 }
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *resultobj = 0;
12174 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12175 long result;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 PyObject *swig_obj[1] ;
12179
12180 if (!args) SWIG_fail;
12181 swig_obj[0] = args;
12182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12185 }
12186 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (long)(arg1)->GetType();
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 resultobj = SWIG_From_long(static_cast< long >(result));
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201 PyObject *resultobj = 0;
12202 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12203 wxString result;
12204 void *argp1 = 0 ;
12205 int res1 = 0 ;
12206 PyObject *swig_obj[1] ;
12207
12208 if (!args) SWIG_fail;
12209 swig_obj[0] = args;
12210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12211 if (!SWIG_IsOK(res1)) {
12212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12213 }
12214 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (arg1)->GetMimeType();
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 {
12222 #if wxUSE_UNICODE
12223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12224 #else
12225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12226 #endif
12227 }
12228 return resultobj;
12229 fail:
12230 return NULL;
12231 }
12232
12233
12234 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12235 PyObject *resultobj = 0;
12236 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12237 wxString *arg2 = 0 ;
12238 bool result;
12239 void *argp1 = 0 ;
12240 int res1 = 0 ;
12241 bool temp2 = false ;
12242 PyObject * obj0 = 0 ;
12243 PyObject * obj1 = 0 ;
12244 char * kwnames[] = {
12245 (char *) "self",(char *) "name", NULL
12246 };
12247
12248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12250 if (!SWIG_IsOK(res1)) {
12251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12252 }
12253 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12254 {
12255 arg2 = wxString_in_helper(obj1);
12256 if (arg2 == NULL) SWIG_fail;
12257 temp2 = true;
12258 }
12259 {
12260 PyThreadState* __tstate = wxPyBeginAllowThreads();
12261 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12262 wxPyEndAllowThreads(__tstate);
12263 if (PyErr_Occurred()) SWIG_fail;
12264 }
12265 {
12266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12267 }
12268 {
12269 if (temp2)
12270 delete arg2;
12271 }
12272 return resultobj;
12273 fail:
12274 {
12275 if (temp2)
12276 delete arg2;
12277 }
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj = 0;
12284 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12285 wxInputStream *arg2 = 0 ;
12286 bool result;
12287 void *argp1 = 0 ;
12288 int res1 = 0 ;
12289 wxPyInputStream *temp2 ;
12290 bool created2 ;
12291 PyObject * obj0 = 0 ;
12292 PyObject * obj1 = 0 ;
12293 char * kwnames[] = {
12294 (char *) "self",(char *) "stream", NULL
12295 };
12296
12297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12299 if (!SWIG_IsOK(res1)) {
12300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12301 }
12302 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12303 {
12304 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12305 arg2 = temp2->m_wxis;
12306 created2 = false;
12307 } else {
12308 PyErr_Clear(); // clear the failure of the wxPyConvert above
12309 arg2 = wxPyCBInputStream_create(obj1, false);
12310 if (arg2 == NULL) {
12311 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12312 SWIG_fail;
12313 }
12314 created2 = true;
12315 }
12316 }
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 result = (bool)(arg1)->CanRead(*arg2);
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 {
12324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12325 }
12326 {
12327 if (created2) delete arg2;
12328 }
12329 return resultobj;
12330 fail:
12331 {
12332 if (created2) delete arg2;
12333 }
12334 return NULL;
12335 }
12336
12337
12338 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12339 PyObject *resultobj = 0;
12340 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12341 wxString *arg2 = 0 ;
12342 void *argp1 = 0 ;
12343 int res1 = 0 ;
12344 bool temp2 = false ;
12345 PyObject * obj0 = 0 ;
12346 PyObject * obj1 = 0 ;
12347 char * kwnames[] = {
12348 (char *) "self",(char *) "name", NULL
12349 };
12350
12351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12353 if (!SWIG_IsOK(res1)) {
12354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12355 }
12356 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12357 {
12358 arg2 = wxString_in_helper(obj1);
12359 if (arg2 == NULL) SWIG_fail;
12360 temp2 = true;
12361 }
12362 {
12363 PyThreadState* __tstate = wxPyBeginAllowThreads();
12364 (arg1)->SetName((wxString const &)*arg2);
12365 wxPyEndAllowThreads(__tstate);
12366 if (PyErr_Occurred()) SWIG_fail;
12367 }
12368 resultobj = SWIG_Py_Void();
12369 {
12370 if (temp2)
12371 delete arg2;
12372 }
12373 return resultobj;
12374 fail:
12375 {
12376 if (temp2)
12377 delete arg2;
12378 }
12379 return NULL;
12380 }
12381
12382
12383 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj = 0;
12385 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12386 wxString *arg2 = 0 ;
12387 void *argp1 = 0 ;
12388 int res1 = 0 ;
12389 bool temp2 = false ;
12390 PyObject * obj0 = 0 ;
12391 PyObject * obj1 = 0 ;
12392 char * kwnames[] = {
12393 (char *) "self",(char *) "extension", NULL
12394 };
12395
12396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12398 if (!SWIG_IsOK(res1)) {
12399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12400 }
12401 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12402 {
12403 arg2 = wxString_in_helper(obj1);
12404 if (arg2 == NULL) SWIG_fail;
12405 temp2 = true;
12406 }
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 (arg1)->SetExtension((wxString const &)*arg2);
12410 wxPyEndAllowThreads(__tstate);
12411 if (PyErr_Occurred()) SWIG_fail;
12412 }
12413 resultobj = SWIG_Py_Void();
12414 {
12415 if (temp2)
12416 delete arg2;
12417 }
12418 return resultobj;
12419 fail:
12420 {
12421 if (temp2)
12422 delete arg2;
12423 }
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12429 PyObject *resultobj = 0;
12430 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12431 long arg2 ;
12432 void *argp1 = 0 ;
12433 int res1 = 0 ;
12434 long val2 ;
12435 int ecode2 = 0 ;
12436 PyObject * obj0 = 0 ;
12437 PyObject * obj1 = 0 ;
12438 char * kwnames[] = {
12439 (char *) "self",(char *) "type", NULL
12440 };
12441
12442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12444 if (!SWIG_IsOK(res1)) {
12445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12446 }
12447 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12448 ecode2 = SWIG_AsVal_long(obj1, &val2);
12449 if (!SWIG_IsOK(ecode2)) {
12450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12451 }
12452 arg2 = static_cast< long >(val2);
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 (arg1)->SetType(arg2);
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 resultobj = SWIG_Py_Void();
12460 return resultobj;
12461 fail:
12462 return NULL;
12463 }
12464
12465
12466 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12467 PyObject *resultobj = 0;
12468 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12469 wxString *arg2 = 0 ;
12470 void *argp1 = 0 ;
12471 int res1 = 0 ;
12472 bool temp2 = false ;
12473 PyObject * obj0 = 0 ;
12474 PyObject * obj1 = 0 ;
12475 char * kwnames[] = {
12476 (char *) "self",(char *) "mimetype", NULL
12477 };
12478
12479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12481 if (!SWIG_IsOK(res1)) {
12482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12483 }
12484 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12485 {
12486 arg2 = wxString_in_helper(obj1);
12487 if (arg2 == NULL) SWIG_fail;
12488 temp2 = true;
12489 }
12490 {
12491 PyThreadState* __tstate = wxPyBeginAllowThreads();
12492 (arg1)->SetMimeType((wxString const &)*arg2);
12493 wxPyEndAllowThreads(__tstate);
12494 if (PyErr_Occurred()) SWIG_fail;
12495 }
12496 resultobj = SWIG_Py_Void();
12497 {
12498 if (temp2)
12499 delete arg2;
12500 }
12501 return resultobj;
12502 fail:
12503 {
12504 if (temp2)
12505 delete arg2;
12506 }
12507 return NULL;
12508 }
12509
12510
12511 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12512 PyObject *obj;
12513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12514 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12515 return SWIG_Py_Void();
12516 }
12517
12518 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12519 PyObject *resultobj = 0;
12520 wxPyImageHandler *result = 0 ;
12521
12522 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12523 {
12524 PyThreadState* __tstate = wxPyBeginAllowThreads();
12525 result = (wxPyImageHandler *)new wxPyImageHandler();
12526 wxPyEndAllowThreads(__tstate);
12527 if (PyErr_Occurred()) SWIG_fail;
12528 }
12529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12530 return resultobj;
12531 fail:
12532 return NULL;
12533 }
12534
12535
12536 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12537 PyObject *resultobj = 0;
12538 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12539 PyObject *arg2 = (PyObject *) 0 ;
12540 void *argp1 = 0 ;
12541 int res1 = 0 ;
12542 PyObject * obj0 = 0 ;
12543 PyObject * obj1 = 0 ;
12544 char * kwnames[] = {
12545 (char *) "self",(char *) "self", NULL
12546 };
12547
12548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12550 if (!SWIG_IsOK(res1)) {
12551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12552 }
12553 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12554 arg2 = obj1;
12555 {
12556 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 (arg1)->_SetSelf(arg2);
12558 wxPyEndAllowThreads(__tstate);
12559 if (PyErr_Occurred()) SWIG_fail;
12560 }
12561 resultobj = SWIG_Py_Void();
12562 return resultobj;
12563 fail:
12564 return NULL;
12565 }
12566
12567
12568 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12569 PyObject *obj;
12570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12571 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12572 return SWIG_Py_Void();
12573 }
12574
12575 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12576 return SWIG_Python_InitShadowInstance(args);
12577 }
12578
12579 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12580 PyObject *resultobj = 0;
12581 wxImageHistogram *result = 0 ;
12582
12583 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (wxImageHistogram *)new wxImageHistogram();
12587 wxPyEndAllowThreads(__tstate);
12588 if (PyErr_Occurred()) SWIG_fail;
12589 }
12590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12591 return resultobj;
12592 fail:
12593 return NULL;
12594 }
12595
12596
12597 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12598 PyObject *resultobj = 0;
12599 byte arg1 ;
12600 byte arg2 ;
12601 byte arg3 ;
12602 unsigned long result;
12603 unsigned char val1 ;
12604 int ecode1 = 0 ;
12605 unsigned char val2 ;
12606 int ecode2 = 0 ;
12607 unsigned char val3 ;
12608 int ecode3 = 0 ;
12609 PyObject * obj0 = 0 ;
12610 PyObject * obj1 = 0 ;
12611 PyObject * obj2 = 0 ;
12612 char * kwnames[] = {
12613 (char *) "r",(char *) "g",(char *) "b", NULL
12614 };
12615
12616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12617 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12618 if (!SWIG_IsOK(ecode1)) {
12619 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12620 }
12621 arg1 = static_cast< byte >(val1);
12622 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12623 if (!SWIG_IsOK(ecode2)) {
12624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12625 }
12626 arg2 = static_cast< byte >(val2);
12627 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12628 if (!SWIG_IsOK(ecode3)) {
12629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12630 }
12631 arg3 = static_cast< byte >(val3);
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12639 return resultobj;
12640 fail:
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12646 PyObject *resultobj = 0;
12647 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12648 byte *arg2 = (byte *) 0 ;
12649 byte *arg3 = (byte *) 0 ;
12650 byte *arg4 = (byte *) 0 ;
12651 byte arg5 = (byte) 1 ;
12652 byte arg6 = (byte) 0 ;
12653 byte arg7 = (byte) 0 ;
12654 bool result;
12655 void *argp1 = 0 ;
12656 int res1 = 0 ;
12657 byte temp2 ;
12658 int res2 = SWIG_TMPOBJ ;
12659 byte temp3 ;
12660 int res3 = SWIG_TMPOBJ ;
12661 byte temp4 ;
12662 int res4 = SWIG_TMPOBJ ;
12663 unsigned char val5 ;
12664 int ecode5 = 0 ;
12665 unsigned char val6 ;
12666 int ecode6 = 0 ;
12667 unsigned char val7 ;
12668 int ecode7 = 0 ;
12669 PyObject * obj0 = 0 ;
12670 PyObject * obj1 = 0 ;
12671 PyObject * obj2 = 0 ;
12672 PyObject * obj3 = 0 ;
12673 char * kwnames[] = {
12674 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12675 };
12676
12677 arg2 = &temp2;
12678 arg3 = &temp3;
12679 arg4 = &temp4;
12680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12682 if (!SWIG_IsOK(res1)) {
12683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12684 }
12685 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12686 if (obj1) {
12687 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12688 if (!SWIG_IsOK(ecode5)) {
12689 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12690 }
12691 arg5 = static_cast< byte >(val5);
12692 }
12693 if (obj2) {
12694 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12695 if (!SWIG_IsOK(ecode6)) {
12696 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12697 }
12698 arg6 = static_cast< byte >(val6);
12699 }
12700 if (obj3) {
12701 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12702 if (!SWIG_IsOK(ecode7)) {
12703 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12704 }
12705 arg7 = static_cast< byte >(val7);
12706 }
12707 {
12708 PyThreadState* __tstate = wxPyBeginAllowThreads();
12709 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12715 }
12716 if (SWIG_IsTmpObj(res2)) {
12717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12718 } else {
12719 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12721 }
12722 if (SWIG_IsTmpObj(res3)) {
12723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12724 } else {
12725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12727 }
12728 if (SWIG_IsTmpObj(res4)) {
12729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12730 } else {
12731 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12733 }
12734 return resultobj;
12735 fail:
12736 return NULL;
12737 }
12738
12739
12740 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12741 PyObject *resultobj = 0;
12742 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12743 unsigned long arg2 ;
12744 unsigned long result;
12745 void *argp1 = 0 ;
12746 int res1 = 0 ;
12747 unsigned long val2 ;
12748 int ecode2 = 0 ;
12749 PyObject * obj0 = 0 ;
12750 PyObject * obj1 = 0 ;
12751 char * kwnames[] = {
12752 (char *) "self",(char *) "key", NULL
12753 };
12754
12755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12757 if (!SWIG_IsOK(res1)) {
12758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12759 }
12760 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12761 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12762 if (!SWIG_IsOK(ecode2)) {
12763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12764 }
12765 arg2 = static_cast< unsigned long >(val2);
12766 {
12767 PyThreadState* __tstate = wxPyBeginAllowThreads();
12768 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12769 wxPyEndAllowThreads(__tstate);
12770 if (PyErr_Occurred()) SWIG_fail;
12771 }
12772 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12773 return resultobj;
12774 fail:
12775 return NULL;
12776 }
12777
12778
12779 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12780 PyObject *resultobj = 0;
12781 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12782 byte arg2 ;
12783 byte arg3 ;
12784 byte arg4 ;
12785 unsigned long result;
12786 void *argp1 = 0 ;
12787 int res1 = 0 ;
12788 unsigned char val2 ;
12789 int ecode2 = 0 ;
12790 unsigned char val3 ;
12791 int ecode3 = 0 ;
12792 unsigned char val4 ;
12793 int ecode4 = 0 ;
12794 PyObject * obj0 = 0 ;
12795 PyObject * obj1 = 0 ;
12796 PyObject * obj2 = 0 ;
12797 PyObject * obj3 = 0 ;
12798 char * kwnames[] = {
12799 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12800 };
12801
12802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12804 if (!SWIG_IsOK(res1)) {
12805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12806 }
12807 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12808 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12809 if (!SWIG_IsOK(ecode2)) {
12810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12811 }
12812 arg2 = static_cast< byte >(val2);
12813 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12814 if (!SWIG_IsOK(ecode3)) {
12815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12816 }
12817 arg3 = static_cast< byte >(val3);
12818 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12819 if (!SWIG_IsOK(ecode4)) {
12820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12821 }
12822 arg4 = static_cast< byte >(val4);
12823 {
12824 PyThreadState* __tstate = wxPyBeginAllowThreads();
12825 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12826 wxPyEndAllowThreads(__tstate);
12827 if (PyErr_Occurred()) SWIG_fail;
12828 }
12829 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12830 return resultobj;
12831 fail:
12832 return NULL;
12833 }
12834
12835
12836 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12837 PyObject *resultobj = 0;
12838 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12839 wxColour *arg2 = 0 ;
12840 unsigned long result;
12841 void *argp1 = 0 ;
12842 int res1 = 0 ;
12843 wxColour temp2 ;
12844 PyObject * obj0 = 0 ;
12845 PyObject * obj1 = 0 ;
12846 char * kwnames[] = {
12847 (char *) "self",(char *) "colour", NULL
12848 };
12849
12850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12852 if (!SWIG_IsOK(res1)) {
12853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12854 }
12855 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12856 {
12857 arg2 = &temp2;
12858 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12859 }
12860 {
12861 PyThreadState* __tstate = wxPyBeginAllowThreads();
12862 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12863 wxPyEndAllowThreads(__tstate);
12864 if (PyErr_Occurred()) SWIG_fail;
12865 }
12866 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12867 return resultobj;
12868 fail:
12869 return NULL;
12870 }
12871
12872
12873 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12874 PyObject *obj;
12875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12876 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12877 return SWIG_Py_Void();
12878 }
12879
12880 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12881 return SWIG_Python_InitShadowInstance(args);
12882 }
12883
12884 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12885 PyObject *resultobj = 0;
12886 byte arg1 = (byte) 0 ;
12887 byte arg2 = (byte) 0 ;
12888 byte arg3 = (byte) 0 ;
12889 wxImage_RGBValue *result = 0 ;
12890 unsigned char val1 ;
12891 int ecode1 = 0 ;
12892 unsigned char val2 ;
12893 int ecode2 = 0 ;
12894 unsigned char val3 ;
12895 int ecode3 = 0 ;
12896 PyObject * obj0 = 0 ;
12897 PyObject * obj1 = 0 ;
12898 PyObject * obj2 = 0 ;
12899 char * kwnames[] = {
12900 (char *) "r",(char *) "g",(char *) "b", NULL
12901 };
12902
12903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12904 if (obj0) {
12905 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12906 if (!SWIG_IsOK(ecode1)) {
12907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12908 }
12909 arg1 = static_cast< byte >(val1);
12910 }
12911 if (obj1) {
12912 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12913 if (!SWIG_IsOK(ecode2)) {
12914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12915 }
12916 arg2 = static_cast< byte >(val2);
12917 }
12918 if (obj2) {
12919 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12920 if (!SWIG_IsOK(ecode3)) {
12921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12922 }
12923 arg3 = static_cast< byte >(val3);
12924 }
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12939 PyObject *resultobj = 0;
12940 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12941 byte arg2 ;
12942 void *argp1 = 0 ;
12943 int res1 = 0 ;
12944 unsigned char val2 ;
12945 int ecode2 = 0 ;
12946 PyObject *swig_obj[2] ;
12947
12948 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12950 if (!SWIG_IsOK(res1)) {
12951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12952 }
12953 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12954 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12955 if (!SWIG_IsOK(ecode2)) {
12956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12957 }
12958 arg2 = static_cast< byte >(val2);
12959 if (arg1) (arg1)->red = arg2;
12960
12961 resultobj = SWIG_Py_Void();
12962 return resultobj;
12963 fail:
12964 return NULL;
12965 }
12966
12967
12968 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12969 PyObject *resultobj = 0;
12970 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12971 byte result;
12972 void *argp1 = 0 ;
12973 int res1 = 0 ;
12974 PyObject *swig_obj[1] ;
12975
12976 if (!args) SWIG_fail;
12977 swig_obj[0] = args;
12978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12979 if (!SWIG_IsOK(res1)) {
12980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12981 }
12982 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12983 result = (byte) ((arg1)->red);
12984 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12992 PyObject *resultobj = 0;
12993 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12994 byte arg2 ;
12995 void *argp1 = 0 ;
12996 int res1 = 0 ;
12997 unsigned char val2 ;
12998 int ecode2 = 0 ;
12999 PyObject *swig_obj[2] ;
13000
13001 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
13002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13003 if (!SWIG_IsOK(res1)) {
13004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13005 }
13006 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13007 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13008 if (!SWIG_IsOK(ecode2)) {
13009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
13010 }
13011 arg2 = static_cast< byte >(val2);
13012 if (arg1) (arg1)->green = arg2;
13013
13014 resultobj = SWIG_Py_Void();
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13022 PyObject *resultobj = 0;
13023 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13024 byte result;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 PyObject *swig_obj[1] ;
13028
13029 if (!args) SWIG_fail;
13030 swig_obj[0] = args;
13031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13032 if (!SWIG_IsOK(res1)) {
13033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13034 }
13035 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13036 result = (byte) ((arg1)->green);
13037 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13045 PyObject *resultobj = 0;
13046 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13047 byte arg2 ;
13048 void *argp1 = 0 ;
13049 int res1 = 0 ;
13050 unsigned char val2 ;
13051 int ecode2 = 0 ;
13052 PyObject *swig_obj[2] ;
13053
13054 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13056 if (!SWIG_IsOK(res1)) {
13057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13058 }
13059 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13060 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13061 if (!SWIG_IsOK(ecode2)) {
13062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13063 }
13064 arg2 = static_cast< byte >(val2);
13065 if (arg1) (arg1)->blue = arg2;
13066
13067 resultobj = SWIG_Py_Void();
13068 return resultobj;
13069 fail:
13070 return NULL;
13071 }
13072
13073
13074 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13075 PyObject *resultobj = 0;
13076 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13077 byte result;
13078 void *argp1 = 0 ;
13079 int res1 = 0 ;
13080 PyObject *swig_obj[1] ;
13081
13082 if (!args) SWIG_fail;
13083 swig_obj[0] = args;
13084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13085 if (!SWIG_IsOK(res1)) {
13086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13087 }
13088 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13089 result = (byte) ((arg1)->blue);
13090 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13098 PyObject *obj;
13099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13100 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13101 return SWIG_Py_Void();
13102 }
13103
13104 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13105 return SWIG_Python_InitShadowInstance(args);
13106 }
13107
13108 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13109 PyObject *resultobj = 0;
13110 double arg1 = (double) 0.0 ;
13111 double arg2 = (double) 0.0 ;
13112 double arg3 = (double) 0.0 ;
13113 wxImage_HSVValue *result = 0 ;
13114 double val1 ;
13115 int ecode1 = 0 ;
13116 double val2 ;
13117 int ecode2 = 0 ;
13118 double val3 ;
13119 int ecode3 = 0 ;
13120 PyObject * obj0 = 0 ;
13121 PyObject * obj1 = 0 ;
13122 PyObject * obj2 = 0 ;
13123 char * kwnames[] = {
13124 (char *) "h",(char *) "s",(char *) "v", NULL
13125 };
13126
13127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13128 if (obj0) {
13129 ecode1 = SWIG_AsVal_double(obj0, &val1);
13130 if (!SWIG_IsOK(ecode1)) {
13131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13132 }
13133 arg1 = static_cast< double >(val1);
13134 }
13135 if (obj1) {
13136 ecode2 = SWIG_AsVal_double(obj1, &val2);
13137 if (!SWIG_IsOK(ecode2)) {
13138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13139 }
13140 arg2 = static_cast< double >(val2);
13141 }
13142 if (obj2) {
13143 ecode3 = SWIG_AsVal_double(obj2, &val3);
13144 if (!SWIG_IsOK(ecode3)) {
13145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13146 }
13147 arg3 = static_cast< double >(val3);
13148 }
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13152 wxPyEndAllowThreads(__tstate);
13153 if (PyErr_Occurred()) SWIG_fail;
13154 }
13155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13156 return resultobj;
13157 fail:
13158 return NULL;
13159 }
13160
13161
13162 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13163 PyObject *resultobj = 0;
13164 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13165 double arg2 ;
13166 void *argp1 = 0 ;
13167 int res1 = 0 ;
13168 double val2 ;
13169 int ecode2 = 0 ;
13170 PyObject *swig_obj[2] ;
13171
13172 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13174 if (!SWIG_IsOK(res1)) {
13175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13176 }
13177 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13178 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13179 if (!SWIG_IsOK(ecode2)) {
13180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13181 }
13182 arg2 = static_cast< double >(val2);
13183 if (arg1) (arg1)->hue = arg2;
13184
13185 resultobj = SWIG_Py_Void();
13186 return resultobj;
13187 fail:
13188 return NULL;
13189 }
13190
13191
13192 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13193 PyObject *resultobj = 0;
13194 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13195 double result;
13196 void *argp1 = 0 ;
13197 int res1 = 0 ;
13198 PyObject *swig_obj[1] ;
13199
13200 if (!args) SWIG_fail;
13201 swig_obj[0] = args;
13202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13203 if (!SWIG_IsOK(res1)) {
13204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13205 }
13206 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13207 result = (double) ((arg1)->hue);
13208 resultobj = SWIG_From_double(static_cast< double >(result));
13209 return resultobj;
13210 fail:
13211 return NULL;
13212 }
13213
13214
13215 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13216 PyObject *resultobj = 0;
13217 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13218 double arg2 ;
13219 void *argp1 = 0 ;
13220 int res1 = 0 ;
13221 double val2 ;
13222 int ecode2 = 0 ;
13223 PyObject *swig_obj[2] ;
13224
13225 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13227 if (!SWIG_IsOK(res1)) {
13228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13229 }
13230 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13231 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13232 if (!SWIG_IsOK(ecode2)) {
13233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13234 }
13235 arg2 = static_cast< double >(val2);
13236 if (arg1) (arg1)->saturation = arg2;
13237
13238 resultobj = SWIG_Py_Void();
13239 return resultobj;
13240 fail:
13241 return NULL;
13242 }
13243
13244
13245 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13246 PyObject *resultobj = 0;
13247 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13248 double result;
13249 void *argp1 = 0 ;
13250 int res1 = 0 ;
13251 PyObject *swig_obj[1] ;
13252
13253 if (!args) SWIG_fail;
13254 swig_obj[0] = args;
13255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13258 }
13259 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13260 result = (double) ((arg1)->saturation);
13261 resultobj = SWIG_From_double(static_cast< double >(result));
13262 return resultobj;
13263 fail:
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13269 PyObject *resultobj = 0;
13270 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13271 double arg2 ;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 double val2 ;
13275 int ecode2 = 0 ;
13276 PyObject *swig_obj[2] ;
13277
13278 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13280 if (!SWIG_IsOK(res1)) {
13281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13282 }
13283 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13284 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13285 if (!SWIG_IsOK(ecode2)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13287 }
13288 arg2 = static_cast< double >(val2);
13289 if (arg1) (arg1)->value = arg2;
13290
13291 resultobj = SWIG_Py_Void();
13292 return resultobj;
13293 fail:
13294 return NULL;
13295 }
13296
13297
13298 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13299 PyObject *resultobj = 0;
13300 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13301 double result;
13302 void *argp1 = 0 ;
13303 int res1 = 0 ;
13304 PyObject *swig_obj[1] ;
13305
13306 if (!args) SWIG_fail;
13307 swig_obj[0] = args;
13308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13309 if (!SWIG_IsOK(res1)) {
13310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13311 }
13312 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13313 result = (double) ((arg1)->value);
13314 resultobj = SWIG_From_double(static_cast< double >(result));
13315 return resultobj;
13316 fail:
13317 return NULL;
13318 }
13319
13320
13321 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13322 PyObject *obj;
13323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13324 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13325 return SWIG_Py_Void();
13326 }
13327
13328 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13329 return SWIG_Python_InitShadowInstance(args);
13330 }
13331
13332 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13333 PyObject *resultobj = 0;
13334 wxString *arg1 = 0 ;
13335 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13336 int arg3 = (int) -1 ;
13337 wxImage *result = 0 ;
13338 bool temp1 = false ;
13339 long val2 ;
13340 int ecode2 = 0 ;
13341 int val3 ;
13342 int ecode3 = 0 ;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 PyObject * obj2 = 0 ;
13346 char * kwnames[] = {
13347 (char *) "name",(char *) "type",(char *) "index", NULL
13348 };
13349
13350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13351 {
13352 arg1 = wxString_in_helper(obj0);
13353 if (arg1 == NULL) SWIG_fail;
13354 temp1 = true;
13355 }
13356 if (obj1) {
13357 ecode2 = SWIG_AsVal_long(obj1, &val2);
13358 if (!SWIG_IsOK(ecode2)) {
13359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13360 }
13361 arg2 = static_cast< long >(val2);
13362 }
13363 if (obj2) {
13364 ecode3 = SWIG_AsVal_int(obj2, &val3);
13365 if (!SWIG_IsOK(ecode3)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13367 }
13368 arg3 = static_cast< int >(val3);
13369 }
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13373 wxPyEndAllowThreads(__tstate);
13374 if (PyErr_Occurred()) SWIG_fail;
13375 }
13376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13377 {
13378 if (temp1)
13379 delete arg1;
13380 }
13381 return resultobj;
13382 fail:
13383 {
13384 if (temp1)
13385 delete arg1;
13386 }
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13392 PyObject *resultobj = 0;
13393 wxImage *arg1 = (wxImage *) 0 ;
13394 void *argp1 = 0 ;
13395 int res1 = 0 ;
13396 PyObject *swig_obj[1] ;
13397
13398 if (!args) SWIG_fail;
13399 swig_obj[0] = args;
13400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13403 }
13404 arg1 = reinterpret_cast< wxImage * >(argp1);
13405 {
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 delete arg1;
13408
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 resultobj = SWIG_Py_Void();
13413 return resultobj;
13414 fail:
13415 return NULL;
13416 }
13417
13418
13419 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13420 PyObject *resultobj = 0;
13421 wxString *arg1 = 0 ;
13422 wxString *arg2 = 0 ;
13423 int arg3 = (int) -1 ;
13424 wxImage *result = 0 ;
13425 bool temp1 = false ;
13426 bool temp2 = false ;
13427 int val3 ;
13428 int ecode3 = 0 ;
13429 PyObject * obj0 = 0 ;
13430 PyObject * obj1 = 0 ;
13431 PyObject * obj2 = 0 ;
13432 char * kwnames[] = {
13433 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13434 };
13435
13436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13437 {
13438 arg1 = wxString_in_helper(obj0);
13439 if (arg1 == NULL) SWIG_fail;
13440 temp1 = true;
13441 }
13442 {
13443 arg2 = wxString_in_helper(obj1);
13444 if (arg2 == NULL) SWIG_fail;
13445 temp2 = true;
13446 }
13447 if (obj2) {
13448 ecode3 = SWIG_AsVal_int(obj2, &val3);
13449 if (!SWIG_IsOK(ecode3)) {
13450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13451 }
13452 arg3 = static_cast< int >(val3);
13453 }
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13461 {
13462 if (temp1)
13463 delete arg1;
13464 }
13465 {
13466 if (temp2)
13467 delete arg2;
13468 }
13469 return resultobj;
13470 fail:
13471 {
13472 if (temp1)
13473 delete arg1;
13474 }
13475 {
13476 if (temp2)
13477 delete arg2;
13478 }
13479 return NULL;
13480 }
13481
13482
13483 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13484 PyObject *resultobj = 0;
13485 wxInputStream *arg1 = 0 ;
13486 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13487 int arg3 = (int) -1 ;
13488 wxImage *result = 0 ;
13489 wxPyInputStream *temp1 ;
13490 bool created1 ;
13491 long val2 ;
13492 int ecode2 = 0 ;
13493 int val3 ;
13494 int ecode3 = 0 ;
13495 PyObject * obj0 = 0 ;
13496 PyObject * obj1 = 0 ;
13497 PyObject * obj2 = 0 ;
13498 char * kwnames[] = {
13499 (char *) "stream",(char *) "type",(char *) "index", NULL
13500 };
13501
13502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13503 {
13504 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13505 arg1 = temp1->m_wxis;
13506 created1 = false;
13507 } else {
13508 PyErr_Clear(); // clear the failure of the wxPyConvert above
13509 arg1 = wxPyCBInputStream_create(obj0, false);
13510 if (arg1 == NULL) {
13511 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13512 SWIG_fail;
13513 }
13514 created1 = true;
13515 }
13516 }
13517 if (obj1) {
13518 ecode2 = SWIG_AsVal_long(obj1, &val2);
13519 if (!SWIG_IsOK(ecode2)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13521 }
13522 arg2 = static_cast< long >(val2);
13523 }
13524 if (obj2) {
13525 ecode3 = SWIG_AsVal_int(obj2, &val3);
13526 if (!SWIG_IsOK(ecode3)) {
13527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13528 }
13529 arg3 = static_cast< int >(val3);
13530 }
13531 {
13532 PyThreadState* __tstate = wxPyBeginAllowThreads();
13533 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13534 wxPyEndAllowThreads(__tstate);
13535 if (PyErr_Occurred()) SWIG_fail;
13536 }
13537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13538 {
13539 if (created1) delete arg1;
13540 }
13541 return resultobj;
13542 fail:
13543 {
13544 if (created1) delete arg1;
13545 }
13546 return NULL;
13547 }
13548
13549
13550 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13551 PyObject *resultobj = 0;
13552 wxInputStream *arg1 = 0 ;
13553 wxString *arg2 = 0 ;
13554 int arg3 = (int) -1 ;
13555 wxImage *result = 0 ;
13556 wxPyInputStream *temp1 ;
13557 bool created1 ;
13558 bool temp2 = false ;
13559 int val3 ;
13560 int ecode3 = 0 ;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 PyObject * obj2 = 0 ;
13564 char * kwnames[] = {
13565 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13566 };
13567
13568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13569 {
13570 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13571 arg1 = temp1->m_wxis;
13572 created1 = false;
13573 } else {
13574 PyErr_Clear(); // clear the failure of the wxPyConvert above
13575 arg1 = wxPyCBInputStream_create(obj0, false);
13576 if (arg1 == NULL) {
13577 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13578 SWIG_fail;
13579 }
13580 created1 = true;
13581 }
13582 }
13583 {
13584 arg2 = wxString_in_helper(obj1);
13585 if (arg2 == NULL) SWIG_fail;
13586 temp2 = true;
13587 }
13588 if (obj2) {
13589 ecode3 = SWIG_AsVal_int(obj2, &val3);
13590 if (!SWIG_IsOK(ecode3)) {
13591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13592 }
13593 arg3 = static_cast< int >(val3);
13594 }
13595 {
13596 PyThreadState* __tstate = wxPyBeginAllowThreads();
13597 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13602 {
13603 if (created1) delete arg1;
13604 }
13605 {
13606 if (temp2)
13607 delete arg2;
13608 }
13609 return resultobj;
13610 fail:
13611 {
13612 if (created1) delete arg1;
13613 }
13614 {
13615 if (temp2)
13616 delete arg2;
13617 }
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13623 PyObject *resultobj = 0;
13624 int arg1 = (int) 0 ;
13625 int arg2 = (int) 0 ;
13626 bool arg3 = (bool) true ;
13627 wxImage *result = 0 ;
13628 int val1 ;
13629 int ecode1 = 0 ;
13630 int val2 ;
13631 int ecode2 = 0 ;
13632 bool val3 ;
13633 int ecode3 = 0 ;
13634 PyObject * obj0 = 0 ;
13635 PyObject * obj1 = 0 ;
13636 PyObject * obj2 = 0 ;
13637 char * kwnames[] = {
13638 (char *) "width",(char *) "height",(char *) "clear", NULL
13639 };
13640
13641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13642 if (obj0) {
13643 ecode1 = SWIG_AsVal_int(obj0, &val1);
13644 if (!SWIG_IsOK(ecode1)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13646 }
13647 arg1 = static_cast< int >(val1);
13648 }
13649 if (obj1) {
13650 ecode2 = SWIG_AsVal_int(obj1, &val2);
13651 if (!SWIG_IsOK(ecode2)) {
13652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13653 }
13654 arg2 = static_cast< int >(val2);
13655 }
13656 if (obj2) {
13657 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13658 if (!SWIG_IsOK(ecode3)) {
13659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13660 }
13661 arg3 = static_cast< bool >(val3);
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13670 return resultobj;
13671 fail:
13672 return NULL;
13673 }
13674
13675
13676 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13677 PyObject *resultobj = 0;
13678 wxBitmap *arg1 = 0 ;
13679 wxImage *result = 0 ;
13680 void *argp1 = 0 ;
13681 int res1 = 0 ;
13682 PyObject * obj0 = 0 ;
13683 char * kwnames[] = {
13684 (char *) "bitmap", NULL
13685 };
13686
13687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13688 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13689 if (!SWIG_IsOK(res1)) {
13690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13691 }
13692 if (!argp1) {
13693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13694 }
13695 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13696 {
13697 if (!wxPyCheckForApp()) SWIG_fail;
13698 PyThreadState* __tstate = wxPyBeginAllowThreads();
13699 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13700 wxPyEndAllowThreads(__tstate);
13701 if (PyErr_Occurred()) SWIG_fail;
13702 }
13703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13704 return resultobj;
13705 fail:
13706 return NULL;
13707 }
13708
13709
13710 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13711 PyObject *resultobj = 0;
13712 int arg1 ;
13713 int arg2 ;
13714 buffer arg3 ;
13715 int arg4 ;
13716 wxImage *result = 0 ;
13717 int val1 ;
13718 int ecode1 = 0 ;
13719 int val2 ;
13720 int ecode2 = 0 ;
13721 Py_ssize_t temp3 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "width",(char *) "height",(char *) "data", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13730 ecode1 = SWIG_AsVal_int(obj0, &val1);
13731 if (!SWIG_IsOK(ecode1)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13733 }
13734 arg1 = static_cast< int >(val1);
13735 ecode2 = SWIG_AsVal_int(obj1, &val2);
13736 if (!SWIG_IsOK(ecode2)) {
13737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13738 }
13739 arg2 = static_cast< int >(val2);
13740 {
13741 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13742 arg4 = (int)temp3;
13743 }
13744 {
13745 PyThreadState* __tstate = wxPyBeginAllowThreads();
13746 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13747 wxPyEndAllowThreads(__tstate);
13748 if (PyErr_Occurred()) SWIG_fail;
13749 }
13750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj = 0;
13759 int arg1 ;
13760 int arg2 ;
13761 buffer arg3 ;
13762 int arg4 ;
13763 buffer arg5 ;
13764 int arg6 ;
13765 wxImage *result = 0 ;
13766 int val1 ;
13767 int ecode1 = 0 ;
13768 int val2 ;
13769 int ecode2 = 0 ;
13770 Py_ssize_t temp3 ;
13771 Py_ssize_t temp5 ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 PyObject * obj3 = 0 ;
13776 char * kwnames[] = {
13777 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13778 };
13779
13780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13781 ecode1 = SWIG_AsVal_int(obj0, &val1);
13782 if (!SWIG_IsOK(ecode1)) {
13783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13784 }
13785 arg1 = static_cast< int >(val1);
13786 ecode2 = SWIG_AsVal_int(obj1, &val2);
13787 if (!SWIG_IsOK(ecode2)) {
13788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13789 }
13790 arg2 = static_cast< int >(val2);
13791 {
13792 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13793 arg4 = (int)temp3;
13794 }
13795 {
13796 if (obj3 != Py_None) {
13797 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13798 arg6 = (int)temp5;
13799 }
13800 }
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13804 wxPyEndAllowThreads(__tstate);
13805 if (PyErr_Occurred()) SWIG_fail;
13806 }
13807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13808 return resultobj;
13809 fail:
13810 return NULL;
13811 }
13812
13813
13814 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13815 PyObject *resultobj = 0;
13816 wxImage *arg1 = (wxImage *) 0 ;
13817 int arg2 ;
13818 int arg3 ;
13819 bool arg4 = (bool) true ;
13820 void *argp1 = 0 ;
13821 int res1 = 0 ;
13822 int val2 ;
13823 int ecode2 = 0 ;
13824 int val3 ;
13825 int ecode3 = 0 ;
13826 bool val4 ;
13827 int ecode4 = 0 ;
13828 PyObject * obj0 = 0 ;
13829 PyObject * obj1 = 0 ;
13830 PyObject * obj2 = 0 ;
13831 PyObject * obj3 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13838 if (!SWIG_IsOK(res1)) {
13839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13840 }
13841 arg1 = reinterpret_cast< wxImage * >(argp1);
13842 ecode2 = SWIG_AsVal_int(obj1, &val2);
13843 if (!SWIG_IsOK(ecode2)) {
13844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13845 }
13846 arg2 = static_cast< int >(val2);
13847 ecode3 = SWIG_AsVal_int(obj2, &val3);
13848 if (!SWIG_IsOK(ecode3)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13850 }
13851 arg3 = static_cast< int >(val3);
13852 if (obj3) {
13853 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13854 if (!SWIG_IsOK(ecode4)) {
13855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13856 }
13857 arg4 = static_cast< bool >(val4);
13858 }
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 (arg1)->Create(arg2,arg3,arg4);
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 resultobj = SWIG_Py_Void();
13866 return resultobj;
13867 fail:
13868 return NULL;
13869 }
13870
13871
13872 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13873 PyObject *resultobj = 0;
13874 wxImage *arg1 = (wxImage *) 0 ;
13875 void *argp1 = 0 ;
13876 int res1 = 0 ;
13877 PyObject *swig_obj[1] ;
13878
13879 if (!args) SWIG_fail;
13880 swig_obj[0] = args;
13881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13882 if (!SWIG_IsOK(res1)) {
13883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13884 }
13885 arg1 = reinterpret_cast< wxImage * >(argp1);
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 (arg1)->Destroy();
13889 wxPyEndAllowThreads(__tstate);
13890 if (PyErr_Occurred()) SWIG_fail;
13891 }
13892 resultobj = SWIG_Py_Void();
13893 return resultobj;
13894 fail:
13895 return NULL;
13896 }
13897
13898
13899 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13900 PyObject *resultobj = 0;
13901 wxImage *arg1 = (wxImage *) 0 ;
13902 int arg2 ;
13903 int arg3 ;
13904 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13905 SwigValueWrapper<wxImage > result;
13906 void *argp1 = 0 ;
13907 int res1 = 0 ;
13908 int val2 ;
13909 int ecode2 = 0 ;
13910 int val3 ;
13911 int ecode3 = 0 ;
13912 int val4 ;
13913 int ecode4 = 0 ;
13914 PyObject * obj0 = 0 ;
13915 PyObject * obj1 = 0 ;
13916 PyObject * obj2 = 0 ;
13917 PyObject * obj3 = 0 ;
13918 char * kwnames[] = {
13919 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13920 };
13921
13922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13924 if (!SWIG_IsOK(res1)) {
13925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13926 }
13927 arg1 = reinterpret_cast< wxImage * >(argp1);
13928 ecode2 = SWIG_AsVal_int(obj1, &val2);
13929 if (!SWIG_IsOK(ecode2)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13931 }
13932 arg2 = static_cast< int >(val2);
13933 ecode3 = SWIG_AsVal_int(obj2, &val3);
13934 if (!SWIG_IsOK(ecode3)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13936 }
13937 arg3 = static_cast< int >(val3);
13938 if (obj3) {
13939 ecode4 = SWIG_AsVal_int(obj3, &val4);
13940 if (!SWIG_IsOK(ecode4)) {
13941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13942 }
13943 arg4 = static_cast< int >(val4);
13944 }
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (arg1)->Scale(arg2,arg3,arg4);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj = 0;
13960 wxImage *arg1 = (wxImage *) 0 ;
13961 int arg2 ;
13962 int arg3 ;
13963 SwigValueWrapper<wxImage > result;
13964 void *argp1 = 0 ;
13965 int res1 = 0 ;
13966 int val2 ;
13967 int ecode2 = 0 ;
13968 int val3 ;
13969 int ecode3 = 0 ;
13970 PyObject * obj0 = 0 ;
13971 PyObject * obj1 = 0 ;
13972 PyObject * obj2 = 0 ;
13973 char * kwnames[] = {
13974 (char *) "self",(char *) "width",(char *) "height", NULL
13975 };
13976
13977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13979 if (!SWIG_IsOK(res1)) {
13980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13981 }
13982 arg1 = reinterpret_cast< wxImage * >(argp1);
13983 ecode2 = SWIG_AsVal_int(obj1, &val2);
13984 if (!SWIG_IsOK(ecode2)) {
13985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13986 }
13987 arg2 = static_cast< int >(val2);
13988 ecode3 = SWIG_AsVal_int(obj2, &val3);
13989 if (!SWIG_IsOK(ecode3)) {
13990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13991 }
13992 arg3 = static_cast< int >(val3);
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14000 return resultobj;
14001 fail:
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14007 PyObject *resultobj = 0;
14008 wxImage *arg1 = (wxImage *) 0 ;
14009 int arg2 ;
14010 int arg3 ;
14011 SwigValueWrapper<wxImage > result;
14012 void *argp1 = 0 ;
14013 int res1 = 0 ;
14014 int val2 ;
14015 int ecode2 = 0 ;
14016 int val3 ;
14017 int ecode3 = 0 ;
14018 PyObject * obj0 = 0 ;
14019 PyObject * obj1 = 0 ;
14020 PyObject * obj2 = 0 ;
14021 char * kwnames[] = {
14022 (char *) "self",(char *) "width",(char *) "height", NULL
14023 };
14024
14025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14027 if (!SWIG_IsOK(res1)) {
14028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14029 }
14030 arg1 = reinterpret_cast< wxImage * >(argp1);
14031 ecode2 = SWIG_AsVal_int(obj1, &val2);
14032 if (!SWIG_IsOK(ecode2)) {
14033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14034 }
14035 arg2 = static_cast< int >(val2);
14036 ecode3 = SWIG_AsVal_int(obj2, &val3);
14037 if (!SWIG_IsOK(ecode3)) {
14038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14039 }
14040 arg3 = static_cast< int >(val3);
14041 {
14042 PyThreadState* __tstate = wxPyBeginAllowThreads();
14043 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14048 return resultobj;
14049 fail:
14050 return NULL;
14051 }
14052
14053
14054 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14055 PyObject *resultobj = 0;
14056 wxImage *arg1 = (wxImage *) 0 ;
14057 int arg2 ;
14058 SwigValueWrapper<wxImage > result;
14059 void *argp1 = 0 ;
14060 int res1 = 0 ;
14061 int val2 ;
14062 int ecode2 = 0 ;
14063 PyObject * obj0 = 0 ;
14064 PyObject * obj1 = 0 ;
14065 char * kwnames[] = {
14066 (char *) "self",(char *) "radius", NULL
14067 };
14068
14069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14071 if (!SWIG_IsOK(res1)) {
14072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14073 }
14074 arg1 = reinterpret_cast< wxImage * >(argp1);
14075 ecode2 = SWIG_AsVal_int(obj1, &val2);
14076 if (!SWIG_IsOK(ecode2)) {
14077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14078 }
14079 arg2 = static_cast< int >(val2);
14080 {
14081 PyThreadState* __tstate = wxPyBeginAllowThreads();
14082 result = (arg1)->Blur(arg2);
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj = 0;
14095 wxImage *arg1 = (wxImage *) 0 ;
14096 int arg2 ;
14097 SwigValueWrapper<wxImage > result;
14098 void *argp1 = 0 ;
14099 int res1 = 0 ;
14100 int val2 ;
14101 int ecode2 = 0 ;
14102 PyObject * obj0 = 0 ;
14103 PyObject * obj1 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "radius", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14112 }
14113 arg1 = reinterpret_cast< wxImage * >(argp1);
14114 ecode2 = SWIG_AsVal_int(obj1, &val2);
14115 if (!SWIG_IsOK(ecode2)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14117 }
14118 arg2 = static_cast< int >(val2);
14119 {
14120 PyThreadState* __tstate = wxPyBeginAllowThreads();
14121 result = (arg1)->BlurHorizontal(arg2);
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj = 0;
14134 wxImage *arg1 = (wxImage *) 0 ;
14135 int arg2 ;
14136 SwigValueWrapper<wxImage > result;
14137 void *argp1 = 0 ;
14138 int res1 = 0 ;
14139 int val2 ;
14140 int ecode2 = 0 ;
14141 PyObject * obj0 = 0 ;
14142 PyObject * obj1 = 0 ;
14143 char * kwnames[] = {
14144 (char *) "self",(char *) "radius", NULL
14145 };
14146
14147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14149 if (!SWIG_IsOK(res1)) {
14150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14151 }
14152 arg1 = reinterpret_cast< wxImage * >(argp1);
14153 ecode2 = SWIG_AsVal_int(obj1, &val2);
14154 if (!SWIG_IsOK(ecode2)) {
14155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14156 }
14157 arg2 = static_cast< int >(val2);
14158 {
14159 PyThreadState* __tstate = wxPyBeginAllowThreads();
14160 result = (arg1)->BlurVertical(arg2);
14161 wxPyEndAllowThreads(__tstate);
14162 if (PyErr_Occurred()) SWIG_fail;
14163 }
14164 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14165 return resultobj;
14166 fail:
14167 return NULL;
14168 }
14169
14170
14171 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj = 0;
14173 wxImage *arg1 = (wxImage *) 0 ;
14174 int arg2 ;
14175 int arg3 ;
14176 SwigValueWrapper<wxImage > result;
14177 void *argp1 = 0 ;
14178 int res1 = 0 ;
14179 int val2 ;
14180 int ecode2 = 0 ;
14181 int val3 ;
14182 int ecode3 = 0 ;
14183 PyObject * obj0 = 0 ;
14184 PyObject * obj1 = 0 ;
14185 PyObject * obj2 = 0 ;
14186 char * kwnames[] = {
14187 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14188 };
14189
14190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14192 if (!SWIG_IsOK(res1)) {
14193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14194 }
14195 arg1 = reinterpret_cast< wxImage * >(argp1);
14196 ecode2 = SWIG_AsVal_int(obj1, &val2);
14197 if (!SWIG_IsOK(ecode2)) {
14198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14199 }
14200 arg2 = static_cast< int >(val2);
14201 ecode3 = SWIG_AsVal_int(obj2, &val3);
14202 if (!SWIG_IsOK(ecode3)) {
14203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14204 }
14205 arg3 = static_cast< int >(val3);
14206 {
14207 PyThreadState* __tstate = wxPyBeginAllowThreads();
14208 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14213 return resultobj;
14214 fail:
14215 return NULL;
14216 }
14217
14218
14219 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14220 PyObject *resultobj = 0;
14221 wxImage *arg1 = (wxImage *) 0 ;
14222 int arg2 ;
14223 int arg3 ;
14224 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14225 wxImage *result = 0 ;
14226 void *argp1 = 0 ;
14227 int res1 = 0 ;
14228 int val2 ;
14229 int ecode2 = 0 ;
14230 int val3 ;
14231 int ecode3 = 0 ;
14232 int val4 ;
14233 int ecode4 = 0 ;
14234 PyObject * obj0 = 0 ;
14235 PyObject * obj1 = 0 ;
14236 PyObject * obj2 = 0 ;
14237 PyObject * obj3 = 0 ;
14238 char * kwnames[] = {
14239 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14240 };
14241
14242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14244 if (!SWIG_IsOK(res1)) {
14245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14246 }
14247 arg1 = reinterpret_cast< wxImage * >(argp1);
14248 ecode2 = SWIG_AsVal_int(obj1, &val2);
14249 if (!SWIG_IsOK(ecode2)) {
14250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14251 }
14252 arg2 = static_cast< int >(val2);
14253 ecode3 = SWIG_AsVal_int(obj2, &val3);
14254 if (!SWIG_IsOK(ecode3)) {
14255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14256 }
14257 arg3 = static_cast< int >(val3);
14258 if (obj3) {
14259 ecode4 = SWIG_AsVal_int(obj3, &val4);
14260 if (!SWIG_IsOK(ecode4)) {
14261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14262 }
14263 arg4 = static_cast< int >(val4);
14264 }
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 {
14268 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14269 result = (wxImage *) &_result_ref;
14270 }
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj = 0;
14283 wxImage *arg1 = (wxImage *) 0 ;
14284 wxSize *arg2 = 0 ;
14285 wxPoint *arg3 = 0 ;
14286 int arg4 = (int) -1 ;
14287 int arg5 = (int) -1 ;
14288 int arg6 = (int) -1 ;
14289 wxImage *result = 0 ;
14290 void *argp1 = 0 ;
14291 int res1 = 0 ;
14292 wxSize temp2 ;
14293 wxPoint temp3 ;
14294 int val4 ;
14295 int ecode4 = 0 ;
14296 int val5 ;
14297 int ecode5 = 0 ;
14298 int val6 ;
14299 int ecode6 = 0 ;
14300 PyObject * obj0 = 0 ;
14301 PyObject * obj1 = 0 ;
14302 PyObject * obj2 = 0 ;
14303 PyObject * obj3 = 0 ;
14304 PyObject * obj4 = 0 ;
14305 PyObject * obj5 = 0 ;
14306 char * kwnames[] = {
14307 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14308 };
14309
14310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14312 if (!SWIG_IsOK(res1)) {
14313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14314 }
14315 arg1 = reinterpret_cast< wxImage * >(argp1);
14316 {
14317 arg2 = &temp2;
14318 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14319 }
14320 {
14321 arg3 = &temp3;
14322 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14323 }
14324 if (obj3) {
14325 ecode4 = SWIG_AsVal_int(obj3, &val4);
14326 if (!SWIG_IsOK(ecode4)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14328 }
14329 arg4 = static_cast< int >(val4);
14330 }
14331 if (obj4) {
14332 ecode5 = SWIG_AsVal_int(obj4, &val5);
14333 if (!SWIG_IsOK(ecode5)) {
14334 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14335 }
14336 arg5 = static_cast< int >(val5);
14337 }
14338 if (obj5) {
14339 ecode6 = SWIG_AsVal_int(obj5, &val6);
14340 if (!SWIG_IsOK(ecode6)) {
14341 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14342 }
14343 arg6 = static_cast< int >(val6);
14344 }
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 {
14348 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14349 result = (wxImage *) &_result_ref;
14350 }
14351 wxPyEndAllowThreads(__tstate);
14352 if (PyErr_Occurred()) SWIG_fail;
14353 }
14354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14355 return resultobj;
14356 fail:
14357 return NULL;
14358 }
14359
14360
14361 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14362 PyObject *resultobj = 0;
14363 wxImage *arg1 = (wxImage *) 0 ;
14364 int arg2 ;
14365 int arg3 ;
14366 byte arg4 ;
14367 byte arg5 ;
14368 byte arg6 ;
14369 void *argp1 = 0 ;
14370 int res1 = 0 ;
14371 int val2 ;
14372 int ecode2 = 0 ;
14373 int val3 ;
14374 int ecode3 = 0 ;
14375 unsigned char val4 ;
14376 int ecode4 = 0 ;
14377 unsigned char val5 ;
14378 int ecode5 = 0 ;
14379 unsigned char val6 ;
14380 int ecode6 = 0 ;
14381 PyObject * obj0 = 0 ;
14382 PyObject * obj1 = 0 ;
14383 PyObject * obj2 = 0 ;
14384 PyObject * obj3 = 0 ;
14385 PyObject * obj4 = 0 ;
14386 PyObject * obj5 = 0 ;
14387 char * kwnames[] = {
14388 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14389 };
14390
14391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14393 if (!SWIG_IsOK(res1)) {
14394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14395 }
14396 arg1 = reinterpret_cast< wxImage * >(argp1);
14397 ecode2 = SWIG_AsVal_int(obj1, &val2);
14398 if (!SWIG_IsOK(ecode2)) {
14399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14400 }
14401 arg2 = static_cast< int >(val2);
14402 ecode3 = SWIG_AsVal_int(obj2, &val3);
14403 if (!SWIG_IsOK(ecode3)) {
14404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14405 }
14406 arg3 = static_cast< int >(val3);
14407 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14408 if (!SWIG_IsOK(ecode4)) {
14409 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14410 }
14411 arg4 = static_cast< byte >(val4);
14412 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14413 if (!SWIG_IsOK(ecode5)) {
14414 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14415 }
14416 arg5 = static_cast< byte >(val5);
14417 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14418 if (!SWIG_IsOK(ecode6)) {
14419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14420 }
14421 arg6 = static_cast< byte >(val6);
14422 {
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 resultobj = SWIG_Py_Void();
14429 return resultobj;
14430 fail:
14431 return NULL;
14432 }
14433
14434
14435 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj = 0;
14437 wxImage *arg1 = (wxImage *) 0 ;
14438 wxRect *arg2 = 0 ;
14439 byte arg3 ;
14440 byte arg4 ;
14441 byte arg5 ;
14442 void *argp1 = 0 ;
14443 int res1 = 0 ;
14444 wxRect temp2 ;
14445 unsigned char val3 ;
14446 int ecode3 = 0 ;
14447 unsigned char val4 ;
14448 int ecode4 = 0 ;
14449 unsigned char val5 ;
14450 int ecode5 = 0 ;
14451 PyObject * obj0 = 0 ;
14452 PyObject * obj1 = 0 ;
14453 PyObject * obj2 = 0 ;
14454 PyObject * obj3 = 0 ;
14455 PyObject * obj4 = 0 ;
14456 char * kwnames[] = {
14457 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14458 };
14459
14460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14462 if (!SWIG_IsOK(res1)) {
14463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14464 }
14465 arg1 = reinterpret_cast< wxImage * >(argp1);
14466 {
14467 arg2 = &temp2;
14468 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14469 }
14470 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14471 if (!SWIG_IsOK(ecode3)) {
14472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14473 }
14474 arg3 = static_cast< byte >(val3);
14475 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14476 if (!SWIG_IsOK(ecode4)) {
14477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14478 }
14479 arg4 = static_cast< byte >(val4);
14480 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14481 if (!SWIG_IsOK(ecode5)) {
14482 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14483 }
14484 arg5 = static_cast< byte >(val5);
14485 {
14486 PyThreadState* __tstate = wxPyBeginAllowThreads();
14487 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14488 wxPyEndAllowThreads(__tstate);
14489 if (PyErr_Occurred()) SWIG_fail;
14490 }
14491 resultobj = SWIG_Py_Void();
14492 return resultobj;
14493 fail:
14494 return NULL;
14495 }
14496
14497
14498 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14499 PyObject *resultobj = 0;
14500 wxImage *arg1 = (wxImage *) 0 ;
14501 int arg2 ;
14502 int arg3 ;
14503 byte result;
14504 void *argp1 = 0 ;
14505 int res1 = 0 ;
14506 int val2 ;
14507 int ecode2 = 0 ;
14508 int val3 ;
14509 int ecode3 = 0 ;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 PyObject * obj2 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "self",(char *) "x",(char *) "y", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14519 if (!SWIG_IsOK(res1)) {
14520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14521 }
14522 arg1 = reinterpret_cast< wxImage * >(argp1);
14523 ecode2 = SWIG_AsVal_int(obj1, &val2);
14524 if (!SWIG_IsOK(ecode2)) {
14525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14526 }
14527 arg2 = static_cast< int >(val2);
14528 ecode3 = SWIG_AsVal_int(obj2, &val3);
14529 if (!SWIG_IsOK(ecode3)) {
14530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14531 }
14532 arg3 = static_cast< int >(val3);
14533 {
14534 PyThreadState* __tstate = wxPyBeginAllowThreads();
14535 result = (byte)(arg1)->GetRed(arg2,arg3);
14536 wxPyEndAllowThreads(__tstate);
14537 if (PyErr_Occurred()) SWIG_fail;
14538 }
14539 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14540 return resultobj;
14541 fail:
14542 return NULL;
14543 }
14544
14545
14546 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj = 0;
14548 wxImage *arg1 = (wxImage *) 0 ;
14549 int arg2 ;
14550 int arg3 ;
14551 byte result;
14552 void *argp1 = 0 ;
14553 int res1 = 0 ;
14554 int val2 ;
14555 int ecode2 = 0 ;
14556 int val3 ;
14557 int ecode3 = 0 ;
14558 PyObject * obj0 = 0 ;
14559 PyObject * obj1 = 0 ;
14560 PyObject * obj2 = 0 ;
14561 char * kwnames[] = {
14562 (char *) "self",(char *) "x",(char *) "y", NULL
14563 };
14564
14565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14567 if (!SWIG_IsOK(res1)) {
14568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14569 }
14570 arg1 = reinterpret_cast< wxImage * >(argp1);
14571 ecode2 = SWIG_AsVal_int(obj1, &val2);
14572 if (!SWIG_IsOK(ecode2)) {
14573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14574 }
14575 arg2 = static_cast< int >(val2);
14576 ecode3 = SWIG_AsVal_int(obj2, &val3);
14577 if (!SWIG_IsOK(ecode3)) {
14578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14579 }
14580 arg3 = static_cast< int >(val3);
14581 {
14582 PyThreadState* __tstate = wxPyBeginAllowThreads();
14583 result = (byte)(arg1)->GetGreen(arg2,arg3);
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14588 return resultobj;
14589 fail:
14590 return NULL;
14591 }
14592
14593
14594 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14595 PyObject *resultobj = 0;
14596 wxImage *arg1 = (wxImage *) 0 ;
14597 int arg2 ;
14598 int arg3 ;
14599 byte result;
14600 void *argp1 = 0 ;
14601 int res1 = 0 ;
14602 int val2 ;
14603 int ecode2 = 0 ;
14604 int val3 ;
14605 int ecode3 = 0 ;
14606 PyObject * obj0 = 0 ;
14607 PyObject * obj1 = 0 ;
14608 PyObject * obj2 = 0 ;
14609 char * kwnames[] = {
14610 (char *) "self",(char *) "x",(char *) "y", NULL
14611 };
14612
14613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14615 if (!SWIG_IsOK(res1)) {
14616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14617 }
14618 arg1 = reinterpret_cast< wxImage * >(argp1);
14619 ecode2 = SWIG_AsVal_int(obj1, &val2);
14620 if (!SWIG_IsOK(ecode2)) {
14621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14622 }
14623 arg2 = static_cast< int >(val2);
14624 ecode3 = SWIG_AsVal_int(obj2, &val3);
14625 if (!SWIG_IsOK(ecode3)) {
14626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14627 }
14628 arg3 = static_cast< int >(val3);
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (byte)(arg1)->GetBlue(arg2,arg3);
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14643 PyObject *resultobj = 0;
14644 wxImage *arg1 = (wxImage *) 0 ;
14645 int arg2 ;
14646 int arg3 ;
14647 byte arg4 ;
14648 void *argp1 = 0 ;
14649 int res1 = 0 ;
14650 int val2 ;
14651 int ecode2 = 0 ;
14652 int val3 ;
14653 int ecode3 = 0 ;
14654 unsigned char val4 ;
14655 int ecode4 = 0 ;
14656 PyObject * obj0 = 0 ;
14657 PyObject * obj1 = 0 ;
14658 PyObject * obj2 = 0 ;
14659 PyObject * obj3 = 0 ;
14660 char * kwnames[] = {
14661 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14662 };
14663
14664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14666 if (!SWIG_IsOK(res1)) {
14667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14668 }
14669 arg1 = reinterpret_cast< wxImage * >(argp1);
14670 ecode2 = SWIG_AsVal_int(obj1, &val2);
14671 if (!SWIG_IsOK(ecode2)) {
14672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14673 }
14674 arg2 = static_cast< int >(val2);
14675 ecode3 = SWIG_AsVal_int(obj2, &val3);
14676 if (!SWIG_IsOK(ecode3)) {
14677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14678 }
14679 arg3 = static_cast< int >(val3);
14680 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14681 if (!SWIG_IsOK(ecode4)) {
14682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14683 }
14684 arg4 = static_cast< byte >(val4);
14685 {
14686 PyThreadState* __tstate = wxPyBeginAllowThreads();
14687 (arg1)->SetAlpha(arg2,arg3,arg4);
14688 wxPyEndAllowThreads(__tstate);
14689 if (PyErr_Occurred()) SWIG_fail;
14690 }
14691 resultobj = SWIG_Py_Void();
14692 return resultobj;
14693 fail:
14694 return NULL;
14695 }
14696
14697
14698 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj = 0;
14700 wxImage *arg1 = (wxImage *) 0 ;
14701 int arg2 ;
14702 int arg3 ;
14703 byte result;
14704 void *argp1 = 0 ;
14705 int res1 = 0 ;
14706 int val2 ;
14707 int ecode2 = 0 ;
14708 int val3 ;
14709 int ecode3 = 0 ;
14710 PyObject * obj0 = 0 ;
14711 PyObject * obj1 = 0 ;
14712 PyObject * obj2 = 0 ;
14713 char * kwnames[] = {
14714 (char *) "self",(char *) "x",(char *) "y", NULL
14715 };
14716
14717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14719 if (!SWIG_IsOK(res1)) {
14720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14721 }
14722 arg1 = reinterpret_cast< wxImage * >(argp1);
14723 ecode2 = SWIG_AsVal_int(obj1, &val2);
14724 if (!SWIG_IsOK(ecode2)) {
14725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14726 }
14727 arg2 = static_cast< int >(val2);
14728 ecode3 = SWIG_AsVal_int(obj2, &val3);
14729 if (!SWIG_IsOK(ecode3)) {
14730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14731 }
14732 arg3 = static_cast< int >(val3);
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14747 PyObject *resultobj = 0;
14748 wxImage *arg1 = (wxImage *) 0 ;
14749 bool result;
14750 void *argp1 = 0 ;
14751 int res1 = 0 ;
14752 PyObject *swig_obj[1] ;
14753
14754 if (!args) SWIG_fail;
14755 swig_obj[0] = args;
14756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14757 if (!SWIG_IsOK(res1)) {
14758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14759 }
14760 arg1 = reinterpret_cast< wxImage * >(argp1);
14761 {
14762 PyThreadState* __tstate = wxPyBeginAllowThreads();
14763 result = (bool)(arg1)->HasAlpha();
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 {
14768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14769 }
14770 return resultobj;
14771 fail:
14772 return NULL;
14773 }
14774
14775
14776 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14777 PyObject *resultobj = 0;
14778 wxImage *arg1 = (wxImage *) 0 ;
14779 void *argp1 = 0 ;
14780 int res1 = 0 ;
14781 PyObject *swig_obj[1] ;
14782
14783 if (!args) SWIG_fail;
14784 swig_obj[0] = args;
14785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14786 if (!SWIG_IsOK(res1)) {
14787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14788 }
14789 arg1 = reinterpret_cast< wxImage * >(argp1);
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 (arg1)->InitAlpha();
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 resultobj = SWIG_Py_Void();
14797 return resultobj;
14798 fail:
14799 return NULL;
14800 }
14801
14802
14803 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14804 PyObject *resultobj = 0;
14805 wxImage *arg1 = (wxImage *) 0 ;
14806 int arg2 ;
14807 int arg3 ;
14808 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14809 bool result;
14810 void *argp1 = 0 ;
14811 int res1 = 0 ;
14812 int val2 ;
14813 int ecode2 = 0 ;
14814 int val3 ;
14815 int ecode3 = 0 ;
14816 unsigned char val4 ;
14817 int ecode4 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 PyObject * obj3 = 0 ;
14822 char * kwnames[] = {
14823 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14824 };
14825
14826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14828 if (!SWIG_IsOK(res1)) {
14829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14830 }
14831 arg1 = reinterpret_cast< wxImage * >(argp1);
14832 ecode2 = SWIG_AsVal_int(obj1, &val2);
14833 if (!SWIG_IsOK(ecode2)) {
14834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14835 }
14836 arg2 = static_cast< int >(val2);
14837 ecode3 = SWIG_AsVal_int(obj2, &val3);
14838 if (!SWIG_IsOK(ecode3)) {
14839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14840 }
14841 arg3 = static_cast< int >(val3);
14842 if (obj3) {
14843 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14844 if (!SWIG_IsOK(ecode4)) {
14845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14846 }
14847 arg4 = static_cast< byte >(val4);
14848 }
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 {
14856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14857 }
14858 return resultobj;
14859 fail:
14860 return NULL;
14861 }
14862
14863
14864 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14865 PyObject *resultobj = 0;
14866 wxImage *arg1 = (wxImage *) 0 ;
14867 byte *arg2 = (byte *) 0 ;
14868 byte *arg3 = (byte *) 0 ;
14869 byte *arg4 = (byte *) 0 ;
14870 byte arg5 = (byte) 0 ;
14871 byte arg6 = (byte) 0 ;
14872 byte arg7 = (byte) 0 ;
14873 bool result;
14874 void *argp1 = 0 ;
14875 int res1 = 0 ;
14876 byte temp2 ;
14877 int res2 = SWIG_TMPOBJ ;
14878 byte temp3 ;
14879 int res3 = SWIG_TMPOBJ ;
14880 byte temp4 ;
14881 int res4 = SWIG_TMPOBJ ;
14882 unsigned char val5 ;
14883 int ecode5 = 0 ;
14884 unsigned char val6 ;
14885 int ecode6 = 0 ;
14886 unsigned char val7 ;
14887 int ecode7 = 0 ;
14888 PyObject * obj0 = 0 ;
14889 PyObject * obj1 = 0 ;
14890 PyObject * obj2 = 0 ;
14891 PyObject * obj3 = 0 ;
14892 char * kwnames[] = {
14893 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14894 };
14895
14896 arg2 = &temp2;
14897 arg3 = &temp3;
14898 arg4 = &temp4;
14899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14901 if (!SWIG_IsOK(res1)) {
14902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14903 }
14904 arg1 = reinterpret_cast< wxImage * >(argp1);
14905 if (obj1) {
14906 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14907 if (!SWIG_IsOK(ecode5)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14909 }
14910 arg5 = static_cast< byte >(val5);
14911 }
14912 if (obj2) {
14913 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14914 if (!SWIG_IsOK(ecode6)) {
14915 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14916 }
14917 arg6 = static_cast< byte >(val6);
14918 }
14919 if (obj3) {
14920 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14921 if (!SWIG_IsOK(ecode7)) {
14922 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14923 }
14924 arg7 = static_cast< byte >(val7);
14925 }
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 {
14933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14934 }
14935 if (SWIG_IsTmpObj(res2)) {
14936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14937 } else {
14938 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14940 }
14941 if (SWIG_IsTmpObj(res3)) {
14942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14943 } else {
14944 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14946 }
14947 if (SWIG_IsTmpObj(res4)) {
14948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14949 } else {
14950 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14952 }
14953 return resultobj;
14954 fail:
14955 return NULL;
14956 }
14957
14958
14959 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14960 PyObject *resultobj = 0;
14961 wxImage *arg1 = (wxImage *) 0 ;
14962 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14963 bool result;
14964 void *argp1 = 0 ;
14965 int res1 = 0 ;
14966 unsigned char val2 ;
14967 int ecode2 = 0 ;
14968 PyObject * obj0 = 0 ;
14969 PyObject * obj1 = 0 ;
14970 char * kwnames[] = {
14971 (char *) "self",(char *) "threshold", NULL
14972 };
14973
14974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14976 if (!SWIG_IsOK(res1)) {
14977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14978 }
14979 arg1 = reinterpret_cast< wxImage * >(argp1);
14980 if (obj1) {
14981 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14982 if (!SWIG_IsOK(ecode2)) {
14983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14984 }
14985 arg2 = static_cast< byte >(val2);
14986 }
14987 {
14988 PyThreadState* __tstate = wxPyBeginAllowThreads();
14989 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 {
14994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14995 }
14996 return resultobj;
14997 fail:
14998 return NULL;
14999 }
15000
15001
15002 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15003 PyObject *resultobj = 0;
15004 wxImage *arg1 = (wxImage *) 0 ;
15005 byte arg2 ;
15006 byte arg3 ;
15007 byte arg4 ;
15008 bool result;
15009 void *argp1 = 0 ;
15010 int res1 = 0 ;
15011 unsigned char val2 ;
15012 int ecode2 = 0 ;
15013 unsigned char val3 ;
15014 int ecode3 = 0 ;
15015 unsigned char val4 ;
15016 int ecode4 = 0 ;
15017 PyObject * obj0 = 0 ;
15018 PyObject * obj1 = 0 ;
15019 PyObject * obj2 = 0 ;
15020 PyObject * obj3 = 0 ;
15021 char * kwnames[] = {
15022 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15023 };
15024
15025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15027 if (!SWIG_IsOK(res1)) {
15028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15029 }
15030 arg1 = reinterpret_cast< wxImage * >(argp1);
15031 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15032 if (!SWIG_IsOK(ecode2)) {
15033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15034 }
15035 arg2 = static_cast< byte >(val2);
15036 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15037 if (!SWIG_IsOK(ecode3)) {
15038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15039 }
15040 arg3 = static_cast< byte >(val3);
15041 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15042 if (!SWIG_IsOK(ecode4)) {
15043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15044 }
15045 arg4 = static_cast< byte >(val4);
15046 {
15047 PyThreadState* __tstate = wxPyBeginAllowThreads();
15048 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15049 wxPyEndAllowThreads(__tstate);
15050 if (PyErr_Occurred()) SWIG_fail;
15051 }
15052 {
15053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15054 }
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj = 0;
15063 wxImage *arg1 = (wxImage *) 0 ;
15064 wxImage *arg2 = 0 ;
15065 byte arg3 ;
15066 byte arg4 ;
15067 byte arg5 ;
15068 bool result;
15069 void *argp1 = 0 ;
15070 int res1 = 0 ;
15071 void *argp2 = 0 ;
15072 int res2 = 0 ;
15073 unsigned char val3 ;
15074 int ecode3 = 0 ;
15075 unsigned char val4 ;
15076 int ecode4 = 0 ;
15077 unsigned char val5 ;
15078 int ecode5 = 0 ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 PyObject * obj2 = 0 ;
15082 PyObject * obj3 = 0 ;
15083 PyObject * obj4 = 0 ;
15084 char * kwnames[] = {
15085 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15086 };
15087
15088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15090 if (!SWIG_IsOK(res1)) {
15091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15092 }
15093 arg1 = reinterpret_cast< wxImage * >(argp1);
15094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15095 if (!SWIG_IsOK(res2)) {
15096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15097 }
15098 if (!argp2) {
15099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15100 }
15101 arg2 = reinterpret_cast< wxImage * >(argp2);
15102 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15103 if (!SWIG_IsOK(ecode3)) {
15104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15105 }
15106 arg3 = static_cast< byte >(val3);
15107 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15108 if (!SWIG_IsOK(ecode4)) {
15109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15110 }
15111 arg4 = static_cast< byte >(val4);
15112 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15113 if (!SWIG_IsOK(ecode5)) {
15114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15115 }
15116 arg5 = static_cast< byte >(val5);
15117 {
15118 PyThreadState* __tstate = wxPyBeginAllowThreads();
15119 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15120 wxPyEndAllowThreads(__tstate);
15121 if (PyErr_Occurred()) SWIG_fail;
15122 }
15123 {
15124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15125 }
15126 return resultobj;
15127 fail:
15128 return NULL;
15129 }
15130
15131
15132 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj = 0;
15134 wxString *arg1 = 0 ;
15135 bool result;
15136 bool temp1 = false ;
15137 PyObject * obj0 = 0 ;
15138 char * kwnames[] = {
15139 (char *) "filename", NULL
15140 };
15141
15142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15143 {
15144 arg1 = wxString_in_helper(obj0);
15145 if (arg1 == NULL) SWIG_fail;
15146 temp1 = true;
15147 }
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15151 wxPyEndAllowThreads(__tstate);
15152 if (PyErr_Occurred()) SWIG_fail;
15153 }
15154 {
15155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15156 }
15157 {
15158 if (temp1)
15159 delete arg1;
15160 }
15161 return resultobj;
15162 fail:
15163 {
15164 if (temp1)
15165 delete arg1;
15166 }
15167 return NULL;
15168 }
15169
15170
15171 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15172 PyObject *resultobj = 0;
15173 wxString *arg1 = 0 ;
15174 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15175 int result;
15176 bool temp1 = false ;
15177 long val2 ;
15178 int ecode2 = 0 ;
15179 PyObject * obj0 = 0 ;
15180 PyObject * obj1 = 0 ;
15181 char * kwnames[] = {
15182 (char *) "filename",(char *) "type", NULL
15183 };
15184
15185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15186 {
15187 arg1 = wxString_in_helper(obj0);
15188 if (arg1 == NULL) SWIG_fail;
15189 temp1 = true;
15190 }
15191 if (obj1) {
15192 ecode2 = SWIG_AsVal_long(obj1, &val2);
15193 if (!SWIG_IsOK(ecode2)) {
15194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15195 }
15196 arg2 = static_cast< long >(val2);
15197 }
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15201 wxPyEndAllowThreads(__tstate);
15202 if (PyErr_Occurred()) SWIG_fail;
15203 }
15204 resultobj = SWIG_From_int(static_cast< int >(result));
15205 {
15206 if (temp1)
15207 delete arg1;
15208 }
15209 return resultobj;
15210 fail:
15211 {
15212 if (temp1)
15213 delete arg1;
15214 }
15215 return NULL;
15216 }
15217
15218
15219 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj = 0;
15221 wxImage *arg1 = (wxImage *) 0 ;
15222 wxString *arg2 = 0 ;
15223 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15224 int arg4 = (int) -1 ;
15225 bool result;
15226 void *argp1 = 0 ;
15227 int res1 = 0 ;
15228 bool temp2 = false ;
15229 long val3 ;
15230 int ecode3 = 0 ;
15231 int val4 ;
15232 int ecode4 = 0 ;
15233 PyObject * obj0 = 0 ;
15234 PyObject * obj1 = 0 ;
15235 PyObject * obj2 = 0 ;
15236 PyObject * obj3 = 0 ;
15237 char * kwnames[] = {
15238 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15239 };
15240
15241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15243 if (!SWIG_IsOK(res1)) {
15244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15245 }
15246 arg1 = reinterpret_cast< wxImage * >(argp1);
15247 {
15248 arg2 = wxString_in_helper(obj1);
15249 if (arg2 == NULL) SWIG_fail;
15250 temp2 = true;
15251 }
15252 if (obj2) {
15253 ecode3 = SWIG_AsVal_long(obj2, &val3);
15254 if (!SWIG_IsOK(ecode3)) {
15255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15256 }
15257 arg3 = static_cast< long >(val3);
15258 }
15259 if (obj3) {
15260 ecode4 = SWIG_AsVal_int(obj3, &val4);
15261 if (!SWIG_IsOK(ecode4)) {
15262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15263 }
15264 arg4 = static_cast< int >(val4);
15265 }
15266 {
15267 PyThreadState* __tstate = wxPyBeginAllowThreads();
15268 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 {
15273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15274 }
15275 {
15276 if (temp2)
15277 delete arg2;
15278 }
15279 return resultobj;
15280 fail:
15281 {
15282 if (temp2)
15283 delete arg2;
15284 }
15285 return NULL;
15286 }
15287
15288
15289 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15290 PyObject *resultobj = 0;
15291 wxImage *arg1 = (wxImage *) 0 ;
15292 wxString *arg2 = 0 ;
15293 wxString *arg3 = 0 ;
15294 int arg4 = (int) -1 ;
15295 bool result;
15296 void *argp1 = 0 ;
15297 int res1 = 0 ;
15298 bool temp2 = false ;
15299 bool temp3 = false ;
15300 int val4 ;
15301 int ecode4 = 0 ;
15302 PyObject * obj0 = 0 ;
15303 PyObject * obj1 = 0 ;
15304 PyObject * obj2 = 0 ;
15305 PyObject * obj3 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage * >(argp1);
15316 {
15317 arg2 = wxString_in_helper(obj1);
15318 if (arg2 == NULL) SWIG_fail;
15319 temp2 = true;
15320 }
15321 {
15322 arg3 = wxString_in_helper(obj2);
15323 if (arg3 == NULL) SWIG_fail;
15324 temp3 = true;
15325 }
15326 if (obj3) {
15327 ecode4 = SWIG_AsVal_int(obj3, &val4);
15328 if (!SWIG_IsOK(ecode4)) {
15329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15330 }
15331 arg4 = static_cast< int >(val4);
15332 }
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15336 wxPyEndAllowThreads(__tstate);
15337 if (PyErr_Occurred()) SWIG_fail;
15338 }
15339 {
15340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15341 }
15342 {
15343 if (temp2)
15344 delete arg2;
15345 }
15346 {
15347 if (temp3)
15348 delete arg3;
15349 }
15350 return resultobj;
15351 fail:
15352 {
15353 if (temp2)
15354 delete arg2;
15355 }
15356 {
15357 if (temp3)
15358 delete arg3;
15359 }
15360 return NULL;
15361 }
15362
15363
15364 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15365 PyObject *resultobj = 0;
15366 wxImage *arg1 = (wxImage *) 0 ;
15367 wxString *arg2 = 0 ;
15368 int arg3 ;
15369 bool result;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 bool temp2 = false ;
15373 int val3 ;
15374 int ecode3 = 0 ;
15375 PyObject * obj0 = 0 ;
15376 PyObject * obj1 = 0 ;
15377 PyObject * obj2 = 0 ;
15378 char * kwnames[] = {
15379 (char *) "self",(char *) "name",(char *) "type", NULL
15380 };
15381
15382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15384 if (!SWIG_IsOK(res1)) {
15385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15386 }
15387 arg1 = reinterpret_cast< wxImage * >(argp1);
15388 {
15389 arg2 = wxString_in_helper(obj1);
15390 if (arg2 == NULL) SWIG_fail;
15391 temp2 = true;
15392 }
15393 ecode3 = SWIG_AsVal_int(obj2, &val3);
15394 if (!SWIG_IsOK(ecode3)) {
15395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15396 }
15397 arg3 = static_cast< int >(val3);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 {
15405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15406 }
15407 {
15408 if (temp2)
15409 delete arg2;
15410 }
15411 return resultobj;
15412 fail:
15413 {
15414 if (temp2)
15415 delete arg2;
15416 }
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15422 PyObject *resultobj = 0;
15423 wxImage *arg1 = (wxImage *) 0 ;
15424 wxString *arg2 = 0 ;
15425 wxString *arg3 = 0 ;
15426 bool result;
15427 void *argp1 = 0 ;
15428 int res1 = 0 ;
15429 bool temp2 = false ;
15430 bool temp3 = false ;
15431 PyObject * obj0 = 0 ;
15432 PyObject * obj1 = 0 ;
15433 PyObject * obj2 = 0 ;
15434 char * kwnames[] = {
15435 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15436 };
15437
15438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15440 if (!SWIG_IsOK(res1)) {
15441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15442 }
15443 arg1 = reinterpret_cast< wxImage * >(argp1);
15444 {
15445 arg2 = wxString_in_helper(obj1);
15446 if (arg2 == NULL) SWIG_fail;
15447 temp2 = true;
15448 }
15449 {
15450 arg3 = wxString_in_helper(obj2);
15451 if (arg3 == NULL) SWIG_fail;
15452 temp3 = true;
15453 }
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 {
15461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15462 }
15463 {
15464 if (temp2)
15465 delete arg2;
15466 }
15467 {
15468 if (temp3)
15469 delete arg3;
15470 }
15471 return resultobj;
15472 fail:
15473 {
15474 if (temp2)
15475 delete arg2;
15476 }
15477 {
15478 if (temp3)
15479 delete arg3;
15480 }
15481 return NULL;
15482 }
15483
15484
15485 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj = 0;
15487 wxInputStream *arg1 = 0 ;
15488 bool result;
15489 wxPyInputStream *temp1 ;
15490 bool created1 ;
15491 PyObject * obj0 = 0 ;
15492 char * kwnames[] = {
15493 (char *) "stream", NULL
15494 };
15495
15496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15497 {
15498 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15499 arg1 = temp1->m_wxis;
15500 created1 = false;
15501 } else {
15502 PyErr_Clear(); // clear the failure of the wxPyConvert above
15503 arg1 = wxPyCBInputStream_create(obj0, false);
15504 if (arg1 == NULL) {
15505 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15506 SWIG_fail;
15507 }
15508 created1 = true;
15509 }
15510 }
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 result = (bool)wxImage::CanRead(*arg1);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 {
15518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15519 }
15520 {
15521 if (created1) delete arg1;
15522 }
15523 return resultobj;
15524 fail:
15525 {
15526 if (created1) delete arg1;
15527 }
15528 return NULL;
15529 }
15530
15531
15532 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15533 PyObject *resultobj = 0;
15534 wxImage *arg1 = (wxImage *) 0 ;
15535 wxInputStream *arg2 = 0 ;
15536 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15537 int arg4 = (int) -1 ;
15538 bool result;
15539 void *argp1 = 0 ;
15540 int res1 = 0 ;
15541 wxPyInputStream *temp2 ;
15542 bool created2 ;
15543 long val3 ;
15544 int ecode3 = 0 ;
15545 int val4 ;
15546 int ecode4 = 0 ;
15547 PyObject * obj0 = 0 ;
15548 PyObject * obj1 = 0 ;
15549 PyObject * obj2 = 0 ;
15550 PyObject * obj3 = 0 ;
15551 char * kwnames[] = {
15552 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15553 };
15554
15555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15557 if (!SWIG_IsOK(res1)) {
15558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15559 }
15560 arg1 = reinterpret_cast< wxImage * >(argp1);
15561 {
15562 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15563 arg2 = temp2->m_wxis;
15564 created2 = false;
15565 } else {
15566 PyErr_Clear(); // clear the failure of the wxPyConvert above
15567 arg2 = wxPyCBInputStream_create(obj1, false);
15568 if (arg2 == NULL) {
15569 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15570 SWIG_fail;
15571 }
15572 created2 = true;
15573 }
15574 }
15575 if (obj2) {
15576 ecode3 = SWIG_AsVal_long(obj2, &val3);
15577 if (!SWIG_IsOK(ecode3)) {
15578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15579 }
15580 arg3 = static_cast< long >(val3);
15581 }
15582 if (obj3) {
15583 ecode4 = SWIG_AsVal_int(obj3, &val4);
15584 if (!SWIG_IsOK(ecode4)) {
15585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15586 }
15587 arg4 = static_cast< int >(val4);
15588 }
15589 {
15590 PyThreadState* __tstate = wxPyBeginAllowThreads();
15591 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15592 wxPyEndAllowThreads(__tstate);
15593 if (PyErr_Occurred()) SWIG_fail;
15594 }
15595 {
15596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15597 }
15598 {
15599 if (created2) delete arg2;
15600 }
15601 return resultobj;
15602 fail:
15603 {
15604 if (created2) delete arg2;
15605 }
15606 return NULL;
15607 }
15608
15609
15610 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15611 PyObject *resultobj = 0;
15612 wxImage *arg1 = (wxImage *) 0 ;
15613 wxInputStream *arg2 = 0 ;
15614 wxString *arg3 = 0 ;
15615 int arg4 = (int) -1 ;
15616 bool result;
15617 void *argp1 = 0 ;
15618 int res1 = 0 ;
15619 wxPyInputStream *temp2 ;
15620 bool created2 ;
15621 bool temp3 = false ;
15622 int val4 ;
15623 int ecode4 = 0 ;
15624 PyObject * obj0 = 0 ;
15625 PyObject * obj1 = 0 ;
15626 PyObject * obj2 = 0 ;
15627 PyObject * obj3 = 0 ;
15628 char * kwnames[] = {
15629 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15630 };
15631
15632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15634 if (!SWIG_IsOK(res1)) {
15635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15636 }
15637 arg1 = reinterpret_cast< wxImage * >(argp1);
15638 {
15639 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15640 arg2 = temp2->m_wxis;
15641 created2 = false;
15642 } else {
15643 PyErr_Clear(); // clear the failure of the wxPyConvert above
15644 arg2 = wxPyCBInputStream_create(obj1, false);
15645 if (arg2 == NULL) {
15646 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15647 SWIG_fail;
15648 }
15649 created2 = true;
15650 }
15651 }
15652 {
15653 arg3 = wxString_in_helper(obj2);
15654 if (arg3 == NULL) SWIG_fail;
15655 temp3 = true;
15656 }
15657 if (obj3) {
15658 ecode4 = SWIG_AsVal_int(obj3, &val4);
15659 if (!SWIG_IsOK(ecode4)) {
15660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15661 }
15662 arg4 = static_cast< int >(val4);
15663 }
15664 {
15665 PyThreadState* __tstate = wxPyBeginAllowThreads();
15666 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 {
15671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15672 }
15673 {
15674 if (created2) delete arg2;
15675 }
15676 {
15677 if (temp3)
15678 delete arg3;
15679 }
15680 return resultobj;
15681 fail:
15682 {
15683 if (created2) delete arg2;
15684 }
15685 {
15686 if (temp3)
15687 delete arg3;
15688 }
15689 return NULL;
15690 }
15691
15692
15693 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15694 PyObject *resultobj = 0;
15695 wxImage *arg1 = (wxImage *) 0 ;
15696 bool result;
15697 void *argp1 = 0 ;
15698 int res1 = 0 ;
15699 PyObject *swig_obj[1] ;
15700
15701 if (!args) SWIG_fail;
15702 swig_obj[0] = args;
15703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15704 if (!SWIG_IsOK(res1)) {
15705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15706 }
15707 arg1 = reinterpret_cast< wxImage * >(argp1);
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (bool)(arg1)->IsOk();
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 {
15715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15716 }
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15724 PyObject *resultobj = 0;
15725 wxImage *arg1 = (wxImage *) 0 ;
15726 int result;
15727 void *argp1 = 0 ;
15728 int res1 = 0 ;
15729 PyObject *swig_obj[1] ;
15730
15731 if (!args) SWIG_fail;
15732 swig_obj[0] = args;
15733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15734 if (!SWIG_IsOK(res1)) {
15735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15736 }
15737 arg1 = reinterpret_cast< wxImage * >(argp1);
15738 {
15739 PyThreadState* __tstate = wxPyBeginAllowThreads();
15740 result = (int)(arg1)->GetWidth();
15741 wxPyEndAllowThreads(__tstate);
15742 if (PyErr_Occurred()) SWIG_fail;
15743 }
15744 resultobj = SWIG_From_int(static_cast< int >(result));
15745 return resultobj;
15746 fail:
15747 return NULL;
15748 }
15749
15750
15751 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15752 PyObject *resultobj = 0;
15753 wxImage *arg1 = (wxImage *) 0 ;
15754 int result;
15755 void *argp1 = 0 ;
15756 int res1 = 0 ;
15757 PyObject *swig_obj[1] ;
15758
15759 if (!args) SWIG_fail;
15760 swig_obj[0] = args;
15761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15762 if (!SWIG_IsOK(res1)) {
15763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15764 }
15765 arg1 = reinterpret_cast< wxImage * >(argp1);
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 result = (int)(arg1)->GetHeight();
15769 wxPyEndAllowThreads(__tstate);
15770 if (PyErr_Occurred()) SWIG_fail;
15771 }
15772 resultobj = SWIG_From_int(static_cast< int >(result));
15773 return resultobj;
15774 fail:
15775 return NULL;
15776 }
15777
15778
15779 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15780 PyObject *resultobj = 0;
15781 wxImage *arg1 = (wxImage *) 0 ;
15782 wxSize result;
15783 void *argp1 = 0 ;
15784 int res1 = 0 ;
15785 PyObject *swig_obj[1] ;
15786
15787 if (!args) SWIG_fail;
15788 swig_obj[0] = args;
15789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15790 if (!SWIG_IsOK(res1)) {
15791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15792 }
15793 arg1 = reinterpret_cast< wxImage * >(argp1);
15794 {
15795 PyThreadState* __tstate = wxPyBeginAllowThreads();
15796 result = wxImage_GetSize(arg1);
15797 wxPyEndAllowThreads(__tstate);
15798 if (PyErr_Occurred()) SWIG_fail;
15799 }
15800 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15801 return resultobj;
15802 fail:
15803 return NULL;
15804 }
15805
15806
15807 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15808 PyObject *resultobj = 0;
15809 wxImage *arg1 = (wxImage *) 0 ;
15810 wxRect *arg2 = 0 ;
15811 SwigValueWrapper<wxImage > result;
15812 void *argp1 = 0 ;
15813 int res1 = 0 ;
15814 wxRect temp2 ;
15815 PyObject * obj0 = 0 ;
15816 PyObject * obj1 = 0 ;
15817 char * kwnames[] = {
15818 (char *) "self",(char *) "rect", NULL
15819 };
15820
15821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15823 if (!SWIG_IsOK(res1)) {
15824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15825 }
15826 arg1 = reinterpret_cast< wxImage * >(argp1);
15827 {
15828 arg2 = &temp2;
15829 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15830 }
15831 {
15832 PyThreadState* __tstate = wxPyBeginAllowThreads();
15833 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15838 return resultobj;
15839 fail:
15840 return NULL;
15841 }
15842
15843
15844 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15845 PyObject *resultobj = 0;
15846 wxImage *arg1 = (wxImage *) 0 ;
15847 wxSize *arg2 = 0 ;
15848 wxPoint *arg3 = 0 ;
15849 int arg4 = (int) -1 ;
15850 int arg5 = (int) -1 ;
15851 int arg6 = (int) -1 ;
15852 SwigValueWrapper<wxImage > result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 wxSize temp2 ;
15856 wxPoint temp3 ;
15857 int val4 ;
15858 int ecode4 = 0 ;
15859 int val5 ;
15860 int ecode5 = 0 ;
15861 int val6 ;
15862 int ecode6 = 0 ;
15863 PyObject * obj0 = 0 ;
15864 PyObject * obj1 = 0 ;
15865 PyObject * obj2 = 0 ;
15866 PyObject * obj3 = 0 ;
15867 PyObject * obj4 = 0 ;
15868 PyObject * obj5 = 0 ;
15869 char * kwnames[] = {
15870 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15871 };
15872
15873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15875 if (!SWIG_IsOK(res1)) {
15876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15877 }
15878 arg1 = reinterpret_cast< wxImage * >(argp1);
15879 {
15880 arg2 = &temp2;
15881 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15882 }
15883 {
15884 arg3 = &temp3;
15885 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15886 }
15887 if (obj3) {
15888 ecode4 = SWIG_AsVal_int(obj3, &val4);
15889 if (!SWIG_IsOK(ecode4)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15891 }
15892 arg4 = static_cast< int >(val4);
15893 }
15894 if (obj4) {
15895 ecode5 = SWIG_AsVal_int(obj4, &val5);
15896 if (!SWIG_IsOK(ecode5)) {
15897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15898 }
15899 arg5 = static_cast< int >(val5);
15900 }
15901 if (obj5) {
15902 ecode6 = SWIG_AsVal_int(obj5, &val6);
15903 if (!SWIG_IsOK(ecode6)) {
15904 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15905 }
15906 arg6 = static_cast< int >(val6);
15907 }
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15922 PyObject *resultobj = 0;
15923 wxImage *arg1 = (wxImage *) 0 ;
15924 SwigValueWrapper<wxImage > result;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 PyObject *swig_obj[1] ;
15928
15929 if (!args) SWIG_fail;
15930 swig_obj[0] = args;
15931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15932 if (!SWIG_IsOK(res1)) {
15933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15934 }
15935 arg1 = reinterpret_cast< wxImage * >(argp1);
15936 {
15937 PyThreadState* __tstate = wxPyBeginAllowThreads();
15938 result = (arg1)->Copy();
15939 wxPyEndAllowThreads(__tstate);
15940 if (PyErr_Occurred()) SWIG_fail;
15941 }
15942 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15943 return resultobj;
15944 fail:
15945 return NULL;
15946 }
15947
15948
15949 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15950 PyObject *resultobj = 0;
15951 wxImage *arg1 = (wxImage *) 0 ;
15952 wxImage *arg2 = 0 ;
15953 int arg3 ;
15954 int arg4 ;
15955 void *argp1 = 0 ;
15956 int res1 = 0 ;
15957 void *argp2 = 0 ;
15958 int res2 = 0 ;
15959 int val3 ;
15960 int ecode3 = 0 ;
15961 int val4 ;
15962 int ecode4 = 0 ;
15963 PyObject * obj0 = 0 ;
15964 PyObject * obj1 = 0 ;
15965 PyObject * obj2 = 0 ;
15966 PyObject * obj3 = 0 ;
15967 char * kwnames[] = {
15968 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15969 };
15970
15971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15975 }
15976 arg1 = reinterpret_cast< wxImage * >(argp1);
15977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15978 if (!SWIG_IsOK(res2)) {
15979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15980 }
15981 if (!argp2) {
15982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15983 }
15984 arg2 = reinterpret_cast< wxImage * >(argp2);
15985 ecode3 = SWIG_AsVal_int(obj2, &val3);
15986 if (!SWIG_IsOK(ecode3)) {
15987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15988 }
15989 arg3 = static_cast< int >(val3);
15990 ecode4 = SWIG_AsVal_int(obj3, &val4);
15991 if (!SWIG_IsOK(ecode4)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15993 }
15994 arg4 = static_cast< int >(val4);
15995 {
15996 PyThreadState* __tstate = wxPyBeginAllowThreads();
15997 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15998 wxPyEndAllowThreads(__tstate);
15999 if (PyErr_Occurred()) SWIG_fail;
16000 }
16001 resultobj = SWIG_Py_Void();
16002 return resultobj;
16003 fail:
16004 return NULL;
16005 }
16006
16007
16008 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16009 PyObject *resultobj = 0;
16010 wxImage *arg1 = (wxImage *) 0 ;
16011 PyObject *result = 0 ;
16012 void *argp1 = 0 ;
16013 int res1 = 0 ;
16014 PyObject *swig_obj[1] ;
16015
16016 if (!args) SWIG_fail;
16017 swig_obj[0] = args;
16018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16019 if (!SWIG_IsOK(res1)) {
16020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16021 }
16022 arg1 = reinterpret_cast< wxImage * >(argp1);
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (PyObject *)wxImage_GetData(arg1);
16026 wxPyEndAllowThreads(__tstate);
16027 if (PyErr_Occurred()) SWIG_fail;
16028 }
16029 resultobj = result;
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj = 0;
16038 wxImage *arg1 = (wxImage *) 0 ;
16039 buffer arg2 ;
16040 int arg3 ;
16041 void *argp1 = 0 ;
16042 int res1 = 0 ;
16043 Py_ssize_t temp2 ;
16044 PyObject * obj0 = 0 ;
16045 PyObject * obj1 = 0 ;
16046 char * kwnames[] = {
16047 (char *) "self",(char *) "data", NULL
16048 };
16049
16050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16052 if (!SWIG_IsOK(res1)) {
16053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16054 }
16055 arg1 = reinterpret_cast< wxImage * >(argp1);
16056 {
16057 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16058 arg3 = (int)temp2;
16059 }
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 wxImage_SetData(arg1,arg2,arg3);
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 resultobj = SWIG_Py_Void();
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16074 PyObject *resultobj = 0;
16075 wxImage *arg1 = (wxImage *) 0 ;
16076 PyObject *result = 0 ;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 PyObject *swig_obj[1] ;
16080
16081 if (!args) SWIG_fail;
16082 swig_obj[0] = args;
16083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16086 }
16087 arg1 = reinterpret_cast< wxImage * >(argp1);
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = result;
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16102 PyObject *resultobj = 0;
16103 wxImage *arg1 = (wxImage *) 0 ;
16104 buffer arg2 ;
16105 int arg3 ;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 Py_ssize_t temp2 ;
16109 PyObject * obj0 = 0 ;
16110 PyObject * obj1 = 0 ;
16111 char * kwnames[] = {
16112 (char *) "self",(char *) "data", NULL
16113 };
16114
16115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16117 if (!SWIG_IsOK(res1)) {
16118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16119 }
16120 arg1 = reinterpret_cast< wxImage * >(argp1);
16121 {
16122 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16123 arg3 = (int)temp2;
16124 }
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 wxImage_SetDataBuffer(arg1,arg2,arg3);
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 resultobj = SWIG_Py_Void();
16132 return resultobj;
16133 fail:
16134 return NULL;
16135 }
16136
16137
16138 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16139 PyObject *resultobj = 0;
16140 wxImage *arg1 = (wxImage *) 0 ;
16141 PyObject *result = 0 ;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 PyObject *swig_obj[1] ;
16145
16146 if (!args) SWIG_fail;
16147 swig_obj[0] = args;
16148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16151 }
16152 arg1 = reinterpret_cast< wxImage * >(argp1);
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (PyObject *)wxImage_GetAlphaData(arg1);
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 resultobj = result;
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16167 PyObject *resultobj = 0;
16168 wxImage *arg1 = (wxImage *) 0 ;
16169 buffer arg2 ;
16170 int arg3 ;
16171 void *argp1 = 0 ;
16172 int res1 = 0 ;
16173 Py_ssize_t temp2 ;
16174 PyObject * obj0 = 0 ;
16175 PyObject * obj1 = 0 ;
16176 char * kwnames[] = {
16177 (char *) "self",(char *) "alpha", NULL
16178 };
16179
16180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16182 if (!SWIG_IsOK(res1)) {
16183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16184 }
16185 arg1 = reinterpret_cast< wxImage * >(argp1);
16186 {
16187 if (obj1 != Py_None) {
16188 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16189 arg3 = (int)temp2;
16190 }
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 wxImage_SetAlphaData(arg1,arg2,arg3);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_Py_Void();
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16206 PyObject *resultobj = 0;
16207 wxImage *arg1 = (wxImage *) 0 ;
16208 PyObject *result = 0 ;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 PyObject *swig_obj[1] ;
16212
16213 if (!args) SWIG_fail;
16214 swig_obj[0] = args;
16215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16216 if (!SWIG_IsOK(res1)) {
16217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16218 }
16219 arg1 = reinterpret_cast< wxImage * >(argp1);
16220 {
16221 PyThreadState* __tstate = wxPyBeginAllowThreads();
16222 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16223 wxPyEndAllowThreads(__tstate);
16224 if (PyErr_Occurred()) SWIG_fail;
16225 }
16226 resultobj = result;
16227 return resultobj;
16228 fail:
16229 return NULL;
16230 }
16231
16232
16233 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16234 PyObject *resultobj = 0;
16235 wxImage *arg1 = (wxImage *) 0 ;
16236 buffer arg2 ;
16237 int arg3 ;
16238 void *argp1 = 0 ;
16239 int res1 = 0 ;
16240 Py_ssize_t temp2 ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 char * kwnames[] = {
16244 (char *) "self",(char *) "alpha", NULL
16245 };
16246
16247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16249 if (!SWIG_IsOK(res1)) {
16250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16251 }
16252 arg1 = reinterpret_cast< wxImage * >(argp1);
16253 {
16254 if (obj1 != Py_None) {
16255 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16256 arg3 = (int)temp2;
16257 }
16258 }
16259 {
16260 PyThreadState* __tstate = wxPyBeginAllowThreads();
16261 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16262 wxPyEndAllowThreads(__tstate);
16263 if (PyErr_Occurred()) SWIG_fail;
16264 }
16265 resultobj = SWIG_Py_Void();
16266 return resultobj;
16267 fail:
16268 return NULL;
16269 }
16270
16271
16272 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16273 PyObject *resultobj = 0;
16274 wxImage *arg1 = (wxImage *) 0 ;
16275 byte arg2 ;
16276 byte arg3 ;
16277 byte arg4 ;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 unsigned char val2 ;
16281 int ecode2 = 0 ;
16282 unsigned char val3 ;
16283 int ecode3 = 0 ;
16284 unsigned char val4 ;
16285 int ecode4 = 0 ;
16286 PyObject * obj0 = 0 ;
16287 PyObject * obj1 = 0 ;
16288 PyObject * obj2 = 0 ;
16289 PyObject * obj3 = 0 ;
16290 char * kwnames[] = {
16291 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16292 };
16293
16294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16296 if (!SWIG_IsOK(res1)) {
16297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16298 }
16299 arg1 = reinterpret_cast< wxImage * >(argp1);
16300 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16301 if (!SWIG_IsOK(ecode2)) {
16302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16303 }
16304 arg2 = static_cast< byte >(val2);
16305 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16306 if (!SWIG_IsOK(ecode3)) {
16307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16308 }
16309 arg3 = static_cast< byte >(val3);
16310 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16311 if (!SWIG_IsOK(ecode4)) {
16312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16313 }
16314 arg4 = static_cast< byte >(val4);
16315 {
16316 PyThreadState* __tstate = wxPyBeginAllowThreads();
16317 (arg1)->SetMaskColour(arg2,arg3,arg4);
16318 wxPyEndAllowThreads(__tstate);
16319 if (PyErr_Occurred()) SWIG_fail;
16320 }
16321 resultobj = SWIG_Py_Void();
16322 return resultobj;
16323 fail:
16324 return NULL;
16325 }
16326
16327
16328 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16329 PyObject *resultobj = 0;
16330 wxImage *arg1 = (wxImage *) 0 ;
16331 byte *arg2 = (byte *) 0 ;
16332 byte *arg3 = (byte *) 0 ;
16333 byte *arg4 = (byte *) 0 ;
16334 void *argp1 = 0 ;
16335 int res1 = 0 ;
16336 byte temp2 ;
16337 int res2 = SWIG_TMPOBJ ;
16338 byte temp3 ;
16339 int res3 = SWIG_TMPOBJ ;
16340 byte temp4 ;
16341 int res4 = SWIG_TMPOBJ ;
16342 PyObject *swig_obj[1] ;
16343
16344 arg2 = &temp2;
16345 arg3 = &temp3;
16346 arg4 = &temp4;
16347 if (!args) SWIG_fail;
16348 swig_obj[0] = args;
16349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16350 if (!SWIG_IsOK(res1)) {
16351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16352 }
16353 arg1 = reinterpret_cast< wxImage * >(argp1);
16354 {
16355 PyThreadState* __tstate = wxPyBeginAllowThreads();
16356 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16357 wxPyEndAllowThreads(__tstate);
16358 if (PyErr_Occurred()) SWIG_fail;
16359 }
16360 resultobj = SWIG_Py_Void();
16361 if (SWIG_IsTmpObj(res2)) {
16362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16363 } else {
16364 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16366 }
16367 if (SWIG_IsTmpObj(res3)) {
16368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16369 } else {
16370 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16372 }
16373 if (SWIG_IsTmpObj(res4)) {
16374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16375 } else {
16376 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16378 }
16379 return resultobj;
16380 fail:
16381 return NULL;
16382 }
16383
16384
16385 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16386 PyObject *resultobj = 0;
16387 wxImage *arg1 = (wxImage *) 0 ;
16388 byte result;
16389 void *argp1 = 0 ;
16390 int res1 = 0 ;
16391 PyObject *swig_obj[1] ;
16392
16393 if (!args) SWIG_fail;
16394 swig_obj[0] = args;
16395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16396 if (!SWIG_IsOK(res1)) {
16397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16398 }
16399 arg1 = reinterpret_cast< wxImage * >(argp1);
16400 {
16401 PyThreadState* __tstate = wxPyBeginAllowThreads();
16402 result = (byte)(arg1)->GetMaskRed();
16403 wxPyEndAllowThreads(__tstate);
16404 if (PyErr_Occurred()) SWIG_fail;
16405 }
16406 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16407 return resultobj;
16408 fail:
16409 return NULL;
16410 }
16411
16412
16413 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16414 PyObject *resultobj = 0;
16415 wxImage *arg1 = (wxImage *) 0 ;
16416 byte result;
16417 void *argp1 = 0 ;
16418 int res1 = 0 ;
16419 PyObject *swig_obj[1] ;
16420
16421 if (!args) SWIG_fail;
16422 swig_obj[0] = args;
16423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16424 if (!SWIG_IsOK(res1)) {
16425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16426 }
16427 arg1 = reinterpret_cast< wxImage * >(argp1);
16428 {
16429 PyThreadState* __tstate = wxPyBeginAllowThreads();
16430 result = (byte)(arg1)->GetMaskGreen();
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16435 return resultobj;
16436 fail:
16437 return NULL;
16438 }
16439
16440
16441 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16442 PyObject *resultobj = 0;
16443 wxImage *arg1 = (wxImage *) 0 ;
16444 byte result;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 PyObject *swig_obj[1] ;
16448
16449 if (!args) SWIG_fail;
16450 swig_obj[0] = args;
16451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16454 }
16455 arg1 = reinterpret_cast< wxImage * >(argp1);
16456 {
16457 PyThreadState* __tstate = wxPyBeginAllowThreads();
16458 result = (byte)(arg1)->GetMaskBlue();
16459 wxPyEndAllowThreads(__tstate);
16460 if (PyErr_Occurred()) SWIG_fail;
16461 }
16462 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16463 return resultobj;
16464 fail:
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16470 PyObject *resultobj = 0;
16471 wxImage *arg1 = (wxImage *) 0 ;
16472 bool arg2 = (bool) true ;
16473 void *argp1 = 0 ;
16474 int res1 = 0 ;
16475 bool val2 ;
16476 int ecode2 = 0 ;
16477 PyObject * obj0 = 0 ;
16478 PyObject * obj1 = 0 ;
16479 char * kwnames[] = {
16480 (char *) "self",(char *) "mask", NULL
16481 };
16482
16483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16485 if (!SWIG_IsOK(res1)) {
16486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16487 }
16488 arg1 = reinterpret_cast< wxImage * >(argp1);
16489 if (obj1) {
16490 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16491 if (!SWIG_IsOK(ecode2)) {
16492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16493 }
16494 arg2 = static_cast< bool >(val2);
16495 }
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 (arg1)->SetMask(arg2);
16499 wxPyEndAllowThreads(__tstate);
16500 if (PyErr_Occurred()) SWIG_fail;
16501 }
16502 resultobj = SWIG_Py_Void();
16503 return resultobj;
16504 fail:
16505 return NULL;
16506 }
16507
16508
16509 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16510 PyObject *resultobj = 0;
16511 wxImage *arg1 = (wxImage *) 0 ;
16512 bool result;
16513 void *argp1 = 0 ;
16514 int res1 = 0 ;
16515 PyObject *swig_obj[1] ;
16516
16517 if (!args) SWIG_fail;
16518 swig_obj[0] = args;
16519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16520 if (!SWIG_IsOK(res1)) {
16521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16522 }
16523 arg1 = reinterpret_cast< wxImage * >(argp1);
16524 {
16525 PyThreadState* __tstate = wxPyBeginAllowThreads();
16526 result = (bool)(arg1)->HasMask();
16527 wxPyEndAllowThreads(__tstate);
16528 if (PyErr_Occurred()) SWIG_fail;
16529 }
16530 {
16531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16532 }
16533 return resultobj;
16534 fail:
16535 return NULL;
16536 }
16537
16538
16539 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16540 PyObject *resultobj = 0;
16541 wxImage *arg1 = (wxImage *) 0 ;
16542 double arg2 ;
16543 wxPoint *arg3 = 0 ;
16544 bool arg4 = (bool) true ;
16545 wxPoint *arg5 = (wxPoint *) NULL ;
16546 SwigValueWrapper<wxImage > result;
16547 void *argp1 = 0 ;
16548 int res1 = 0 ;
16549 double val2 ;
16550 int ecode2 = 0 ;
16551 wxPoint temp3 ;
16552 bool val4 ;
16553 int ecode4 = 0 ;
16554 void *argp5 = 0 ;
16555 int res5 = 0 ;
16556 PyObject * obj0 = 0 ;
16557 PyObject * obj1 = 0 ;
16558 PyObject * obj2 = 0 ;
16559 PyObject * obj3 = 0 ;
16560 PyObject * obj4 = 0 ;
16561 char * kwnames[] = {
16562 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16563 };
16564
16565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16567 if (!SWIG_IsOK(res1)) {
16568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16569 }
16570 arg1 = reinterpret_cast< wxImage * >(argp1);
16571 ecode2 = SWIG_AsVal_double(obj1, &val2);
16572 if (!SWIG_IsOK(ecode2)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16574 }
16575 arg2 = static_cast< double >(val2);
16576 {
16577 arg3 = &temp3;
16578 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16579 }
16580 if (obj3) {
16581 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16582 if (!SWIG_IsOK(ecode4)) {
16583 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16584 }
16585 arg4 = static_cast< bool >(val4);
16586 }
16587 if (obj4) {
16588 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16589 if (!SWIG_IsOK(res5)) {
16590 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16591 }
16592 arg5 = reinterpret_cast< wxPoint * >(argp5);
16593 }
16594 {
16595 PyThreadState* __tstate = wxPyBeginAllowThreads();
16596 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16597 wxPyEndAllowThreads(__tstate);
16598 if (PyErr_Occurred()) SWIG_fail;
16599 }
16600 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16601 return resultobj;
16602 fail:
16603 return NULL;
16604 }
16605
16606
16607 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16608 PyObject *resultobj = 0;
16609 wxImage *arg1 = (wxImage *) 0 ;
16610 bool arg2 = (bool) true ;
16611 SwigValueWrapper<wxImage > result;
16612 void *argp1 = 0 ;
16613 int res1 = 0 ;
16614 bool val2 ;
16615 int ecode2 = 0 ;
16616 PyObject * obj0 = 0 ;
16617 PyObject * obj1 = 0 ;
16618 char * kwnames[] = {
16619 (char *) "self",(char *) "clockwise", NULL
16620 };
16621
16622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16624 if (!SWIG_IsOK(res1)) {
16625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16626 }
16627 arg1 = reinterpret_cast< wxImage * >(argp1);
16628 if (obj1) {
16629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16630 if (!SWIG_IsOK(ecode2)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16632 }
16633 arg2 = static_cast< bool >(val2);
16634 }
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = (arg1)->Rotate90(arg2);
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16649 PyObject *resultobj = 0;
16650 wxImage *arg1 = (wxImage *) 0 ;
16651 bool arg2 = (bool) true ;
16652 SwigValueWrapper<wxImage > result;
16653 void *argp1 = 0 ;
16654 int res1 = 0 ;
16655 bool val2 ;
16656 int ecode2 = 0 ;
16657 PyObject * obj0 = 0 ;
16658 PyObject * obj1 = 0 ;
16659 char * kwnames[] = {
16660 (char *) "self",(char *) "horizontally", NULL
16661 };
16662
16663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16665 if (!SWIG_IsOK(res1)) {
16666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16667 }
16668 arg1 = reinterpret_cast< wxImage * >(argp1);
16669 if (obj1) {
16670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16671 if (!SWIG_IsOK(ecode2)) {
16672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16673 }
16674 arg2 = static_cast< bool >(val2);
16675 }
16676 {
16677 PyThreadState* __tstate = wxPyBeginAllowThreads();
16678 result = (arg1)->Mirror(arg2);
16679 wxPyEndAllowThreads(__tstate);
16680 if (PyErr_Occurred()) SWIG_fail;
16681 }
16682 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16683 return resultobj;
16684 fail:
16685 return NULL;
16686 }
16687
16688
16689 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16690 PyObject *resultobj = 0;
16691 wxImage *arg1 = (wxImage *) 0 ;
16692 byte arg2 ;
16693 byte arg3 ;
16694 byte arg4 ;
16695 byte arg5 ;
16696 byte arg6 ;
16697 byte arg7 ;
16698 void *argp1 = 0 ;
16699 int res1 = 0 ;
16700 unsigned char val2 ;
16701 int ecode2 = 0 ;
16702 unsigned char val3 ;
16703 int ecode3 = 0 ;
16704 unsigned char val4 ;
16705 int ecode4 = 0 ;
16706 unsigned char val5 ;
16707 int ecode5 = 0 ;
16708 unsigned char val6 ;
16709 int ecode6 = 0 ;
16710 unsigned char val7 ;
16711 int ecode7 = 0 ;
16712 PyObject * obj0 = 0 ;
16713 PyObject * obj1 = 0 ;
16714 PyObject * obj2 = 0 ;
16715 PyObject * obj3 = 0 ;
16716 PyObject * obj4 = 0 ;
16717 PyObject * obj5 = 0 ;
16718 PyObject * obj6 = 0 ;
16719 char * kwnames[] = {
16720 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16721 };
16722
16723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16727 }
16728 arg1 = reinterpret_cast< wxImage * >(argp1);
16729 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16730 if (!SWIG_IsOK(ecode2)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16732 }
16733 arg2 = static_cast< byte >(val2);
16734 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16735 if (!SWIG_IsOK(ecode3)) {
16736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16737 }
16738 arg3 = static_cast< byte >(val3);
16739 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16740 if (!SWIG_IsOK(ecode4)) {
16741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16742 }
16743 arg4 = static_cast< byte >(val4);
16744 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16745 if (!SWIG_IsOK(ecode5)) {
16746 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16747 }
16748 arg5 = static_cast< byte >(val5);
16749 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16750 if (!SWIG_IsOK(ecode6)) {
16751 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16752 }
16753 arg6 = static_cast< byte >(val6);
16754 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16755 if (!SWIG_IsOK(ecode7)) {
16756 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16757 }
16758 arg7 = static_cast< byte >(val7);
16759 {
16760 PyThreadState* __tstate = wxPyBeginAllowThreads();
16761 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 resultobj = SWIG_Py_Void();
16766 return resultobj;
16767 fail:
16768 return NULL;
16769 }
16770
16771
16772 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16773 PyObject *resultobj = 0;
16774 wxImage *arg1 = (wxImage *) 0 ;
16775 double arg2 = (double) 0.299 ;
16776 double arg3 = (double) 0.587 ;
16777 double arg4 = (double) 0.114 ;
16778 SwigValueWrapper<wxImage > result;
16779 void *argp1 = 0 ;
16780 int res1 = 0 ;
16781 double val2 ;
16782 int ecode2 = 0 ;
16783 double val3 ;
16784 int ecode3 = 0 ;
16785 double val4 ;
16786 int ecode4 = 0 ;
16787 PyObject * obj0 = 0 ;
16788 PyObject * obj1 = 0 ;
16789 PyObject * obj2 = 0 ;
16790 PyObject * obj3 = 0 ;
16791 char * kwnames[] = {
16792 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16793 };
16794
16795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16797 if (!SWIG_IsOK(res1)) {
16798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16799 }
16800 arg1 = reinterpret_cast< wxImage * >(argp1);
16801 if (obj1) {
16802 ecode2 = SWIG_AsVal_double(obj1, &val2);
16803 if (!SWIG_IsOK(ecode2)) {
16804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16805 }
16806 arg2 = static_cast< double >(val2);
16807 }
16808 if (obj2) {
16809 ecode3 = SWIG_AsVal_double(obj2, &val3);
16810 if (!SWIG_IsOK(ecode3)) {
16811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16812 }
16813 arg3 = static_cast< double >(val3);
16814 }
16815 if (obj3) {
16816 ecode4 = SWIG_AsVal_double(obj3, &val4);
16817 if (!SWIG_IsOK(ecode4)) {
16818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16819 }
16820 arg4 = static_cast< double >(val4);
16821 }
16822 {
16823 PyThreadState* __tstate = wxPyBeginAllowThreads();
16824 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16825 wxPyEndAllowThreads(__tstate);
16826 if (PyErr_Occurred()) SWIG_fail;
16827 }
16828 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16829 return resultobj;
16830 fail:
16831 return NULL;
16832 }
16833
16834
16835 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16836 PyObject *resultobj = 0;
16837 wxImage *arg1 = (wxImage *) 0 ;
16838 byte arg2 ;
16839 byte arg3 ;
16840 byte arg4 ;
16841 SwigValueWrapper<wxImage > result;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 unsigned char val2 ;
16845 int ecode2 = 0 ;
16846 unsigned char val3 ;
16847 int ecode3 = 0 ;
16848 unsigned char val4 ;
16849 int ecode4 = 0 ;
16850 PyObject * obj0 = 0 ;
16851 PyObject * obj1 = 0 ;
16852 PyObject * obj2 = 0 ;
16853 PyObject * obj3 = 0 ;
16854 char * kwnames[] = {
16855 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16856 };
16857
16858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16860 if (!SWIG_IsOK(res1)) {
16861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16862 }
16863 arg1 = reinterpret_cast< wxImage * >(argp1);
16864 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16865 if (!SWIG_IsOK(ecode2)) {
16866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16867 }
16868 arg2 = static_cast< byte >(val2);
16869 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16870 if (!SWIG_IsOK(ecode3)) {
16871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16872 }
16873 arg3 = static_cast< byte >(val3);
16874 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16875 if (!SWIG_IsOK(ecode4)) {
16876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16877 }
16878 arg4 = static_cast< byte >(val4);
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj = 0;
16894 wxImage *arg1 = (wxImage *) 0 ;
16895 wxString *arg2 = 0 ;
16896 wxString *arg3 = 0 ;
16897 void *argp1 = 0 ;
16898 int res1 = 0 ;
16899 bool temp2 = false ;
16900 bool temp3 = false ;
16901 PyObject * obj0 = 0 ;
16902 PyObject * obj1 = 0 ;
16903 PyObject * obj2 = 0 ;
16904 char * kwnames[] = {
16905 (char *) "self",(char *) "name",(char *) "value", NULL
16906 };
16907
16908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16912 }
16913 arg1 = reinterpret_cast< wxImage * >(argp1);
16914 {
16915 arg2 = wxString_in_helper(obj1);
16916 if (arg2 == NULL) SWIG_fail;
16917 temp2 = true;
16918 }
16919 {
16920 arg3 = wxString_in_helper(obj2);
16921 if (arg3 == NULL) SWIG_fail;
16922 temp3 = true;
16923 }
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 resultobj = SWIG_Py_Void();
16931 {
16932 if (temp2)
16933 delete arg2;
16934 }
16935 {
16936 if (temp3)
16937 delete arg3;
16938 }
16939 return resultobj;
16940 fail:
16941 {
16942 if (temp2)
16943 delete arg2;
16944 }
16945 {
16946 if (temp3)
16947 delete arg3;
16948 }
16949 return NULL;
16950 }
16951
16952
16953 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16954 PyObject *resultobj = 0;
16955 wxImage *arg1 = (wxImage *) 0 ;
16956 wxString *arg2 = 0 ;
16957 int arg3 ;
16958 void *argp1 = 0 ;
16959 int res1 = 0 ;
16960 bool temp2 = false ;
16961 int val3 ;
16962 int ecode3 = 0 ;
16963 PyObject * obj0 = 0 ;
16964 PyObject * obj1 = 0 ;
16965 PyObject * obj2 = 0 ;
16966 char * kwnames[] = {
16967 (char *) "self",(char *) "name",(char *) "value", NULL
16968 };
16969
16970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16972 if (!SWIG_IsOK(res1)) {
16973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16974 }
16975 arg1 = reinterpret_cast< wxImage * >(argp1);
16976 {
16977 arg2 = wxString_in_helper(obj1);
16978 if (arg2 == NULL) SWIG_fail;
16979 temp2 = true;
16980 }
16981 ecode3 = SWIG_AsVal_int(obj2, &val3);
16982 if (!SWIG_IsOK(ecode3)) {
16983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16984 }
16985 arg3 = static_cast< int >(val3);
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 (arg1)->SetOption((wxString const &)*arg2,arg3);
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 resultobj = SWIG_Py_Void();
16993 {
16994 if (temp2)
16995 delete arg2;
16996 }
16997 return resultobj;
16998 fail:
16999 {
17000 if (temp2)
17001 delete arg2;
17002 }
17003 return NULL;
17004 }
17005
17006
17007 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj = 0;
17009 wxImage *arg1 = (wxImage *) 0 ;
17010 wxString *arg2 = 0 ;
17011 wxString result;
17012 void *argp1 = 0 ;
17013 int res1 = 0 ;
17014 bool temp2 = false ;
17015 PyObject * obj0 = 0 ;
17016 PyObject * obj1 = 0 ;
17017 char * kwnames[] = {
17018 (char *) "self",(char *) "name", NULL
17019 };
17020
17021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17023 if (!SWIG_IsOK(res1)) {
17024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17025 }
17026 arg1 = reinterpret_cast< wxImage * >(argp1);
17027 {
17028 arg2 = wxString_in_helper(obj1);
17029 if (arg2 == NULL) SWIG_fail;
17030 temp2 = true;
17031 }
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 {
17039 #if wxUSE_UNICODE
17040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17041 #else
17042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17043 #endif
17044 }
17045 {
17046 if (temp2)
17047 delete arg2;
17048 }
17049 return resultobj;
17050 fail:
17051 {
17052 if (temp2)
17053 delete arg2;
17054 }
17055 return NULL;
17056 }
17057
17058
17059 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17060 PyObject *resultobj = 0;
17061 wxImage *arg1 = (wxImage *) 0 ;
17062 wxString *arg2 = 0 ;
17063 int result;
17064 void *argp1 = 0 ;
17065 int res1 = 0 ;
17066 bool temp2 = false ;
17067 PyObject * obj0 = 0 ;
17068 PyObject * obj1 = 0 ;
17069 char * kwnames[] = {
17070 (char *) "self",(char *) "name", NULL
17071 };
17072
17073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17075 if (!SWIG_IsOK(res1)) {
17076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17077 }
17078 arg1 = reinterpret_cast< wxImage * >(argp1);
17079 {
17080 arg2 = wxString_in_helper(obj1);
17081 if (arg2 == NULL) SWIG_fail;
17082 temp2 = true;
17083 }
17084 {
17085 PyThreadState* __tstate = wxPyBeginAllowThreads();
17086 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 resultobj = SWIG_From_int(static_cast< int >(result));
17091 {
17092 if (temp2)
17093 delete arg2;
17094 }
17095 return resultobj;
17096 fail:
17097 {
17098 if (temp2)
17099 delete arg2;
17100 }
17101 return NULL;
17102 }
17103
17104
17105 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17106 PyObject *resultobj = 0;
17107 wxImage *arg1 = (wxImage *) 0 ;
17108 wxString *arg2 = 0 ;
17109 bool result;
17110 void *argp1 = 0 ;
17111 int res1 = 0 ;
17112 bool temp2 = false ;
17113 PyObject * obj0 = 0 ;
17114 PyObject * obj1 = 0 ;
17115 char * kwnames[] = {
17116 (char *) "self",(char *) "name", NULL
17117 };
17118
17119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17121 if (!SWIG_IsOK(res1)) {
17122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17123 }
17124 arg1 = reinterpret_cast< wxImage * >(argp1);
17125 {
17126 arg2 = wxString_in_helper(obj1);
17127 if (arg2 == NULL) SWIG_fail;
17128 temp2 = true;
17129 }
17130 {
17131 PyThreadState* __tstate = wxPyBeginAllowThreads();
17132 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17133 wxPyEndAllowThreads(__tstate);
17134 if (PyErr_Occurred()) SWIG_fail;
17135 }
17136 {
17137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17138 }
17139 {
17140 if (temp2)
17141 delete arg2;
17142 }
17143 return resultobj;
17144 fail:
17145 {
17146 if (temp2)
17147 delete arg2;
17148 }
17149 return NULL;
17150 }
17151
17152
17153 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj = 0;
17155 wxImage *arg1 = (wxImage *) 0 ;
17156 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17157 unsigned long result;
17158 void *argp1 = 0 ;
17159 int res1 = 0 ;
17160 unsigned long val2 ;
17161 int ecode2 = 0 ;
17162 PyObject * obj0 = 0 ;
17163 PyObject * obj1 = 0 ;
17164 char * kwnames[] = {
17165 (char *) "self",(char *) "stopafter", NULL
17166 };
17167
17168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17170 if (!SWIG_IsOK(res1)) {
17171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17172 }
17173 arg1 = reinterpret_cast< wxImage * >(argp1);
17174 if (obj1) {
17175 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17176 if (!SWIG_IsOK(ecode2)) {
17177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17178 }
17179 arg2 = static_cast< unsigned long >(val2);
17180 }
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (unsigned long)(arg1)->CountColours(arg2);
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj = 0;
17196 wxImage *arg1 = (wxImage *) 0 ;
17197 wxImageHistogram *arg2 = 0 ;
17198 unsigned long result;
17199 void *argp1 = 0 ;
17200 int res1 = 0 ;
17201 void *argp2 = 0 ;
17202 int res2 = 0 ;
17203 PyObject * obj0 = 0 ;
17204 PyObject * obj1 = 0 ;
17205 char * kwnames[] = {
17206 (char *) "self",(char *) "h", NULL
17207 };
17208
17209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17211 if (!SWIG_IsOK(res1)) {
17212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17213 }
17214 arg1 = reinterpret_cast< wxImage * >(argp1);
17215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17216 if (!SWIG_IsOK(res2)) {
17217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17218 }
17219 if (!argp2) {
17220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17221 }
17222 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17223 {
17224 PyThreadState* __tstate = wxPyBeginAllowThreads();
17225 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17230 return resultobj;
17231 fail:
17232 return NULL;
17233 }
17234
17235
17236 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17237 PyObject *resultobj = 0;
17238 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17239 void *argp1 = 0 ;
17240 int res1 = 0 ;
17241 PyObject * obj0 = 0 ;
17242 char * kwnames[] = {
17243 (char *) "handler", NULL
17244 };
17245
17246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17248 if (!SWIG_IsOK(res1)) {
17249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17250 }
17251 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 wxImage::AddHandler(arg1);
17255 wxPyEndAllowThreads(__tstate);
17256 if (PyErr_Occurred()) SWIG_fail;
17257 }
17258 resultobj = SWIG_Py_Void();
17259 return resultobj;
17260 fail:
17261 return NULL;
17262 }
17263
17264
17265 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17266 PyObject *resultobj = 0;
17267 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17268 void *argp1 = 0 ;
17269 int res1 = 0 ;
17270 PyObject * obj0 = 0 ;
17271 char * kwnames[] = {
17272 (char *) "handler", NULL
17273 };
17274
17275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17277 if (!SWIG_IsOK(res1)) {
17278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17279 }
17280 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17281 {
17282 PyThreadState* __tstate = wxPyBeginAllowThreads();
17283 wxImage::InsertHandler(arg1);
17284 wxPyEndAllowThreads(__tstate);
17285 if (PyErr_Occurred()) SWIG_fail;
17286 }
17287 resultobj = SWIG_Py_Void();
17288 return resultobj;
17289 fail:
17290 return NULL;
17291 }
17292
17293
17294 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17295 PyObject *resultobj = 0;
17296 wxString *arg1 = 0 ;
17297 bool result;
17298 bool temp1 = false ;
17299 PyObject * obj0 = 0 ;
17300 char * kwnames[] = {
17301 (char *) "name", NULL
17302 };
17303
17304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17305 {
17306 arg1 = wxString_in_helper(obj0);
17307 if (arg1 == NULL) SWIG_fail;
17308 temp1 = true;
17309 }
17310 {
17311 PyThreadState* __tstate = wxPyBeginAllowThreads();
17312 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17313 wxPyEndAllowThreads(__tstate);
17314 if (PyErr_Occurred()) SWIG_fail;
17315 }
17316 {
17317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17318 }
17319 {
17320 if (temp1)
17321 delete arg1;
17322 }
17323 return resultobj;
17324 fail:
17325 {
17326 if (temp1)
17327 delete arg1;
17328 }
17329 return NULL;
17330 }
17331
17332
17333 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17334 PyObject *resultobj = 0;
17335 PyObject *result = 0 ;
17336
17337 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17338 {
17339 PyThreadState* __tstate = wxPyBeginAllowThreads();
17340 result = (PyObject *)wxImage_GetHandlers();
17341 wxPyEndAllowThreads(__tstate);
17342 if (PyErr_Occurred()) SWIG_fail;
17343 }
17344 resultobj = result;
17345 return resultobj;
17346 fail:
17347 return NULL;
17348 }
17349
17350
17351 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 PyObject *resultobj = 0;
17353 wxString result;
17354
17355 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = wxImage::GetImageExtWildcard();
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 {
17363 #if wxUSE_UNICODE
17364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17365 #else
17366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17367 #endif
17368 }
17369 return resultobj;
17370 fail:
17371 return NULL;
17372 }
17373
17374
17375 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17376 PyObject *resultobj = 0;
17377 wxImage *arg1 = (wxImage *) 0 ;
17378 int arg2 = (int) -1 ;
17379 wxBitmap result;
17380 void *argp1 = 0 ;
17381 int res1 = 0 ;
17382 int val2 ;
17383 int ecode2 = 0 ;
17384 PyObject * obj0 = 0 ;
17385 PyObject * obj1 = 0 ;
17386 char * kwnames[] = {
17387 (char *) "self",(char *) "depth", NULL
17388 };
17389
17390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17392 if (!SWIG_IsOK(res1)) {
17393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17394 }
17395 arg1 = reinterpret_cast< wxImage * >(argp1);
17396 if (obj1) {
17397 ecode2 = SWIG_AsVal_int(obj1, &val2);
17398 if (!SWIG_IsOK(ecode2)) {
17399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17400 }
17401 arg2 = static_cast< int >(val2);
17402 }
17403 {
17404 if (!wxPyCheckForApp()) SWIG_fail;
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = wxImage_ConvertToBitmap(arg1,arg2);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17411 return resultobj;
17412 fail:
17413 return NULL;
17414 }
17415
17416
17417 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17418 PyObject *resultobj = 0;
17419 wxImage *arg1 = (wxImage *) 0 ;
17420 byte arg2 ;
17421 byte arg3 ;
17422 byte arg4 ;
17423 wxBitmap result;
17424 void *argp1 = 0 ;
17425 int res1 = 0 ;
17426 unsigned char val2 ;
17427 int ecode2 = 0 ;
17428 unsigned char val3 ;
17429 int ecode3 = 0 ;
17430 unsigned char val4 ;
17431 int ecode4 = 0 ;
17432 PyObject * obj0 = 0 ;
17433 PyObject * obj1 = 0 ;
17434 PyObject * obj2 = 0 ;
17435 PyObject * obj3 = 0 ;
17436 char * kwnames[] = {
17437 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17438 };
17439
17440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17442 if (!SWIG_IsOK(res1)) {
17443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17444 }
17445 arg1 = reinterpret_cast< wxImage * >(argp1);
17446 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17447 if (!SWIG_IsOK(ecode2)) {
17448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17449 }
17450 arg2 = static_cast< byte >(val2);
17451 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17452 if (!SWIG_IsOK(ecode3)) {
17453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17454 }
17455 arg3 = static_cast< byte >(val3);
17456 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17457 if (!SWIG_IsOK(ecode4)) {
17458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17459 }
17460 arg4 = static_cast< byte >(val4);
17461 {
17462 if (!wxPyCheckForApp()) SWIG_fail;
17463 PyThreadState* __tstate = wxPyBeginAllowThreads();
17464 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17465 wxPyEndAllowThreads(__tstate);
17466 if (PyErr_Occurred()) SWIG_fail;
17467 }
17468 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17469 return resultobj;
17470 fail:
17471 return NULL;
17472 }
17473
17474
17475 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17476 PyObject *resultobj = 0;
17477 wxImage *arg1 = (wxImage *) 0 ;
17478 double arg2 ;
17479 void *argp1 = 0 ;
17480 int res1 = 0 ;
17481 double val2 ;
17482 int ecode2 = 0 ;
17483 PyObject * obj0 = 0 ;
17484 PyObject * obj1 = 0 ;
17485 char * kwnames[] = {
17486 (char *) "self",(char *) "angle", NULL
17487 };
17488
17489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17491 if (!SWIG_IsOK(res1)) {
17492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17493 }
17494 arg1 = reinterpret_cast< wxImage * >(argp1);
17495 ecode2 = SWIG_AsVal_double(obj1, &val2);
17496 if (!SWIG_IsOK(ecode2)) {
17497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17498 }
17499 arg2 = static_cast< double >(val2);
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 (arg1)->RotateHue(arg2);
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 resultobj = SWIG_Py_Void();
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj = 0;
17515 wxImage_RGBValue arg1 ;
17516 wxImage_HSVValue result;
17517 void *argp1 ;
17518 int res1 = 0 ;
17519 PyObject * obj0 = 0 ;
17520 char * kwnames[] = {
17521 (char *) "rgb", NULL
17522 };
17523
17524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17525 {
17526 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17527 if (!SWIG_IsOK(res1)) {
17528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17529 }
17530 if (!argp1) {
17531 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17532 } else {
17533 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17534 arg1 = *temp;
17535 if (SWIG_IsNewObj(res1)) delete temp;
17536 }
17537 }
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = wxImage::RGBtoHSV(arg1);
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17545 return resultobj;
17546 fail:
17547 return NULL;
17548 }
17549
17550
17551 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17552 PyObject *resultobj = 0;
17553 wxImage_HSVValue arg1 ;
17554 wxImage_RGBValue result;
17555 void *argp1 ;
17556 int res1 = 0 ;
17557 PyObject * obj0 = 0 ;
17558 char * kwnames[] = {
17559 (char *) "hsv", NULL
17560 };
17561
17562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17563 {
17564 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17565 if (!SWIG_IsOK(res1)) {
17566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17567 }
17568 if (!argp1) {
17569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17570 } else {
17571 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17572 arg1 = *temp;
17573 if (SWIG_IsNewObj(res1)) delete temp;
17574 }
17575 }
17576 {
17577 PyThreadState* __tstate = wxPyBeginAllowThreads();
17578 result = wxImage::HSVtoRGB(arg1);
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17583 return resultobj;
17584 fail:
17585 return NULL;
17586 }
17587
17588
17589 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17590 PyObject *obj;
17591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17592 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17593 return SWIG_Py_Void();
17594 }
17595
17596 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17597 return SWIG_Python_InitShadowInstance(args);
17598 }
17599
17600 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17601 PyObject *resultobj = 0;
17602 int arg1 ;
17603 int arg2 ;
17604 buffer arg3 ;
17605 int arg4 ;
17606 buffer arg5 = (buffer) NULL ;
17607 int arg6 = (int) 0 ;
17608 wxImage *result = 0 ;
17609 int val1 ;
17610 int ecode1 = 0 ;
17611 int val2 ;
17612 int ecode2 = 0 ;
17613 Py_ssize_t temp3 ;
17614 Py_ssize_t temp5 ;
17615 PyObject * obj0 = 0 ;
17616 PyObject * obj1 = 0 ;
17617 PyObject * obj2 = 0 ;
17618 PyObject * obj3 = 0 ;
17619 char * kwnames[] = {
17620 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17621 };
17622
17623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17624 ecode1 = SWIG_AsVal_int(obj0, &val1);
17625 if (!SWIG_IsOK(ecode1)) {
17626 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17627 }
17628 arg1 = static_cast< int >(val1);
17629 ecode2 = SWIG_AsVal_int(obj1, &val2);
17630 if (!SWIG_IsOK(ecode2)) {
17631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17632 }
17633 arg2 = static_cast< int >(val2);
17634 {
17635 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17636 arg4 = (int)temp3;
17637 }
17638 if (obj3) {
17639 {
17640 if (obj3 != Py_None) {
17641 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17642 arg6 = (int)temp5;
17643 }
17644 }
17645 }
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 {
17653 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17654 }
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 SWIGINTERN int NullImage_set(PyObject *) {
17662 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17663 return 1;
17664 }
17665
17666
17667 SWIGINTERN PyObject *NullImage_get(void) {
17668 PyObject *pyobj = 0;
17669
17670 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17671 return pyobj;
17672 }
17673
17674
17675 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17676 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17677 return 1;
17678 }
17679
17680
17681 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17682 PyObject *pyobj = 0;
17683
17684 {
17685 #if wxUSE_UNICODE
17686 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17687 #else
17688 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17689 #endif
17690 }
17691 return pyobj;
17692 }
17693
17694
17695 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17696 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17697 return 1;
17698 }
17699
17700
17701 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17702 PyObject *pyobj = 0;
17703
17704 {
17705 #if wxUSE_UNICODE
17706 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17707 #else
17708 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17709 #endif
17710 }
17711 return pyobj;
17712 }
17713
17714
17715 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17716 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17717 return 1;
17718 }
17719
17720
17721 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17722 PyObject *pyobj = 0;
17723
17724 {
17725 #if wxUSE_UNICODE
17726 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17727 #else
17728 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17729 #endif
17730 }
17731 return pyobj;
17732 }
17733
17734
17735 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17736 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17737 return 1;
17738 }
17739
17740
17741 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17742 PyObject *pyobj = 0;
17743
17744 {
17745 #if wxUSE_UNICODE
17746 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17747 #else
17748 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17749 #endif
17750 }
17751 return pyobj;
17752 }
17753
17754
17755 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17756 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17757 return 1;
17758 }
17759
17760
17761 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17762 PyObject *pyobj = 0;
17763
17764 {
17765 #if wxUSE_UNICODE
17766 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17767 #else
17768 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17769 #endif
17770 }
17771 return pyobj;
17772 }
17773
17774
17775 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17776 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17777 return 1;
17778 }
17779
17780
17781 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17782 PyObject *pyobj = 0;
17783
17784 {
17785 #if wxUSE_UNICODE
17786 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17787 #else
17788 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17789 #endif
17790 }
17791 return pyobj;
17792 }
17793
17794
17795 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17796 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17797 return 1;
17798 }
17799
17800
17801 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17802 PyObject *pyobj = 0;
17803
17804 {
17805 #if wxUSE_UNICODE
17806 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17807 #else
17808 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17809 #endif
17810 }
17811 return pyobj;
17812 }
17813
17814
17815 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17816 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17817 return 1;
17818 }
17819
17820
17821 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17822 PyObject *pyobj = 0;
17823
17824 {
17825 #if wxUSE_UNICODE
17826 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17827 #else
17828 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17829 #endif
17830 }
17831 return pyobj;
17832 }
17833
17834
17835 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17836 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17837 return 1;
17838 }
17839
17840
17841 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17842 PyObject *pyobj = 0;
17843
17844 {
17845 #if wxUSE_UNICODE
17846 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17847 #else
17848 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17849 #endif
17850 }
17851 return pyobj;
17852 }
17853
17854
17855 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17856 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17857 return 1;
17858 }
17859
17860
17861 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17862 PyObject *pyobj = 0;
17863
17864 {
17865 #if wxUSE_UNICODE
17866 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17867 #else
17868 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17869 #endif
17870 }
17871 return pyobj;
17872 }
17873
17874
17875 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17876 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17877 return 1;
17878 }
17879
17880
17881 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17882 PyObject *pyobj = 0;
17883
17884 {
17885 #if wxUSE_UNICODE
17886 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17887 #else
17888 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17889 #endif
17890 }
17891 return pyobj;
17892 }
17893
17894
17895 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17896 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17897 return 1;
17898 }
17899
17900
17901 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17902 PyObject *pyobj = 0;
17903
17904 {
17905 #if wxUSE_UNICODE
17906 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17907 #else
17908 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17909 #endif
17910 }
17911 return pyobj;
17912 }
17913
17914
17915 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17916 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17917 return 1;
17918 }
17919
17920
17921 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17922 PyObject *pyobj = 0;
17923
17924 {
17925 #if wxUSE_UNICODE
17926 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17927 #else
17928 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17929 #endif
17930 }
17931 return pyobj;
17932 }
17933
17934
17935 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17936 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17937 return 1;
17938 }
17939
17940
17941 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17942 PyObject *pyobj = 0;
17943
17944 {
17945 #if wxUSE_UNICODE
17946 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17947 #else
17948 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17949 #endif
17950 }
17951 return pyobj;
17952 }
17953
17954
17955 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17956 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17957 return 1;
17958 }
17959
17960
17961 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17962 PyObject *pyobj = 0;
17963
17964 {
17965 #if wxUSE_UNICODE
17966 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17967 #else
17968 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17969 #endif
17970 }
17971 return pyobj;
17972 }
17973
17974
17975 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *resultobj = 0;
17977 wxBMPHandler *result = 0 ;
17978
17979 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 result = (wxBMPHandler *)new wxBMPHandler();
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17994 PyObject *obj;
17995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17996 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17997 return SWIG_Py_Void();
17998 }
17999
18000 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18001 return SWIG_Python_InitShadowInstance(args);
18002 }
18003
18004 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18005 PyObject *resultobj = 0;
18006 wxICOHandler *result = 0 ;
18007
18008 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 result = (wxICOHandler *)new wxICOHandler();
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18023 PyObject *obj;
18024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18025 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18026 return SWIG_Py_Void();
18027 }
18028
18029 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18030 return SWIG_Python_InitShadowInstance(args);
18031 }
18032
18033 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18034 PyObject *resultobj = 0;
18035 wxCURHandler *result = 0 ;
18036
18037 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18038 {
18039 PyThreadState* __tstate = wxPyBeginAllowThreads();
18040 result = (wxCURHandler *)new wxCURHandler();
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18052 PyObject *obj;
18053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18054 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18055 return SWIG_Py_Void();
18056 }
18057
18058 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18059 return SWIG_Python_InitShadowInstance(args);
18060 }
18061
18062 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 wxANIHandler *result = 0 ;
18065
18066 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 result = (wxANIHandler *)new wxANIHandler();
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18081 PyObject *obj;
18082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18083 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18084 return SWIG_Py_Void();
18085 }
18086
18087 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 return SWIG_Python_InitShadowInstance(args);
18089 }
18090
18091 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18092 PyObject *resultobj = 0;
18093 wxPNGHandler *result = 0 ;
18094
18095 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 result = (wxPNGHandler *)new wxPNGHandler();
18099 wxPyEndAllowThreads(__tstate);
18100 if (PyErr_Occurred()) SWIG_fail;
18101 }
18102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18110 PyObject *obj;
18111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18112 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18113 return SWIG_Py_Void();
18114 }
18115
18116 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18117 return SWIG_Python_InitShadowInstance(args);
18118 }
18119
18120 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18121 PyObject *resultobj = 0;
18122 wxGIFHandler *result = 0 ;
18123
18124 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18125 {
18126 PyThreadState* __tstate = wxPyBeginAllowThreads();
18127 result = (wxGIFHandler *)new wxGIFHandler();
18128 wxPyEndAllowThreads(__tstate);
18129 if (PyErr_Occurred()) SWIG_fail;
18130 }
18131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18132 return resultobj;
18133 fail:
18134 return NULL;
18135 }
18136
18137
18138 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18139 PyObject *obj;
18140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18141 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18142 return SWIG_Py_Void();
18143 }
18144
18145 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18146 return SWIG_Python_InitShadowInstance(args);
18147 }
18148
18149 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18150 PyObject *resultobj = 0;
18151 wxPCXHandler *result = 0 ;
18152
18153 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 result = (wxPCXHandler *)new wxPCXHandler();
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18168 PyObject *obj;
18169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18170 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18171 return SWIG_Py_Void();
18172 }
18173
18174 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18175 return SWIG_Python_InitShadowInstance(args);
18176 }
18177
18178 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18179 PyObject *resultobj = 0;
18180 wxJPEGHandler *result = 0 ;
18181
18182 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 result = (wxJPEGHandler *)new wxJPEGHandler();
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18197 PyObject *obj;
18198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18199 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18200 return SWIG_Py_Void();
18201 }
18202
18203 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18204 return SWIG_Python_InitShadowInstance(args);
18205 }
18206
18207 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18208 PyObject *resultobj = 0;
18209 wxPNMHandler *result = 0 ;
18210
18211 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (wxPNMHandler *)new wxPNMHandler();
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18226 PyObject *obj;
18227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18228 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18229 return SWIG_Py_Void();
18230 }
18231
18232 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18233 return SWIG_Python_InitShadowInstance(args);
18234 }
18235
18236 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18237 PyObject *resultobj = 0;
18238 wxXPMHandler *result = 0 ;
18239
18240 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (wxXPMHandler *)new wxXPMHandler();
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18255 PyObject *obj;
18256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18257 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18258 return SWIG_Py_Void();
18259 }
18260
18261 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18262 return SWIG_Python_InitShadowInstance(args);
18263 }
18264
18265 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18266 PyObject *resultobj = 0;
18267 wxTIFFHandler *result = 0 ;
18268
18269 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = (wxTIFFHandler *)new wxTIFFHandler();
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18284 PyObject *obj;
18285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18286 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18287 return SWIG_Py_Void();
18288 }
18289
18290 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18291 return SWIG_Python_InitShadowInstance(args);
18292 }
18293
18294 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj = 0;
18296 wxImage *arg1 = 0 ;
18297 wxImage *arg2 = 0 ;
18298 int arg3 = (int) 236 ;
18299 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18300 bool result;
18301 void *argp1 = 0 ;
18302 int res1 = 0 ;
18303 void *argp2 = 0 ;
18304 int res2 = 0 ;
18305 int val3 ;
18306 int ecode3 = 0 ;
18307 int val4 ;
18308 int ecode4 = 0 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 PyObject * obj2 = 0 ;
18312 PyObject * obj3 = 0 ;
18313 char * kwnames[] = {
18314 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18315 };
18316
18317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18318 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18319 if (!SWIG_IsOK(res1)) {
18320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18321 }
18322 if (!argp1) {
18323 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18324 }
18325 arg1 = reinterpret_cast< wxImage * >(argp1);
18326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18327 if (!SWIG_IsOK(res2)) {
18328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18329 }
18330 if (!argp2) {
18331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18332 }
18333 arg2 = reinterpret_cast< wxImage * >(argp2);
18334 if (obj2) {
18335 ecode3 = SWIG_AsVal_int(obj2, &val3);
18336 if (!SWIG_IsOK(ecode3)) {
18337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18338 }
18339 arg3 = static_cast< int >(val3);
18340 }
18341 if (obj3) {
18342 ecode4 = SWIG_AsVal_int(obj3, &val4);
18343 if (!SWIG_IsOK(ecode4)) {
18344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18345 }
18346 arg4 = static_cast< int >(val4);
18347 }
18348 {
18349 PyThreadState* __tstate = wxPyBeginAllowThreads();
18350 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18351 wxPyEndAllowThreads(__tstate);
18352 if (PyErr_Occurred()) SWIG_fail;
18353 }
18354 {
18355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18356 }
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18364 PyObject *obj;
18365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18366 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18367 return SWIG_Py_Void();
18368 }
18369
18370 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18371 PyObject *resultobj = 0;
18372 wxEvtHandler *result = 0 ;
18373
18374 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = (wxEvtHandler *)new wxEvtHandler();
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18382 return resultobj;
18383 fail:
18384 return NULL;
18385 }
18386
18387
18388 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18389 PyObject *resultobj = 0;
18390 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18391 wxEvtHandler *result = 0 ;
18392 void *argp1 = 0 ;
18393 int res1 = 0 ;
18394 PyObject *swig_obj[1] ;
18395
18396 if (!args) SWIG_fail;
18397 swig_obj[0] = args;
18398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18399 if (!SWIG_IsOK(res1)) {
18400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18401 }
18402 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18403 {
18404 PyThreadState* __tstate = wxPyBeginAllowThreads();
18405 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18406 wxPyEndAllowThreads(__tstate);
18407 if (PyErr_Occurred()) SWIG_fail;
18408 }
18409 {
18410 resultobj = wxPyMake_wxObject(result, 0);
18411 }
18412 return resultobj;
18413 fail:
18414 return NULL;
18415 }
18416
18417
18418 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18419 PyObject *resultobj = 0;
18420 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18421 wxEvtHandler *result = 0 ;
18422 void *argp1 = 0 ;
18423 int res1 = 0 ;
18424 PyObject *swig_obj[1] ;
18425
18426 if (!args) SWIG_fail;
18427 swig_obj[0] = args;
18428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18429 if (!SWIG_IsOK(res1)) {
18430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18431 }
18432 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 {
18440 resultobj = wxPyMake_wxObject(result, 0);
18441 }
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj = 0;
18450 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18451 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18452 void *argp1 = 0 ;
18453 int res1 = 0 ;
18454 void *argp2 = 0 ;
18455 int res2 = 0 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char * kwnames[] = {
18459 (char *) "self",(char *) "handler", NULL
18460 };
18461
18462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18464 if (!SWIG_IsOK(res1)) {
18465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18466 }
18467 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18468 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18469 if (!SWIG_IsOK(res2)) {
18470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18471 }
18472 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18473 {
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 (arg1)->SetNextHandler(arg2);
18476 wxPyEndAllowThreads(__tstate);
18477 if (PyErr_Occurred()) SWIG_fail;
18478 }
18479 resultobj = SWIG_Py_Void();
18480 return resultobj;
18481 fail:
18482 return NULL;
18483 }
18484
18485
18486 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18487 PyObject *resultobj = 0;
18488 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18489 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18490 void *argp1 = 0 ;
18491 int res1 = 0 ;
18492 void *argp2 = 0 ;
18493 int res2 = 0 ;
18494 PyObject * obj0 = 0 ;
18495 PyObject * obj1 = 0 ;
18496 char * kwnames[] = {
18497 (char *) "self",(char *) "handler", NULL
18498 };
18499
18500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18502 if (!SWIG_IsOK(res1)) {
18503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18504 }
18505 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18506 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18507 if (!SWIG_IsOK(res2)) {
18508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18509 }
18510 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18511 {
18512 PyThreadState* __tstate = wxPyBeginAllowThreads();
18513 (arg1)->SetPreviousHandler(arg2);
18514 wxPyEndAllowThreads(__tstate);
18515 if (PyErr_Occurred()) SWIG_fail;
18516 }
18517 resultobj = SWIG_Py_Void();
18518 return resultobj;
18519 fail:
18520 return NULL;
18521 }
18522
18523
18524 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18525 PyObject *resultobj = 0;
18526 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18527 bool result;
18528 void *argp1 = 0 ;
18529 int res1 = 0 ;
18530 PyObject *swig_obj[1] ;
18531
18532 if (!args) SWIG_fail;
18533 swig_obj[0] = args;
18534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18535 if (!SWIG_IsOK(res1)) {
18536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18537 }
18538 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = (bool)(arg1)->GetEvtHandlerEnabled();
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 {
18546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18547 }
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18555 PyObject *resultobj = 0;
18556 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18557 bool arg2 ;
18558 void *argp1 = 0 ;
18559 int res1 = 0 ;
18560 bool val2 ;
18561 int ecode2 = 0 ;
18562 PyObject * obj0 = 0 ;
18563 PyObject * obj1 = 0 ;
18564 char * kwnames[] = {
18565 (char *) "self",(char *) "enabled", NULL
18566 };
18567
18568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18570 if (!SWIG_IsOK(res1)) {
18571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18572 }
18573 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18575 if (!SWIG_IsOK(ecode2)) {
18576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18577 }
18578 arg2 = static_cast< bool >(val2);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 (arg1)->SetEvtHandlerEnabled(arg2);
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 resultobj = SWIG_Py_Void();
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18593 PyObject *resultobj = 0;
18594 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18595 wxEvent *arg2 = 0 ;
18596 bool result;
18597 void *argp1 = 0 ;
18598 int res1 = 0 ;
18599 void *argp2 = 0 ;
18600 int res2 = 0 ;
18601 PyObject * obj0 = 0 ;
18602 PyObject * obj1 = 0 ;
18603 char * kwnames[] = {
18604 (char *) "self",(char *) "event", NULL
18605 };
18606
18607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18609 if (!SWIG_IsOK(res1)) {
18610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18611 }
18612 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18614 if (!SWIG_IsOK(res2)) {
18615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18616 }
18617 if (!argp2) {
18618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18619 }
18620 arg2 = reinterpret_cast< wxEvent * >(argp2);
18621 {
18622 PyThreadState* __tstate = wxPyBeginAllowThreads();
18623 result = (bool)(arg1)->ProcessEvent(*arg2);
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 {
18628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18629 }
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj = 0;
18638 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18639 wxEvent *arg2 = 0 ;
18640 void *argp1 = 0 ;
18641 int res1 = 0 ;
18642 void *argp2 = 0 ;
18643 int res2 = 0 ;
18644 PyObject * obj0 = 0 ;
18645 PyObject * obj1 = 0 ;
18646 char * kwnames[] = {
18647 (char *) "self",(char *) "event", NULL
18648 };
18649
18650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18652 if (!SWIG_IsOK(res1)) {
18653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18654 }
18655 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18657 if (!SWIG_IsOK(res2)) {
18658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18659 }
18660 if (!argp2) {
18661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18662 }
18663 arg2 = reinterpret_cast< wxEvent * >(argp2);
18664 {
18665 PyThreadState* __tstate = wxPyBeginAllowThreads();
18666 (arg1)->AddPendingEvent(*arg2);
18667 wxPyEndAllowThreads(__tstate);
18668 if (PyErr_Occurred()) SWIG_fail;
18669 }
18670 resultobj = SWIG_Py_Void();
18671 return resultobj;
18672 fail:
18673 return NULL;
18674 }
18675
18676
18677 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18678 PyObject *resultobj = 0;
18679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18680 void *argp1 = 0 ;
18681 int res1 = 0 ;
18682 PyObject *swig_obj[1] ;
18683
18684 if (!args) SWIG_fail;
18685 swig_obj[0] = args;
18686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18687 if (!SWIG_IsOK(res1)) {
18688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18689 }
18690 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18691 {
18692 PyThreadState* __tstate = wxPyBeginAllowThreads();
18693 (arg1)->ProcessPendingEvents();
18694 wxPyEndAllowThreads(__tstate);
18695 if (PyErr_Occurred()) SWIG_fail;
18696 }
18697 resultobj = SWIG_Py_Void();
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj = 0;
18706 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18707 bool arg2 = (bool) true ;
18708 void *argp1 = 0 ;
18709 int res1 = 0 ;
18710 bool val2 ;
18711 int ecode2 = 0 ;
18712 PyObject * obj0 = 0 ;
18713 PyObject * obj1 = 0 ;
18714 char * kwnames[] = {
18715 (char *) "self",(char *) "allow", NULL
18716 };
18717
18718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18720 if (!SWIG_IsOK(res1)) {
18721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18722 }
18723 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18724 if (obj1) {
18725 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18726 if (!SWIG_IsOK(ecode2)) {
18727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18728 }
18729 arg2 = static_cast< bool >(val2);
18730 }
18731 {
18732 PyThreadState* __tstate = wxPyBeginAllowThreads();
18733 (arg1)->AllowReentrance(arg2);
18734 wxPyEndAllowThreads(__tstate);
18735 if (PyErr_Occurred()) SWIG_fail;
18736 }
18737 resultobj = SWIG_Py_Void();
18738 return resultobj;
18739 fail:
18740 return NULL;
18741 }
18742
18743
18744 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18745 PyObject *resultobj = 0;
18746 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18747 bool result;
18748 void *argp1 = 0 ;
18749 int res1 = 0 ;
18750 PyObject *swig_obj[1] ;
18751
18752 if (!args) SWIG_fail;
18753 swig_obj[0] = args;
18754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18755 if (!SWIG_IsOK(res1)) {
18756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18757 }
18758 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18759 {
18760 PyThreadState* __tstate = wxPyBeginAllowThreads();
18761 result = (bool)(arg1)->IsReentranceAllowed();
18762 wxPyEndAllowThreads(__tstate);
18763 if (PyErr_Occurred()) SWIG_fail;
18764 }
18765 {
18766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18767 }
18768 return resultobj;
18769 fail:
18770 return NULL;
18771 }
18772
18773
18774 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18775 PyObject *resultobj = 0;
18776 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18777 bool result;
18778 void *argp1 = 0 ;
18779 int res1 = 0 ;
18780 PyObject *swig_obj[1] ;
18781
18782 if (!args) SWIG_fail;
18783 swig_obj[0] = args;
18784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18785 if (!SWIG_IsOK(res1)) {
18786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18787 }
18788 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18789 {
18790 PyThreadState* __tstate = wxPyBeginAllowThreads();
18791 result = (bool)(arg1)->IsEventHandlingInProgress();
18792 wxPyEndAllowThreads(__tstate);
18793 if (PyErr_Occurred()) SWIG_fail;
18794 }
18795 {
18796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18797 }
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj = 0;
18806 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18807 int arg2 ;
18808 int arg3 ;
18809 int arg4 ;
18810 PyObject *arg5 = (PyObject *) 0 ;
18811 void *argp1 = 0 ;
18812 int res1 = 0 ;
18813 int val2 ;
18814 int ecode2 = 0 ;
18815 int val3 ;
18816 int ecode3 = 0 ;
18817 int val4 ;
18818 int ecode4 = 0 ;
18819 PyObject * obj0 = 0 ;
18820 PyObject * obj1 = 0 ;
18821 PyObject * obj2 = 0 ;
18822 PyObject * obj3 = 0 ;
18823 PyObject * obj4 = 0 ;
18824 char * kwnames[] = {
18825 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18826 };
18827
18828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18830 if (!SWIG_IsOK(res1)) {
18831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18832 }
18833 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18834 ecode2 = SWIG_AsVal_int(obj1, &val2);
18835 if (!SWIG_IsOK(ecode2)) {
18836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18837 }
18838 arg2 = static_cast< int >(val2);
18839 ecode3 = SWIG_AsVal_int(obj2, &val3);
18840 if (!SWIG_IsOK(ecode3)) {
18841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18842 }
18843 arg3 = static_cast< int >(val3);
18844 ecode4 = SWIG_AsVal_int(obj3, &val4);
18845 if (!SWIG_IsOK(ecode4)) {
18846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18847 }
18848 arg4 = static_cast< int >(val4);
18849 arg5 = obj4;
18850 {
18851 PyThreadState* __tstate = wxPyBeginAllowThreads();
18852 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18853 wxPyEndAllowThreads(__tstate);
18854 if (PyErr_Occurred()) SWIG_fail;
18855 }
18856 resultobj = SWIG_Py_Void();
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj = 0;
18865 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18866 int arg2 ;
18867 int arg3 = (int) -1 ;
18868 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18869 bool result;
18870 void *argp1 = 0 ;
18871 int res1 = 0 ;
18872 int val2 ;
18873 int ecode2 = 0 ;
18874 int val3 ;
18875 int ecode3 = 0 ;
18876 int val4 ;
18877 int ecode4 = 0 ;
18878 PyObject * obj0 = 0 ;
18879 PyObject * obj1 = 0 ;
18880 PyObject * obj2 = 0 ;
18881 PyObject * obj3 = 0 ;
18882 char * kwnames[] = {
18883 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18884 };
18885
18886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18888 if (!SWIG_IsOK(res1)) {
18889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18890 }
18891 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18892 ecode2 = SWIG_AsVal_int(obj1, &val2);
18893 if (!SWIG_IsOK(ecode2)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18895 }
18896 arg2 = static_cast< int >(val2);
18897 if (obj2) {
18898 ecode3 = SWIG_AsVal_int(obj2, &val3);
18899 if (!SWIG_IsOK(ecode3)) {
18900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18901 }
18902 arg3 = static_cast< int >(val3);
18903 }
18904 if (obj3) {
18905 ecode4 = SWIG_AsVal_int(obj3, &val4);
18906 if (!SWIG_IsOK(ecode4)) {
18907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18908 }
18909 arg4 = static_cast< wxEventType >(val4);
18910 }
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18914 wxPyEndAllowThreads(__tstate);
18915 if (PyErr_Occurred()) SWIG_fail;
18916 }
18917 {
18918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18919 }
18920 return resultobj;
18921 fail:
18922 return NULL;
18923 }
18924
18925
18926 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18927 PyObject *resultobj = 0;
18928 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18929 PyObject *arg2 = (PyObject *) 0 ;
18930 bool arg3 = (bool) true ;
18931 void *argp1 = 0 ;
18932 int res1 = 0 ;
18933 bool val3 ;
18934 int ecode3 = 0 ;
18935 PyObject * obj0 = 0 ;
18936 PyObject * obj1 = 0 ;
18937 PyObject * obj2 = 0 ;
18938 char * kwnames[] = {
18939 (char *) "self",(char *) "_self",(char *) "incref", NULL
18940 };
18941
18942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18946 }
18947 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18948 arg2 = obj1;
18949 if (obj2) {
18950 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18951 if (!SWIG_IsOK(ecode3)) {
18952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18953 }
18954 arg3 = static_cast< bool >(val3);
18955 }
18956 {
18957 PyThreadState* __tstate = wxPyBeginAllowThreads();
18958 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 resultobj = SWIG_Py_Void();
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18970 PyObject *obj;
18971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18972 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18973 return SWIG_Py_Void();
18974 }
18975
18976 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18977 return SWIG_Python_InitShadowInstance(args);
18978 }
18979
18980 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18981 PyObject *resultobj = 0;
18982 wxEventType result;
18983
18984 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18985 {
18986 PyThreadState* __tstate = wxPyBeginAllowThreads();
18987 result = (wxEventType)wxNewEventType();
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 resultobj = SWIG_From_int(static_cast< int >(result));
18992 return resultobj;
18993 fail:
18994 return NULL;
18995 }
18996
18997
18998 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18999 PyObject *resultobj = 0;
19000 wxEvent *arg1 = (wxEvent *) 0 ;
19001 void *argp1 = 0 ;
19002 int res1 = 0 ;
19003 PyObject *swig_obj[1] ;
19004
19005 if (!args) SWIG_fail;
19006 swig_obj[0] = args;
19007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
19008 if (!SWIG_IsOK(res1)) {
19009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
19010 }
19011 arg1 = reinterpret_cast< wxEvent * >(argp1);
19012 {
19013 PyThreadState* __tstate = wxPyBeginAllowThreads();
19014 delete arg1;
19015
19016 wxPyEndAllowThreads(__tstate);
19017 if (PyErr_Occurred()) SWIG_fail;
19018 }
19019 resultobj = SWIG_Py_Void();
19020 return resultobj;
19021 fail:
19022 return NULL;
19023 }
19024
19025
19026 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj = 0;
19028 wxEvent *arg1 = (wxEvent *) 0 ;
19029 wxEventType arg2 ;
19030 void *argp1 = 0 ;
19031 int res1 = 0 ;
19032 int val2 ;
19033 int ecode2 = 0 ;
19034 PyObject * obj0 = 0 ;
19035 PyObject * obj1 = 0 ;
19036 char * kwnames[] = {
19037 (char *) "self",(char *) "typ", NULL
19038 };
19039
19040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19042 if (!SWIG_IsOK(res1)) {
19043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19044 }
19045 arg1 = reinterpret_cast< wxEvent * >(argp1);
19046 ecode2 = SWIG_AsVal_int(obj1, &val2);
19047 if (!SWIG_IsOK(ecode2)) {
19048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19049 }
19050 arg2 = static_cast< wxEventType >(val2);
19051 {
19052 PyThreadState* __tstate = wxPyBeginAllowThreads();
19053 (arg1)->SetEventType(arg2);
19054 wxPyEndAllowThreads(__tstate);
19055 if (PyErr_Occurred()) SWIG_fail;
19056 }
19057 resultobj = SWIG_Py_Void();
19058 return resultobj;
19059 fail:
19060 return NULL;
19061 }
19062
19063
19064 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19065 PyObject *resultobj = 0;
19066 wxEvent *arg1 = (wxEvent *) 0 ;
19067 wxEventType result;
19068 void *argp1 = 0 ;
19069 int res1 = 0 ;
19070 PyObject *swig_obj[1] ;
19071
19072 if (!args) SWIG_fail;
19073 swig_obj[0] = args;
19074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19075 if (!SWIG_IsOK(res1)) {
19076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19077 }
19078 arg1 = reinterpret_cast< wxEvent * >(argp1);
19079 {
19080 PyThreadState* __tstate = wxPyBeginAllowThreads();
19081 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19082 wxPyEndAllowThreads(__tstate);
19083 if (PyErr_Occurred()) SWIG_fail;
19084 }
19085 resultobj = SWIG_From_int(static_cast< int >(result));
19086 return resultobj;
19087 fail:
19088 return NULL;
19089 }
19090
19091
19092 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19093 PyObject *resultobj = 0;
19094 wxEvent *arg1 = (wxEvent *) 0 ;
19095 wxObject *result = 0 ;
19096 void *argp1 = 0 ;
19097 int res1 = 0 ;
19098 PyObject *swig_obj[1] ;
19099
19100 if (!args) SWIG_fail;
19101 swig_obj[0] = args;
19102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19103 if (!SWIG_IsOK(res1)) {
19104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19105 }
19106 arg1 = reinterpret_cast< wxEvent * >(argp1);
19107 {
19108 PyThreadState* __tstate = wxPyBeginAllowThreads();
19109 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19110 wxPyEndAllowThreads(__tstate);
19111 if (PyErr_Occurred()) SWIG_fail;
19112 }
19113 {
19114 resultobj = wxPyMake_wxObject(result, (bool)0);
19115 }
19116 return resultobj;
19117 fail:
19118 return NULL;
19119 }
19120
19121
19122 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19123 PyObject *resultobj = 0;
19124 wxEvent *arg1 = (wxEvent *) 0 ;
19125 wxObject *arg2 = (wxObject *) 0 ;
19126 void *argp1 = 0 ;
19127 int res1 = 0 ;
19128 void *argp2 = 0 ;
19129 int res2 = 0 ;
19130 PyObject * obj0 = 0 ;
19131 PyObject * obj1 = 0 ;
19132 char * kwnames[] = {
19133 (char *) "self",(char *) "obj", NULL
19134 };
19135
19136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19138 if (!SWIG_IsOK(res1)) {
19139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19140 }
19141 arg1 = reinterpret_cast< wxEvent * >(argp1);
19142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19143 if (!SWIG_IsOK(res2)) {
19144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19145 }
19146 arg2 = reinterpret_cast< wxObject * >(argp2);
19147 {
19148 PyThreadState* __tstate = wxPyBeginAllowThreads();
19149 (arg1)->SetEventObject(arg2);
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 resultobj = SWIG_Py_Void();
19154 return resultobj;
19155 fail:
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19161 PyObject *resultobj = 0;
19162 wxEvent *arg1 = (wxEvent *) 0 ;
19163 long result;
19164 void *argp1 = 0 ;
19165 int res1 = 0 ;
19166 PyObject *swig_obj[1] ;
19167
19168 if (!args) SWIG_fail;
19169 swig_obj[0] = args;
19170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19171 if (!SWIG_IsOK(res1)) {
19172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19173 }
19174 arg1 = reinterpret_cast< wxEvent * >(argp1);
19175 {
19176 PyThreadState* __tstate = wxPyBeginAllowThreads();
19177 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 resultobj = SWIG_From_long(static_cast< long >(result));
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19189 PyObject *resultobj = 0;
19190 wxEvent *arg1 = (wxEvent *) 0 ;
19191 long arg2 = (long) 0 ;
19192 void *argp1 = 0 ;
19193 int res1 = 0 ;
19194 long val2 ;
19195 int ecode2 = 0 ;
19196 PyObject * obj0 = 0 ;
19197 PyObject * obj1 = 0 ;
19198 char * kwnames[] = {
19199 (char *) "self",(char *) "ts", NULL
19200 };
19201
19202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19204 if (!SWIG_IsOK(res1)) {
19205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19206 }
19207 arg1 = reinterpret_cast< wxEvent * >(argp1);
19208 if (obj1) {
19209 ecode2 = SWIG_AsVal_long(obj1, &val2);
19210 if (!SWIG_IsOK(ecode2)) {
19211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19212 }
19213 arg2 = static_cast< long >(val2);
19214 }
19215 {
19216 PyThreadState* __tstate = wxPyBeginAllowThreads();
19217 (arg1)->SetTimestamp(arg2);
19218 wxPyEndAllowThreads(__tstate);
19219 if (PyErr_Occurred()) SWIG_fail;
19220 }
19221 resultobj = SWIG_Py_Void();
19222 return resultobj;
19223 fail:
19224 return NULL;
19225 }
19226
19227
19228 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19229 PyObject *resultobj = 0;
19230 wxEvent *arg1 = (wxEvent *) 0 ;
19231 int result;
19232 void *argp1 = 0 ;
19233 int res1 = 0 ;
19234 PyObject *swig_obj[1] ;
19235
19236 if (!args) SWIG_fail;
19237 swig_obj[0] = args;
19238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19239 if (!SWIG_IsOK(res1)) {
19240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19241 }
19242 arg1 = reinterpret_cast< wxEvent * >(argp1);
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (int)((wxEvent const *)arg1)->GetId();
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = SWIG_From_int(static_cast< int >(result));
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19257 PyObject *resultobj = 0;
19258 wxEvent *arg1 = (wxEvent *) 0 ;
19259 int arg2 ;
19260 void *argp1 = 0 ;
19261 int res1 = 0 ;
19262 int val2 ;
19263 int ecode2 = 0 ;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 char * kwnames[] = {
19267 (char *) "self",(char *) "Id", NULL
19268 };
19269
19270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19272 if (!SWIG_IsOK(res1)) {
19273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19274 }
19275 arg1 = reinterpret_cast< wxEvent * >(argp1);
19276 ecode2 = SWIG_AsVal_int(obj1, &val2);
19277 if (!SWIG_IsOK(ecode2)) {
19278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19279 }
19280 arg2 = static_cast< int >(val2);
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 (arg1)->SetId(arg2);
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 resultobj = SWIG_Py_Void();
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19295 PyObject *resultobj = 0;
19296 wxEvent *arg1 = (wxEvent *) 0 ;
19297 bool result;
19298 void *argp1 = 0 ;
19299 int res1 = 0 ;
19300 PyObject *swig_obj[1] ;
19301
19302 if (!args) SWIG_fail;
19303 swig_obj[0] = args;
19304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19305 if (!SWIG_IsOK(res1)) {
19306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19307 }
19308 arg1 = reinterpret_cast< wxEvent * >(argp1);
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 {
19316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19317 }
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19325 PyObject *resultobj = 0;
19326 wxEvent *arg1 = (wxEvent *) 0 ;
19327 bool arg2 = (bool) true ;
19328 void *argp1 = 0 ;
19329 int res1 = 0 ;
19330 bool val2 ;
19331 int ecode2 = 0 ;
19332 PyObject * obj0 = 0 ;
19333 PyObject * obj1 = 0 ;
19334 char * kwnames[] = {
19335 (char *) "self",(char *) "skip", NULL
19336 };
19337
19338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19340 if (!SWIG_IsOK(res1)) {
19341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19342 }
19343 arg1 = reinterpret_cast< wxEvent * >(argp1);
19344 if (obj1) {
19345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19346 if (!SWIG_IsOK(ecode2)) {
19347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19348 }
19349 arg2 = static_cast< bool >(val2);
19350 }
19351 {
19352 PyThreadState* __tstate = wxPyBeginAllowThreads();
19353 (arg1)->Skip(arg2);
19354 wxPyEndAllowThreads(__tstate);
19355 if (PyErr_Occurred()) SWIG_fail;
19356 }
19357 resultobj = SWIG_Py_Void();
19358 return resultobj;
19359 fail:
19360 return NULL;
19361 }
19362
19363
19364 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19365 PyObject *resultobj = 0;
19366 wxEvent *arg1 = (wxEvent *) 0 ;
19367 bool result;
19368 void *argp1 = 0 ;
19369 int res1 = 0 ;
19370 PyObject *swig_obj[1] ;
19371
19372 if (!args) SWIG_fail;
19373 swig_obj[0] = args;
19374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19375 if (!SWIG_IsOK(res1)) {
19376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19377 }
19378 arg1 = reinterpret_cast< wxEvent * >(argp1);
19379 {
19380 PyThreadState* __tstate = wxPyBeginAllowThreads();
19381 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19382 wxPyEndAllowThreads(__tstate);
19383 if (PyErr_Occurred()) SWIG_fail;
19384 }
19385 {
19386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19387 }
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19395 PyObject *resultobj = 0;
19396 wxEvent *arg1 = (wxEvent *) 0 ;
19397 bool result;
19398 void *argp1 = 0 ;
19399 int res1 = 0 ;
19400 PyObject *swig_obj[1] ;
19401
19402 if (!args) SWIG_fail;
19403 swig_obj[0] = args;
19404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19405 if (!SWIG_IsOK(res1)) {
19406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19407 }
19408 arg1 = reinterpret_cast< wxEvent * >(argp1);
19409 {
19410 PyThreadState* __tstate = wxPyBeginAllowThreads();
19411 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19412 wxPyEndAllowThreads(__tstate);
19413 if (PyErr_Occurred()) SWIG_fail;
19414 }
19415 {
19416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19417 }
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19425 PyObject *resultobj = 0;
19426 wxEvent *arg1 = (wxEvent *) 0 ;
19427 int result;
19428 void *argp1 = 0 ;
19429 int res1 = 0 ;
19430 PyObject *swig_obj[1] ;
19431
19432 if (!args) SWIG_fail;
19433 swig_obj[0] = args;
19434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19435 if (!SWIG_IsOK(res1)) {
19436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19437 }
19438 arg1 = reinterpret_cast< wxEvent * >(argp1);
19439 {
19440 PyThreadState* __tstate = wxPyBeginAllowThreads();
19441 result = (int)(arg1)->StopPropagation();
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 resultobj = SWIG_From_int(static_cast< int >(result));
19446 return resultobj;
19447 fail:
19448 return NULL;
19449 }
19450
19451
19452 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj = 0;
19454 wxEvent *arg1 = (wxEvent *) 0 ;
19455 int arg2 ;
19456 void *argp1 = 0 ;
19457 int res1 = 0 ;
19458 int val2 ;
19459 int ecode2 = 0 ;
19460 PyObject * obj0 = 0 ;
19461 PyObject * obj1 = 0 ;
19462 char * kwnames[] = {
19463 (char *) "self",(char *) "propagationLevel", NULL
19464 };
19465
19466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19468 if (!SWIG_IsOK(res1)) {
19469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19470 }
19471 arg1 = reinterpret_cast< wxEvent * >(argp1);
19472 ecode2 = SWIG_AsVal_int(obj1, &val2);
19473 if (!SWIG_IsOK(ecode2)) {
19474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19475 }
19476 arg2 = static_cast< int >(val2);
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 (arg1)->ResumePropagation(arg2);
19480 wxPyEndAllowThreads(__tstate);
19481 if (PyErr_Occurred()) SWIG_fail;
19482 }
19483 resultobj = SWIG_Py_Void();
19484 return resultobj;
19485 fail:
19486 return NULL;
19487 }
19488
19489
19490 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19491 PyObject *resultobj = 0;
19492 wxEvent *arg1 = (wxEvent *) 0 ;
19493 wxEvent *result = 0 ;
19494 void *argp1 = 0 ;
19495 int res1 = 0 ;
19496 PyObject *swig_obj[1] ;
19497
19498 if (!args) SWIG_fail;
19499 swig_obj[0] = args;
19500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19501 if (!SWIG_IsOK(res1)) {
19502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19503 }
19504 arg1 = reinterpret_cast< wxEvent * >(argp1);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 result = (wxEvent *)(arg1)->Clone();
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19519 PyObject *obj;
19520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19521 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19522 return SWIG_Py_Void();
19523 }
19524
19525 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19526 PyObject *resultobj = 0;
19527 wxEvent *arg1 = 0 ;
19528 wxPropagationDisabler *result = 0 ;
19529 void *argp1 = 0 ;
19530 int res1 = 0 ;
19531 PyObject * obj0 = 0 ;
19532 char * kwnames[] = {
19533 (char *) "event", NULL
19534 };
19535
19536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19537 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19538 if (!SWIG_IsOK(res1)) {
19539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19540 }
19541 if (!argp1) {
19542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19543 }
19544 arg1 = reinterpret_cast< wxEvent * >(argp1);
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19548 wxPyEndAllowThreads(__tstate);
19549 if (PyErr_Occurred()) SWIG_fail;
19550 }
19551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19559 PyObject *resultobj = 0;
19560 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19561 void *argp1 = 0 ;
19562 int res1 = 0 ;
19563 PyObject *swig_obj[1] ;
19564
19565 if (!args) SWIG_fail;
19566 swig_obj[0] = args;
19567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19568 if (!SWIG_IsOK(res1)) {
19569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19570 }
19571 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19572 {
19573 PyThreadState* __tstate = wxPyBeginAllowThreads();
19574 delete arg1;
19575
19576 wxPyEndAllowThreads(__tstate);
19577 if (PyErr_Occurred()) SWIG_fail;
19578 }
19579 resultobj = SWIG_Py_Void();
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19587 PyObject *obj;
19588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19589 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19590 return SWIG_Py_Void();
19591 }
19592
19593 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19594 return SWIG_Python_InitShadowInstance(args);
19595 }
19596
19597 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19598 PyObject *resultobj = 0;
19599 wxEvent *arg1 = 0 ;
19600 wxPropagateOnce *result = 0 ;
19601 void *argp1 = 0 ;
19602 int res1 = 0 ;
19603 PyObject * obj0 = 0 ;
19604 char * kwnames[] = {
19605 (char *) "event", NULL
19606 };
19607
19608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19609 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19610 if (!SWIG_IsOK(res1)) {
19611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19612 }
19613 if (!argp1) {
19614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19615 }
19616 arg1 = reinterpret_cast< wxEvent * >(argp1);
19617 {
19618 PyThreadState* __tstate = wxPyBeginAllowThreads();
19619 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19620 wxPyEndAllowThreads(__tstate);
19621 if (PyErr_Occurred()) SWIG_fail;
19622 }
19623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19624 return resultobj;
19625 fail:
19626 return NULL;
19627 }
19628
19629
19630 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19631 PyObject *resultobj = 0;
19632 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 PyObject *swig_obj[1] ;
19636
19637 if (!args) SWIG_fail;
19638 swig_obj[0] = args;
19639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19640 if (!SWIG_IsOK(res1)) {
19641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19642 }
19643 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19644 {
19645 PyThreadState* __tstate = wxPyBeginAllowThreads();
19646 delete arg1;
19647
19648 wxPyEndAllowThreads(__tstate);
19649 if (PyErr_Occurred()) SWIG_fail;
19650 }
19651 resultobj = SWIG_Py_Void();
19652 return resultobj;
19653 fail:
19654 return NULL;
19655 }
19656
19657
19658 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19659 PyObject *obj;
19660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19661 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19662 return SWIG_Py_Void();
19663 }
19664
19665 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19666 return SWIG_Python_InitShadowInstance(args);
19667 }
19668
19669 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj = 0;
19671 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19672 int arg2 = (int) 0 ;
19673 wxCommandEvent *result = 0 ;
19674 int val1 ;
19675 int ecode1 = 0 ;
19676 int val2 ;
19677 int ecode2 = 0 ;
19678 PyObject * obj0 = 0 ;
19679 PyObject * obj1 = 0 ;
19680 char * kwnames[] = {
19681 (char *) "commandType",(char *) "winid", NULL
19682 };
19683
19684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19685 if (obj0) {
19686 ecode1 = SWIG_AsVal_int(obj0, &val1);
19687 if (!SWIG_IsOK(ecode1)) {
19688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19689 }
19690 arg1 = static_cast< wxEventType >(val1);
19691 }
19692 if (obj1) {
19693 ecode2 = SWIG_AsVal_int(obj1, &val2);
19694 if (!SWIG_IsOK(ecode2)) {
19695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19696 }
19697 arg2 = static_cast< int >(val2);
19698 }
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19702 wxPyEndAllowThreads(__tstate);
19703 if (PyErr_Occurred()) SWIG_fail;
19704 }
19705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19713 PyObject *resultobj = 0;
19714 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19715 int result;
19716 void *argp1 = 0 ;
19717 int res1 = 0 ;
19718 PyObject *swig_obj[1] ;
19719
19720 if (!args) SWIG_fail;
19721 swig_obj[0] = args;
19722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19725 }
19726 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = SWIG_From_int(static_cast< int >(result));
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19741 PyObject *resultobj = 0;
19742 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19743 wxString *arg2 = 0 ;
19744 void *argp1 = 0 ;
19745 int res1 = 0 ;
19746 bool temp2 = false ;
19747 PyObject * obj0 = 0 ;
19748 PyObject * obj1 = 0 ;
19749 char * kwnames[] = {
19750 (char *) "self",(char *) "s", NULL
19751 };
19752
19753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19755 if (!SWIG_IsOK(res1)) {
19756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19757 }
19758 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19759 {
19760 arg2 = wxString_in_helper(obj1);
19761 if (arg2 == NULL) SWIG_fail;
19762 temp2 = true;
19763 }
19764 {
19765 PyThreadState* __tstate = wxPyBeginAllowThreads();
19766 (arg1)->SetString((wxString const &)*arg2);
19767 wxPyEndAllowThreads(__tstate);
19768 if (PyErr_Occurred()) SWIG_fail;
19769 }
19770 resultobj = SWIG_Py_Void();
19771 {
19772 if (temp2)
19773 delete arg2;
19774 }
19775 return resultobj;
19776 fail:
19777 {
19778 if (temp2)
19779 delete arg2;
19780 }
19781 return NULL;
19782 }
19783
19784
19785 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19786 PyObject *resultobj = 0;
19787 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19788 wxString result;
19789 void *argp1 = 0 ;
19790 int res1 = 0 ;
19791 PyObject *swig_obj[1] ;
19792
19793 if (!args) SWIG_fail;
19794 swig_obj[0] = args;
19795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19796 if (!SWIG_IsOK(res1)) {
19797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19798 }
19799 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = ((wxCommandEvent const *)arg1)->GetString();
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 {
19807 #if wxUSE_UNICODE
19808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19809 #else
19810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19811 #endif
19812 }
19813 return resultobj;
19814 fail:
19815 return NULL;
19816 }
19817
19818
19819 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19820 PyObject *resultobj = 0;
19821 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19822 bool result;
19823 void *argp1 = 0 ;
19824 int res1 = 0 ;
19825 PyObject *swig_obj[1] ;
19826
19827 if (!args) SWIG_fail;
19828 swig_obj[0] = args;
19829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19830 if (!SWIG_IsOK(res1)) {
19831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19832 }
19833 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19850 PyObject *resultobj = 0;
19851 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19852 bool result;
19853 void *argp1 = 0 ;
19854 int res1 = 0 ;
19855 PyObject *swig_obj[1] ;
19856
19857 if (!args) SWIG_fail;
19858 swig_obj[0] = args;
19859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19860 if (!SWIG_IsOK(res1)) {
19861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19862 }
19863 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 {
19871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19872 }
19873 return resultobj;
19874 fail:
19875 return NULL;
19876 }
19877
19878
19879 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19880 PyObject *resultobj = 0;
19881 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19882 long arg2 ;
19883 void *argp1 = 0 ;
19884 int res1 = 0 ;
19885 long val2 ;
19886 int ecode2 = 0 ;
19887 PyObject * obj0 = 0 ;
19888 PyObject * obj1 = 0 ;
19889 char * kwnames[] = {
19890 (char *) "self",(char *) "extraLong", NULL
19891 };
19892
19893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19895 if (!SWIG_IsOK(res1)) {
19896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19897 }
19898 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19899 ecode2 = SWIG_AsVal_long(obj1, &val2);
19900 if (!SWIG_IsOK(ecode2)) {
19901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19902 }
19903 arg2 = static_cast< long >(val2);
19904 {
19905 PyThreadState* __tstate = wxPyBeginAllowThreads();
19906 (arg1)->SetExtraLong(arg2);
19907 wxPyEndAllowThreads(__tstate);
19908 if (PyErr_Occurred()) SWIG_fail;
19909 }
19910 resultobj = SWIG_Py_Void();
19911 return resultobj;
19912 fail:
19913 return NULL;
19914 }
19915
19916
19917 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19918 PyObject *resultobj = 0;
19919 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19920 long result;
19921 void *argp1 = 0 ;
19922 int res1 = 0 ;
19923 PyObject *swig_obj[1] ;
19924
19925 if (!args) SWIG_fail;
19926 swig_obj[0] = args;
19927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19928 if (!SWIG_IsOK(res1)) {
19929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19930 }
19931 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19932 {
19933 PyThreadState* __tstate = wxPyBeginAllowThreads();
19934 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 resultobj = SWIG_From_long(static_cast< long >(result));
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj = 0;
19947 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19948 int arg2 ;
19949 void *argp1 = 0 ;
19950 int res1 = 0 ;
19951 int val2 ;
19952 int ecode2 = 0 ;
19953 PyObject * obj0 = 0 ;
19954 PyObject * obj1 = 0 ;
19955 char * kwnames[] = {
19956 (char *) "self",(char *) "i", NULL
19957 };
19958
19959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19961 if (!SWIG_IsOK(res1)) {
19962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19963 }
19964 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19965 ecode2 = SWIG_AsVal_int(obj1, &val2);
19966 if (!SWIG_IsOK(ecode2)) {
19967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19968 }
19969 arg2 = static_cast< int >(val2);
19970 {
19971 PyThreadState* __tstate = wxPyBeginAllowThreads();
19972 (arg1)->SetInt(arg2);
19973 wxPyEndAllowThreads(__tstate);
19974 if (PyErr_Occurred()) SWIG_fail;
19975 }
19976 resultobj = SWIG_Py_Void();
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19984 PyObject *resultobj = 0;
19985 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19986 int result;
19987 void *argp1 = 0 ;
19988 int res1 = 0 ;
19989 PyObject *swig_obj[1] ;
19990
19991 if (!args) SWIG_fail;
19992 swig_obj[0] = args;
19993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19994 if (!SWIG_IsOK(res1)) {
19995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19996 }
19997 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 result = (int)((wxCommandEvent const *)arg1)->GetInt();
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 resultobj = SWIG_From_int(static_cast< int >(result));
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20012 PyObject *resultobj = 0;
20013 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20014 PyObject *result = 0 ;
20015 void *argp1 = 0 ;
20016 int res1 = 0 ;
20017 PyObject *swig_obj[1] ;
20018
20019 if (!args) SWIG_fail;
20020 swig_obj[0] = args;
20021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20022 if (!SWIG_IsOK(res1)) {
20023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20024 }
20025 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20026 {
20027 PyThreadState* __tstate = wxPyBeginAllowThreads();
20028 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20029 wxPyEndAllowThreads(__tstate);
20030 if (PyErr_Occurred()) SWIG_fail;
20031 }
20032 resultobj = result;
20033 return resultobj;
20034 fail:
20035 return NULL;
20036 }
20037
20038
20039 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20040 PyObject *resultobj = 0;
20041 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20042 PyObject *arg2 = (PyObject *) 0 ;
20043 void *argp1 = 0 ;
20044 int res1 = 0 ;
20045 PyObject * obj0 = 0 ;
20046 PyObject * obj1 = 0 ;
20047 char * kwnames[] = {
20048 (char *) "self",(char *) "clientData", NULL
20049 };
20050
20051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20053 if (!SWIG_IsOK(res1)) {
20054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20055 }
20056 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20057 arg2 = obj1;
20058 {
20059 PyThreadState* __tstate = wxPyBeginAllowThreads();
20060 wxCommandEvent_SetClientData(arg1,arg2);
20061 wxPyEndAllowThreads(__tstate);
20062 if (PyErr_Occurred()) SWIG_fail;
20063 }
20064 resultobj = SWIG_Py_Void();
20065 return resultobj;
20066 fail:
20067 return NULL;
20068 }
20069
20070
20071 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20072 PyObject *resultobj = 0;
20073 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20074 wxEvent *result = 0 ;
20075 void *argp1 = 0 ;
20076 int res1 = 0 ;
20077 PyObject *swig_obj[1] ;
20078
20079 if (!args) SWIG_fail;
20080 swig_obj[0] = args;
20081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20082 if (!SWIG_IsOK(res1)) {
20083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20084 }
20085 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20086 {
20087 PyThreadState* __tstate = wxPyBeginAllowThreads();
20088 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20089 wxPyEndAllowThreads(__tstate);
20090 if (PyErr_Occurred()) SWIG_fail;
20091 }
20092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20093 return resultobj;
20094 fail:
20095 return NULL;
20096 }
20097
20098
20099 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20100 PyObject *obj;
20101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20102 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20103 return SWIG_Py_Void();
20104 }
20105
20106 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20107 return SWIG_Python_InitShadowInstance(args);
20108 }
20109
20110 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20111 PyObject *resultobj = 0;
20112 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20113 int arg2 = (int) 0 ;
20114 wxNotifyEvent *result = 0 ;
20115 int val1 ;
20116 int ecode1 = 0 ;
20117 int val2 ;
20118 int ecode2 = 0 ;
20119 PyObject * obj0 = 0 ;
20120 PyObject * obj1 = 0 ;
20121 char * kwnames[] = {
20122 (char *) "commandType",(char *) "winid", NULL
20123 };
20124
20125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20126 if (obj0) {
20127 ecode1 = SWIG_AsVal_int(obj0, &val1);
20128 if (!SWIG_IsOK(ecode1)) {
20129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20130 }
20131 arg1 = static_cast< wxEventType >(val1);
20132 }
20133 if (obj1) {
20134 ecode2 = SWIG_AsVal_int(obj1, &val2);
20135 if (!SWIG_IsOK(ecode2)) {
20136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20137 }
20138 arg2 = static_cast< int >(val2);
20139 }
20140 {
20141 PyThreadState* __tstate = wxPyBeginAllowThreads();
20142 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20143 wxPyEndAllowThreads(__tstate);
20144 if (PyErr_Occurred()) SWIG_fail;
20145 }
20146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20147 return resultobj;
20148 fail:
20149 return NULL;
20150 }
20151
20152
20153 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20154 PyObject *resultobj = 0;
20155 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20156 void *argp1 = 0 ;
20157 int res1 = 0 ;
20158 PyObject *swig_obj[1] ;
20159
20160 if (!args) SWIG_fail;
20161 swig_obj[0] = args;
20162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20163 if (!SWIG_IsOK(res1)) {
20164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20165 }
20166 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20167 {
20168 PyThreadState* __tstate = wxPyBeginAllowThreads();
20169 (arg1)->Veto();
20170 wxPyEndAllowThreads(__tstate);
20171 if (PyErr_Occurred()) SWIG_fail;
20172 }
20173 resultobj = SWIG_Py_Void();
20174 return resultobj;
20175 fail:
20176 return NULL;
20177 }
20178
20179
20180 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20181 PyObject *resultobj = 0;
20182 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20183 void *argp1 = 0 ;
20184 int res1 = 0 ;
20185 PyObject *swig_obj[1] ;
20186
20187 if (!args) SWIG_fail;
20188 swig_obj[0] = args;
20189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20190 if (!SWIG_IsOK(res1)) {
20191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20192 }
20193 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 (arg1)->Allow();
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 resultobj = SWIG_Py_Void();
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20208 PyObject *resultobj = 0;
20209 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20210 bool result;
20211 void *argp1 = 0 ;
20212 int res1 = 0 ;
20213 PyObject *swig_obj[1] ;
20214
20215 if (!args) SWIG_fail;
20216 swig_obj[0] = args;
20217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20218 if (!SWIG_IsOK(res1)) {
20219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20220 }
20221 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (bool)(arg1)->IsAllowed();
20225 wxPyEndAllowThreads(__tstate);
20226 if (PyErr_Occurred()) SWIG_fail;
20227 }
20228 {
20229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20230 }
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20238 PyObject *obj;
20239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20240 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20241 return SWIG_Py_Void();
20242 }
20243
20244 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20245 return SWIG_Python_InitShadowInstance(args);
20246 }
20247
20248 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20249 PyObject *resultobj = 0;
20250 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20251 int arg2 = (int) 0 ;
20252 int arg3 = (int) 0 ;
20253 int arg4 = (int) 0 ;
20254 wxScrollEvent *result = 0 ;
20255 int val1 ;
20256 int ecode1 = 0 ;
20257 int val2 ;
20258 int ecode2 = 0 ;
20259 int val3 ;
20260 int ecode3 = 0 ;
20261 int val4 ;
20262 int ecode4 = 0 ;
20263 PyObject * obj0 = 0 ;
20264 PyObject * obj1 = 0 ;
20265 PyObject * obj2 = 0 ;
20266 PyObject * obj3 = 0 ;
20267 char * kwnames[] = {
20268 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20269 };
20270
20271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20272 if (obj0) {
20273 ecode1 = SWIG_AsVal_int(obj0, &val1);
20274 if (!SWIG_IsOK(ecode1)) {
20275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20276 }
20277 arg1 = static_cast< wxEventType >(val1);
20278 }
20279 if (obj1) {
20280 ecode2 = SWIG_AsVal_int(obj1, &val2);
20281 if (!SWIG_IsOK(ecode2)) {
20282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20283 }
20284 arg2 = static_cast< int >(val2);
20285 }
20286 if (obj2) {
20287 ecode3 = SWIG_AsVal_int(obj2, &val3);
20288 if (!SWIG_IsOK(ecode3)) {
20289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20290 }
20291 arg3 = static_cast< int >(val3);
20292 }
20293 if (obj3) {
20294 ecode4 = SWIG_AsVal_int(obj3, &val4);
20295 if (!SWIG_IsOK(ecode4)) {
20296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20297 }
20298 arg4 = static_cast< int >(val4);
20299 }
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20314 PyObject *resultobj = 0;
20315 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20316 int result;
20317 void *argp1 = 0 ;
20318 int res1 = 0 ;
20319 PyObject *swig_obj[1] ;
20320
20321 if (!args) SWIG_fail;
20322 swig_obj[0] = args;
20323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20324 if (!SWIG_IsOK(res1)) {
20325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20326 }
20327 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20331 wxPyEndAllowThreads(__tstate);
20332 if (PyErr_Occurred()) SWIG_fail;
20333 }
20334 resultobj = SWIG_From_int(static_cast< int >(result));
20335 return resultobj;
20336 fail:
20337 return NULL;
20338 }
20339
20340
20341 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 PyObject *resultobj = 0;
20343 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20344 int result;
20345 void *argp1 = 0 ;
20346 int res1 = 0 ;
20347 PyObject *swig_obj[1] ;
20348
20349 if (!args) SWIG_fail;
20350 swig_obj[0] = args;
20351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20352 if (!SWIG_IsOK(res1)) {
20353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20354 }
20355 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20359 wxPyEndAllowThreads(__tstate);
20360 if (PyErr_Occurred()) SWIG_fail;
20361 }
20362 resultobj = SWIG_From_int(static_cast< int >(result));
20363 return resultobj;
20364 fail:
20365 return NULL;
20366 }
20367
20368
20369 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20370 PyObject *resultobj = 0;
20371 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20372 int arg2 ;
20373 void *argp1 = 0 ;
20374 int res1 = 0 ;
20375 int val2 ;
20376 int ecode2 = 0 ;
20377 PyObject * obj0 = 0 ;
20378 PyObject * obj1 = 0 ;
20379 char * kwnames[] = {
20380 (char *) "self",(char *) "orient", NULL
20381 };
20382
20383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20385 if (!SWIG_IsOK(res1)) {
20386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20387 }
20388 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20389 ecode2 = SWIG_AsVal_int(obj1, &val2);
20390 if (!SWIG_IsOK(ecode2)) {
20391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20392 }
20393 arg2 = static_cast< int >(val2);
20394 {
20395 PyThreadState* __tstate = wxPyBeginAllowThreads();
20396 (arg1)->SetOrientation(arg2);
20397 wxPyEndAllowThreads(__tstate);
20398 if (PyErr_Occurred()) SWIG_fail;
20399 }
20400 resultobj = SWIG_Py_Void();
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20408 PyObject *resultobj = 0;
20409 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20410 int arg2 ;
20411 void *argp1 = 0 ;
20412 int res1 = 0 ;
20413 int val2 ;
20414 int ecode2 = 0 ;
20415 PyObject * obj0 = 0 ;
20416 PyObject * obj1 = 0 ;
20417 char * kwnames[] = {
20418 (char *) "self",(char *) "pos", NULL
20419 };
20420
20421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20423 if (!SWIG_IsOK(res1)) {
20424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20425 }
20426 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20427 ecode2 = SWIG_AsVal_int(obj1, &val2);
20428 if (!SWIG_IsOK(ecode2)) {
20429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20430 }
20431 arg2 = static_cast< int >(val2);
20432 {
20433 PyThreadState* __tstate = wxPyBeginAllowThreads();
20434 (arg1)->SetPosition(arg2);
20435 wxPyEndAllowThreads(__tstate);
20436 if (PyErr_Occurred()) SWIG_fail;
20437 }
20438 resultobj = SWIG_Py_Void();
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *obj;
20447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20448 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20449 return SWIG_Py_Void();
20450 }
20451
20452 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20453 return SWIG_Python_InitShadowInstance(args);
20454 }
20455
20456 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20457 PyObject *resultobj = 0;
20458 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20459 int arg2 = (int) 0 ;
20460 int arg3 = (int) 0 ;
20461 wxScrollWinEvent *result = 0 ;
20462 int val1 ;
20463 int ecode1 = 0 ;
20464 int val2 ;
20465 int ecode2 = 0 ;
20466 int val3 ;
20467 int ecode3 = 0 ;
20468 PyObject * obj0 = 0 ;
20469 PyObject * obj1 = 0 ;
20470 PyObject * obj2 = 0 ;
20471 char * kwnames[] = {
20472 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20473 };
20474
20475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20476 if (obj0) {
20477 ecode1 = SWIG_AsVal_int(obj0, &val1);
20478 if (!SWIG_IsOK(ecode1)) {
20479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20480 }
20481 arg1 = static_cast< wxEventType >(val1);
20482 }
20483 if (obj1) {
20484 ecode2 = SWIG_AsVal_int(obj1, &val2);
20485 if (!SWIG_IsOK(ecode2)) {
20486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20487 }
20488 arg2 = static_cast< int >(val2);
20489 }
20490 if (obj2) {
20491 ecode3 = SWIG_AsVal_int(obj2, &val3);
20492 if (!SWIG_IsOK(ecode3)) {
20493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20494 }
20495 arg3 = static_cast< int >(val3);
20496 }
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20500 wxPyEndAllowThreads(__tstate);
20501 if (PyErr_Occurred()) SWIG_fail;
20502 }
20503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20504 return resultobj;
20505 fail:
20506 return NULL;
20507 }
20508
20509
20510 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20511 PyObject *resultobj = 0;
20512 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20513 int result;
20514 void *argp1 = 0 ;
20515 int res1 = 0 ;
20516 PyObject *swig_obj[1] ;
20517
20518 if (!args) SWIG_fail;
20519 swig_obj[0] = args;
20520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20521 if (!SWIG_IsOK(res1)) {
20522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20523 }
20524 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20525 {
20526 PyThreadState* __tstate = wxPyBeginAllowThreads();
20527 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20528 wxPyEndAllowThreads(__tstate);
20529 if (PyErr_Occurred()) SWIG_fail;
20530 }
20531 resultobj = SWIG_From_int(static_cast< int >(result));
20532 return resultobj;
20533 fail:
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20539 PyObject *resultobj = 0;
20540 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20541 int result;
20542 void *argp1 = 0 ;
20543 int res1 = 0 ;
20544 PyObject *swig_obj[1] ;
20545
20546 if (!args) SWIG_fail;
20547 swig_obj[0] = args;
20548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20549 if (!SWIG_IsOK(res1)) {
20550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20551 }
20552 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20553 {
20554 PyThreadState* __tstate = wxPyBeginAllowThreads();
20555 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20556 wxPyEndAllowThreads(__tstate);
20557 if (PyErr_Occurred()) SWIG_fail;
20558 }
20559 resultobj = SWIG_From_int(static_cast< int >(result));
20560 return resultobj;
20561 fail:
20562 return NULL;
20563 }
20564
20565
20566 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20567 PyObject *resultobj = 0;
20568 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20569 int arg2 ;
20570 void *argp1 = 0 ;
20571 int res1 = 0 ;
20572 int val2 ;
20573 int ecode2 = 0 ;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 char * kwnames[] = {
20577 (char *) "self",(char *) "orient", NULL
20578 };
20579
20580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20582 if (!SWIG_IsOK(res1)) {
20583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20584 }
20585 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20586 ecode2 = SWIG_AsVal_int(obj1, &val2);
20587 if (!SWIG_IsOK(ecode2)) {
20588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20589 }
20590 arg2 = static_cast< int >(val2);
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 (arg1)->SetOrientation(arg2);
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 resultobj = SWIG_Py_Void();
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20605 PyObject *resultobj = 0;
20606 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20607 int arg2 ;
20608 void *argp1 = 0 ;
20609 int res1 = 0 ;
20610 int val2 ;
20611 int ecode2 = 0 ;
20612 PyObject * obj0 = 0 ;
20613 PyObject * obj1 = 0 ;
20614 char * kwnames[] = {
20615 (char *) "self",(char *) "pos", NULL
20616 };
20617
20618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20620 if (!SWIG_IsOK(res1)) {
20621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20622 }
20623 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20624 ecode2 = SWIG_AsVal_int(obj1, &val2);
20625 if (!SWIG_IsOK(ecode2)) {
20626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20627 }
20628 arg2 = static_cast< int >(val2);
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 (arg1)->SetPosition(arg2);
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 resultobj = SWIG_Py_Void();
20636 return resultobj;
20637 fail:
20638 return NULL;
20639 }
20640
20641
20642 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20643 PyObject *obj;
20644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20645 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20646 return SWIG_Py_Void();
20647 }
20648
20649 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20650 return SWIG_Python_InitShadowInstance(args);
20651 }
20652
20653 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20654 PyObject *resultobj = 0;
20655 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20656 wxMouseEvent *result = 0 ;
20657 int val1 ;
20658 int ecode1 = 0 ;
20659 PyObject * obj0 = 0 ;
20660 char * kwnames[] = {
20661 (char *) "mouseType", NULL
20662 };
20663
20664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20665 if (obj0) {
20666 ecode1 = SWIG_AsVal_int(obj0, &val1);
20667 if (!SWIG_IsOK(ecode1)) {
20668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20669 }
20670 arg1 = static_cast< wxEventType >(val1);
20671 }
20672 {
20673 PyThreadState* __tstate = wxPyBeginAllowThreads();
20674 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20675 wxPyEndAllowThreads(__tstate);
20676 if (PyErr_Occurred()) SWIG_fail;
20677 }
20678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686 PyObject *resultobj = 0;
20687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20688 bool result;
20689 void *argp1 = 0 ;
20690 int res1 = 0 ;
20691 PyObject *swig_obj[1] ;
20692
20693 if (!args) SWIG_fail;
20694 swig_obj[0] = args;
20695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20696 if (!SWIG_IsOK(res1)) {
20697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20698 }
20699 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20708 }
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj = 0;
20717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20718 int arg2 = (int) wxMOUSE_BTN_ANY ;
20719 bool result;
20720 void *argp1 = 0 ;
20721 int res1 = 0 ;
20722 int val2 ;
20723 int ecode2 = 0 ;
20724 PyObject * obj0 = 0 ;
20725 PyObject * obj1 = 0 ;
20726 char * kwnames[] = {
20727 (char *) "self",(char *) "but", NULL
20728 };
20729
20730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20732 if (!SWIG_IsOK(res1)) {
20733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20734 }
20735 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20736 if (obj1) {
20737 ecode2 = SWIG_AsVal_int(obj1, &val2);
20738 if (!SWIG_IsOK(ecode2)) {
20739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20740 }
20741 arg2 = static_cast< int >(val2);
20742 }
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 {
20750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20751 }
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20759 PyObject *resultobj = 0;
20760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20761 int arg2 = (int) wxMOUSE_BTN_ANY ;
20762 bool result;
20763 void *argp1 = 0 ;
20764 int res1 = 0 ;
20765 int val2 ;
20766 int ecode2 = 0 ;
20767 PyObject * obj0 = 0 ;
20768 PyObject * obj1 = 0 ;
20769 char * kwnames[] = {
20770 (char *) "self",(char *) "but", NULL
20771 };
20772
20773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20775 if (!SWIG_IsOK(res1)) {
20776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20777 }
20778 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20779 if (obj1) {
20780 ecode2 = SWIG_AsVal_int(obj1, &val2);
20781 if (!SWIG_IsOK(ecode2)) {
20782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20783 }
20784 arg2 = static_cast< int >(val2);
20785 }
20786 {
20787 PyThreadState* __tstate = wxPyBeginAllowThreads();
20788 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 {
20793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20794 }
20795 return resultobj;
20796 fail:
20797 return NULL;
20798 }
20799
20800
20801 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20802 PyObject *resultobj = 0;
20803 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20804 int arg2 = (int) wxMOUSE_BTN_ANY ;
20805 bool result;
20806 void *argp1 = 0 ;
20807 int res1 = 0 ;
20808 int val2 ;
20809 int ecode2 = 0 ;
20810 PyObject * obj0 = 0 ;
20811 PyObject * obj1 = 0 ;
20812 char * kwnames[] = {
20813 (char *) "self",(char *) "but", NULL
20814 };
20815
20816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20818 if (!SWIG_IsOK(res1)) {
20819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20820 }
20821 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20822 if (obj1) {
20823 ecode2 = SWIG_AsVal_int(obj1, &val2);
20824 if (!SWIG_IsOK(ecode2)) {
20825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20826 }
20827 arg2 = static_cast< int >(val2);
20828 }
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 {
20836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20837 }
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20845 PyObject *resultobj = 0;
20846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20847 int arg2 ;
20848 bool result;
20849 void *argp1 = 0 ;
20850 int res1 = 0 ;
20851 int val2 ;
20852 int ecode2 = 0 ;
20853 PyObject * obj0 = 0 ;
20854 PyObject * obj1 = 0 ;
20855 char * kwnames[] = {
20856 (char *) "self",(char *) "button", NULL
20857 };
20858
20859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20861 if (!SWIG_IsOK(res1)) {
20862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20863 }
20864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20865 ecode2 = SWIG_AsVal_int(obj1, &val2);
20866 if (!SWIG_IsOK(ecode2)) {
20867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20868 }
20869 arg2 = static_cast< int >(val2);
20870 {
20871 PyThreadState* __tstate = wxPyBeginAllowThreads();
20872 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20873 wxPyEndAllowThreads(__tstate);
20874 if (PyErr_Occurred()) SWIG_fail;
20875 }
20876 {
20877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20878 }
20879 return resultobj;
20880 fail:
20881 return NULL;
20882 }
20883
20884
20885 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20886 PyObject *resultobj = 0;
20887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20888 int arg2 ;
20889 bool result;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 int val2 ;
20893 int ecode2 = 0 ;
20894 PyObject * obj0 = 0 ;
20895 PyObject * obj1 = 0 ;
20896 char * kwnames[] = {
20897 (char *) "self",(char *) "but", NULL
20898 };
20899
20900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20902 if (!SWIG_IsOK(res1)) {
20903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20904 }
20905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20906 ecode2 = SWIG_AsVal_int(obj1, &val2);
20907 if (!SWIG_IsOK(ecode2)) {
20908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20909 }
20910 arg2 = static_cast< int >(val2);
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20914 wxPyEndAllowThreads(__tstate);
20915 if (PyErr_Occurred()) SWIG_fail;
20916 }
20917 {
20918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20919 }
20920 return resultobj;
20921 fail:
20922 return NULL;
20923 }
20924
20925
20926 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20927 PyObject *resultobj = 0;
20928 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20929 int result;
20930 void *argp1 = 0 ;
20931 int res1 = 0 ;
20932 PyObject *swig_obj[1] ;
20933
20934 if (!args) SWIG_fail;
20935 swig_obj[0] = args;
20936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20937 if (!SWIG_IsOK(res1)) {
20938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20939 }
20940 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20944 wxPyEndAllowThreads(__tstate);
20945 if (PyErr_Occurred()) SWIG_fail;
20946 }
20947 resultobj = SWIG_From_int(static_cast< int >(result));
20948 return resultobj;
20949 fail:
20950 return NULL;
20951 }
20952
20953
20954 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20955 PyObject *resultobj = 0;
20956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20957 bool result;
20958 void *argp1 = 0 ;
20959 int res1 = 0 ;
20960 PyObject *swig_obj[1] ;
20961
20962 if (!args) SWIG_fail;
20963 swig_obj[0] = args;
20964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20965 if (!SWIG_IsOK(res1)) {
20966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20967 }
20968 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20969 {
20970 PyThreadState* __tstate = wxPyBeginAllowThreads();
20971 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20972 wxPyEndAllowThreads(__tstate);
20973 if (PyErr_Occurred()) SWIG_fail;
20974 }
20975 {
20976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20977 }
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20985 PyObject *resultobj = 0;
20986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20987 bool result;
20988 void *argp1 = 0 ;
20989 int res1 = 0 ;
20990 PyObject *swig_obj[1] ;
20991
20992 if (!args) SWIG_fail;
20993 swig_obj[0] = args;
20994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20995 if (!SWIG_IsOK(res1)) {
20996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20997 }
20998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
21002 wxPyEndAllowThreads(__tstate);
21003 if (PyErr_Occurred()) SWIG_fail;
21004 }
21005 {
21006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21007 }
21008 return resultobj;
21009 fail:
21010 return NULL;
21011 }
21012
21013
21014 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21015 PyObject *resultobj = 0;
21016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21017 bool result;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 PyObject *swig_obj[1] ;
21021
21022 if (!args) SWIG_fail;
21023 swig_obj[0] = args;
21024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21025 if (!SWIG_IsOK(res1)) {
21026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21027 }
21028 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 {
21036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21037 }
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045 PyObject *resultobj = 0;
21046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21047 bool result;
21048 void *argp1 = 0 ;
21049 int res1 = 0 ;
21050 PyObject *swig_obj[1] ;
21051
21052 if (!args) SWIG_fail;
21053 swig_obj[0] = args;
21054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21057 }
21058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21059 {
21060 PyThreadState* __tstate = wxPyBeginAllowThreads();
21061 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21062 wxPyEndAllowThreads(__tstate);
21063 if (PyErr_Occurred()) SWIG_fail;
21064 }
21065 {
21066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21067 }
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21075 PyObject *resultobj = 0;
21076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21077 bool result;
21078 void *argp1 = 0 ;
21079 int res1 = 0 ;
21080 PyObject *swig_obj[1] ;
21081
21082 if (!args) SWIG_fail;
21083 swig_obj[0] = args;
21084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21085 if (!SWIG_IsOK(res1)) {
21086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21087 }
21088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21092 wxPyEndAllowThreads(__tstate);
21093 if (PyErr_Occurred()) SWIG_fail;
21094 }
21095 {
21096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21097 }
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21105 PyObject *resultobj = 0;
21106 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21107 bool result;
21108 void *argp1 = 0 ;
21109 int res1 = 0 ;
21110 PyObject *swig_obj[1] ;
21111
21112 if (!args) SWIG_fail;
21113 swig_obj[0] = args;
21114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21115 if (!SWIG_IsOK(res1)) {
21116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21117 }
21118 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 {
21126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21127 }
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21135 PyObject *resultobj = 0;
21136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21137 bool result;
21138 void *argp1 = 0 ;
21139 int res1 = 0 ;
21140 PyObject *swig_obj[1] ;
21141
21142 if (!args) SWIG_fail;
21143 swig_obj[0] = args;
21144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21145 if (!SWIG_IsOK(res1)) {
21146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21147 }
21148 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21149 {
21150 PyThreadState* __tstate = wxPyBeginAllowThreads();
21151 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21152 wxPyEndAllowThreads(__tstate);
21153 if (PyErr_Occurred()) SWIG_fail;
21154 }
21155 {
21156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21157 }
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21165 PyObject *resultobj = 0;
21166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21167 bool result;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 PyObject *swig_obj[1] ;
21171
21172 if (!args) SWIG_fail;
21173 swig_obj[0] = args;
21174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21175 if (!SWIG_IsOK(res1)) {
21176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21177 }
21178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 {
21186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21187 }
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21195 PyObject *resultobj = 0;
21196 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21197 bool result;
21198 void *argp1 = 0 ;
21199 int res1 = 0 ;
21200 PyObject *swig_obj[1] ;
21201
21202 if (!args) SWIG_fail;
21203 swig_obj[0] = args;
21204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21205 if (!SWIG_IsOK(res1)) {
21206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21207 }
21208 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21209 {
21210 PyThreadState* __tstate = wxPyBeginAllowThreads();
21211 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21212 wxPyEndAllowThreads(__tstate);
21213 if (PyErr_Occurred()) SWIG_fail;
21214 }
21215 {
21216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21217 }
21218 return resultobj;
21219 fail:
21220 return NULL;
21221 }
21222
21223
21224 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21225 PyObject *resultobj = 0;
21226 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21227 bool result;
21228 void *argp1 = 0 ;
21229 int res1 = 0 ;
21230 PyObject *swig_obj[1] ;
21231
21232 if (!args) SWIG_fail;
21233 swig_obj[0] = args;
21234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21235 if (!SWIG_IsOK(res1)) {
21236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21237 }
21238 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21239 {
21240 PyThreadState* __tstate = wxPyBeginAllowThreads();
21241 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 {
21246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21247 }
21248 return resultobj;
21249 fail:
21250 return NULL;
21251 }
21252
21253
21254 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21255 PyObject *resultobj = 0;
21256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21257 bool result;
21258 void *argp1 = 0 ;
21259 int res1 = 0 ;
21260 PyObject *swig_obj[1] ;
21261
21262 if (!args) SWIG_fail;
21263 swig_obj[0] = args;
21264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21265 if (!SWIG_IsOK(res1)) {
21266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21267 }
21268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21269 {
21270 PyThreadState* __tstate = wxPyBeginAllowThreads();
21271 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21272 wxPyEndAllowThreads(__tstate);
21273 if (PyErr_Occurred()) SWIG_fail;
21274 }
21275 {
21276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21277 }
21278 return resultobj;
21279 fail:
21280 return NULL;
21281 }
21282
21283
21284 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21285 PyObject *resultobj = 0;
21286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21287 bool result;
21288 void *argp1 = 0 ;
21289 int res1 = 0 ;
21290 PyObject *swig_obj[1] ;
21291
21292 if (!args) SWIG_fail;
21293 swig_obj[0] = args;
21294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21295 if (!SWIG_IsOK(res1)) {
21296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21297 }
21298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 {
21306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21307 }
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21317 bool result;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 PyObject *swig_obj[1] ;
21321
21322 if (!args) SWIG_fail;
21323 swig_obj[0] = args;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21327 }
21328 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21332 wxPyEndAllowThreads(__tstate);
21333 if (PyErr_Occurred()) SWIG_fail;
21334 }
21335 {
21336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21337 }
21338 return resultobj;
21339 fail:
21340 return NULL;
21341 }
21342
21343
21344 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21345 PyObject *resultobj = 0;
21346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21347 bool result;
21348 void *argp1 = 0 ;
21349 int res1 = 0 ;
21350 PyObject *swig_obj[1] ;
21351
21352 if (!args) SWIG_fail;
21353 swig_obj[0] = args;
21354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21355 if (!SWIG_IsOK(res1)) {
21356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21357 }
21358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21359 {
21360 PyThreadState* __tstate = wxPyBeginAllowThreads();
21361 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21362 wxPyEndAllowThreads(__tstate);
21363 if (PyErr_Occurred()) SWIG_fail;
21364 }
21365 {
21366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21367 }
21368 return resultobj;
21369 fail:
21370 return NULL;
21371 }
21372
21373
21374 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21375 PyObject *resultobj = 0;
21376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21377 bool result;
21378 void *argp1 = 0 ;
21379 int res1 = 0 ;
21380 PyObject *swig_obj[1] ;
21381
21382 if (!args) SWIG_fail;
21383 swig_obj[0] = args;
21384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21385 if (!SWIG_IsOK(res1)) {
21386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21387 }
21388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (bool)(arg1)->LeftIsDown();
21392 wxPyEndAllowThreads(__tstate);
21393 if (PyErr_Occurred()) SWIG_fail;
21394 }
21395 {
21396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21397 }
21398 return resultobj;
21399 fail:
21400 return NULL;
21401 }
21402
21403
21404 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21405 PyObject *resultobj = 0;
21406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21407 bool result;
21408 void *argp1 = 0 ;
21409 int res1 = 0 ;
21410 PyObject *swig_obj[1] ;
21411
21412 if (!args) SWIG_fail;
21413 swig_obj[0] = args;
21414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21415 if (!SWIG_IsOK(res1)) {
21416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21417 }
21418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 result = (bool)(arg1)->MiddleIsDown();
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 {
21426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21427 }
21428 return resultobj;
21429 fail:
21430 return NULL;
21431 }
21432
21433
21434 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21435 PyObject *resultobj = 0;
21436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21437 bool result;
21438 void *argp1 = 0 ;
21439 int res1 = 0 ;
21440 PyObject *swig_obj[1] ;
21441
21442 if (!args) SWIG_fail;
21443 swig_obj[0] = args;
21444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21445 if (!SWIG_IsOK(res1)) {
21446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21447 }
21448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21449 {
21450 PyThreadState* __tstate = wxPyBeginAllowThreads();
21451 result = (bool)(arg1)->RightIsDown();
21452 wxPyEndAllowThreads(__tstate);
21453 if (PyErr_Occurred()) SWIG_fail;
21454 }
21455 {
21456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21457 }
21458 return resultobj;
21459 fail:
21460 return NULL;
21461 }
21462
21463
21464 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21465 PyObject *resultobj = 0;
21466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21467 bool result;
21468 void *argp1 = 0 ;
21469 int res1 = 0 ;
21470 PyObject *swig_obj[1] ;
21471
21472 if (!args) SWIG_fail;
21473 swig_obj[0] = args;
21474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21475 if (!SWIG_IsOK(res1)) {
21476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21477 }
21478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21482 wxPyEndAllowThreads(__tstate);
21483 if (PyErr_Occurred()) SWIG_fail;
21484 }
21485 {
21486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21487 }
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21495 PyObject *resultobj = 0;
21496 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21497 bool result;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 PyObject *swig_obj[1] ;
21501
21502 if (!args) SWIG_fail;
21503 swig_obj[0] = args;
21504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21507 }
21508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21509 {
21510 PyThreadState* __tstate = wxPyBeginAllowThreads();
21511 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 {
21516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21517 }
21518 return resultobj;
21519 fail:
21520 return NULL;
21521 }
21522
21523
21524 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21525 PyObject *resultobj = 0;
21526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21527 bool result;
21528 void *argp1 = 0 ;
21529 int res1 = 0 ;
21530 PyObject *swig_obj[1] ;
21531
21532 if (!args) SWIG_fail;
21533 swig_obj[0] = args;
21534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21537 }
21538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21539 {
21540 PyThreadState* __tstate = wxPyBeginAllowThreads();
21541 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21542 wxPyEndAllowThreads(__tstate);
21543 if (PyErr_Occurred()) SWIG_fail;
21544 }
21545 {
21546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21547 }
21548 return resultobj;
21549 fail:
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21555 PyObject *resultobj = 0;
21556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21557 bool result;
21558 void *argp1 = 0 ;
21559 int res1 = 0 ;
21560 PyObject *swig_obj[1] ;
21561
21562 if (!args) SWIG_fail;
21563 swig_obj[0] = args;
21564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21565 if (!SWIG_IsOK(res1)) {
21566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21567 }
21568 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21572 wxPyEndAllowThreads(__tstate);
21573 if (PyErr_Occurred()) SWIG_fail;
21574 }
21575 {
21576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21577 }
21578 return resultobj;
21579 fail:
21580 return NULL;
21581 }
21582
21583
21584 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21585 PyObject *resultobj = 0;
21586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21587 wxPoint result;
21588 void *argp1 = 0 ;
21589 int res1 = 0 ;
21590 PyObject *swig_obj[1] ;
21591
21592 if (!args) SWIG_fail;
21593 swig_obj[0] = args;
21594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21595 if (!SWIG_IsOK(res1)) {
21596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21597 }
21598 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21599 {
21600 PyThreadState* __tstate = wxPyBeginAllowThreads();
21601 result = (arg1)->GetPosition();
21602 wxPyEndAllowThreads(__tstate);
21603 if (PyErr_Occurred()) SWIG_fail;
21604 }
21605 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21613 PyObject *resultobj = 0;
21614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21615 long *arg2 = (long *) 0 ;
21616 long *arg3 = (long *) 0 ;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 long temp2 ;
21620 int res2 = SWIG_TMPOBJ ;
21621 long temp3 ;
21622 int res3 = SWIG_TMPOBJ ;
21623 PyObject *swig_obj[1] ;
21624
21625 arg2 = &temp2;
21626 arg3 = &temp3;
21627 if (!args) SWIG_fail;
21628 swig_obj[0] = args;
21629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21630 if (!SWIG_IsOK(res1)) {
21631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21632 }
21633 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21634 {
21635 PyThreadState* __tstate = wxPyBeginAllowThreads();
21636 (arg1)->GetPosition(arg2,arg3);
21637 wxPyEndAllowThreads(__tstate);
21638 if (PyErr_Occurred()) SWIG_fail;
21639 }
21640 resultobj = SWIG_Py_Void();
21641 if (SWIG_IsTmpObj(res2)) {
21642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21643 } else {
21644 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21646 }
21647 if (SWIG_IsTmpObj(res3)) {
21648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21649 } else {
21650 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21652 }
21653 return resultobj;
21654 fail:
21655 return NULL;
21656 }
21657
21658
21659 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21660 PyObject *resultobj = 0;
21661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21662 wxDC *arg2 = 0 ;
21663 wxPoint result;
21664 void *argp1 = 0 ;
21665 int res1 = 0 ;
21666 void *argp2 = 0 ;
21667 int res2 = 0 ;
21668 PyObject * obj0 = 0 ;
21669 PyObject * obj1 = 0 ;
21670 char * kwnames[] = {
21671 (char *) "self",(char *) "dc", NULL
21672 };
21673
21674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21678 }
21679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21680 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21681 if (!SWIG_IsOK(res2)) {
21682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21683 }
21684 if (!argp2) {
21685 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21686 }
21687 arg2 = reinterpret_cast< wxDC * >(argp2);
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21695 return resultobj;
21696 fail:
21697 return NULL;
21698 }
21699
21700
21701 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21702 PyObject *resultobj = 0;
21703 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21704 int result;
21705 void *argp1 = 0 ;
21706 int res1 = 0 ;
21707 PyObject *swig_obj[1] ;
21708
21709 if (!args) SWIG_fail;
21710 swig_obj[0] = args;
21711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21712 if (!SWIG_IsOK(res1)) {
21713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21714 }
21715 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = (int)((wxMouseEvent const *)arg1)->GetX();
21719 wxPyEndAllowThreads(__tstate);
21720 if (PyErr_Occurred()) SWIG_fail;
21721 }
21722 resultobj = SWIG_From_int(static_cast< int >(result));
21723 return resultobj;
21724 fail:
21725 return NULL;
21726 }
21727
21728
21729 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21730 PyObject *resultobj = 0;
21731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21732 int result;
21733 void *argp1 = 0 ;
21734 int res1 = 0 ;
21735 PyObject *swig_obj[1] ;
21736
21737 if (!args) SWIG_fail;
21738 swig_obj[0] = args;
21739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21740 if (!SWIG_IsOK(res1)) {
21741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21742 }
21743 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 result = (int)((wxMouseEvent const *)arg1)->GetY();
21747 wxPyEndAllowThreads(__tstate);
21748 if (PyErr_Occurred()) SWIG_fail;
21749 }
21750 resultobj = SWIG_From_int(static_cast< int >(result));
21751 return resultobj;
21752 fail:
21753 return NULL;
21754 }
21755
21756
21757 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21758 PyObject *resultobj = 0;
21759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21760 int result;
21761 void *argp1 = 0 ;
21762 int res1 = 0 ;
21763 PyObject *swig_obj[1] ;
21764
21765 if (!args) SWIG_fail;
21766 swig_obj[0] = args;
21767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21768 if (!SWIG_IsOK(res1)) {
21769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21770 }
21771 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21772 {
21773 PyThreadState* __tstate = wxPyBeginAllowThreads();
21774 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21775 wxPyEndAllowThreads(__tstate);
21776 if (PyErr_Occurred()) SWIG_fail;
21777 }
21778 resultobj = SWIG_From_int(static_cast< int >(result));
21779 return resultobj;
21780 fail:
21781 return NULL;
21782 }
21783
21784
21785 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21786 PyObject *resultobj = 0;
21787 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21788 int result;
21789 void *argp1 = 0 ;
21790 int res1 = 0 ;
21791 PyObject *swig_obj[1] ;
21792
21793 if (!args) SWIG_fail;
21794 swig_obj[0] = args;
21795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21796 if (!SWIG_IsOK(res1)) {
21797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21798 }
21799 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 resultobj = SWIG_From_int(static_cast< int >(result));
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21814 PyObject *resultobj = 0;
21815 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21816 int result;
21817 void *argp1 = 0 ;
21818 int res1 = 0 ;
21819 PyObject *swig_obj[1] ;
21820
21821 if (!args) SWIG_fail;
21822 swig_obj[0] = args;
21823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21824 if (!SWIG_IsOK(res1)) {
21825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21826 }
21827 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 resultobj = SWIG_From_int(static_cast< int >(result));
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21842 PyObject *resultobj = 0;
21843 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21844 bool result;
21845 void *argp1 = 0 ;
21846 int res1 = 0 ;
21847 PyObject *swig_obj[1] ;
21848
21849 if (!args) SWIG_fail;
21850 swig_obj[0] = args;
21851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21852 if (!SWIG_IsOK(res1)) {
21853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21854 }
21855 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21859 wxPyEndAllowThreads(__tstate);
21860 if (PyErr_Occurred()) SWIG_fail;
21861 }
21862 {
21863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21864 }
21865 return resultobj;
21866 fail:
21867 return NULL;
21868 }
21869
21870
21871 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21872 PyObject *resultobj = 0;
21873 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21874 int arg2 ;
21875 void *argp1 = 0 ;
21876 int res1 = 0 ;
21877 int val2 ;
21878 int ecode2 = 0 ;
21879 PyObject *swig_obj[2] ;
21880
21881 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21883 if (!SWIG_IsOK(res1)) {
21884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21885 }
21886 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21887 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21888 if (!SWIG_IsOK(ecode2)) {
21889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21890 }
21891 arg2 = static_cast< int >(val2);
21892 if (arg1) (arg1)->m_x = arg2;
21893
21894 resultobj = SWIG_Py_Void();
21895 return resultobj;
21896 fail:
21897 return NULL;
21898 }
21899
21900
21901 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21902 PyObject *resultobj = 0;
21903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21904 int result;
21905 void *argp1 = 0 ;
21906 int res1 = 0 ;
21907 PyObject *swig_obj[1] ;
21908
21909 if (!args) SWIG_fail;
21910 swig_obj[0] = args;
21911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21912 if (!SWIG_IsOK(res1)) {
21913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21914 }
21915 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21916 result = (int) ((arg1)->m_x);
21917 resultobj = SWIG_From_int(static_cast< int >(result));
21918 return resultobj;
21919 fail:
21920 return NULL;
21921 }
21922
21923
21924 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21925 PyObject *resultobj = 0;
21926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21927 int arg2 ;
21928 void *argp1 = 0 ;
21929 int res1 = 0 ;
21930 int val2 ;
21931 int ecode2 = 0 ;
21932 PyObject *swig_obj[2] ;
21933
21934 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21936 if (!SWIG_IsOK(res1)) {
21937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21938 }
21939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21940 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21941 if (!SWIG_IsOK(ecode2)) {
21942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21943 }
21944 arg2 = static_cast< int >(val2);
21945 if (arg1) (arg1)->m_y = arg2;
21946
21947 resultobj = SWIG_Py_Void();
21948 return resultobj;
21949 fail:
21950 return NULL;
21951 }
21952
21953
21954 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21955 PyObject *resultobj = 0;
21956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21957 int result;
21958 void *argp1 = 0 ;
21959 int res1 = 0 ;
21960 PyObject *swig_obj[1] ;
21961
21962 if (!args) SWIG_fail;
21963 swig_obj[0] = args;
21964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21965 if (!SWIG_IsOK(res1)) {
21966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21967 }
21968 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21969 result = (int) ((arg1)->m_y);
21970 resultobj = SWIG_From_int(static_cast< int >(result));
21971 return resultobj;
21972 fail:
21973 return NULL;
21974 }
21975
21976
21977 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21978 PyObject *resultobj = 0;
21979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21980 bool arg2 ;
21981 void *argp1 = 0 ;
21982 int res1 = 0 ;
21983 bool val2 ;
21984 int ecode2 = 0 ;
21985 PyObject *swig_obj[2] ;
21986
21987 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21989 if (!SWIG_IsOK(res1)) {
21990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21991 }
21992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21993 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21994 if (!SWIG_IsOK(ecode2)) {
21995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21996 }
21997 arg2 = static_cast< bool >(val2);
21998 if (arg1) (arg1)->m_leftDown = arg2;
21999
22000 resultobj = SWIG_Py_Void();
22001 return resultobj;
22002 fail:
22003 return NULL;
22004 }
22005
22006
22007 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22008 PyObject *resultobj = 0;
22009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22010 bool result;
22011 void *argp1 = 0 ;
22012 int res1 = 0 ;
22013 PyObject *swig_obj[1] ;
22014
22015 if (!args) SWIG_fail;
22016 swig_obj[0] = args;
22017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22018 if (!SWIG_IsOK(res1)) {
22019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22020 }
22021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22022 result = (bool) ((arg1)->m_leftDown);
22023 {
22024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22033 PyObject *resultobj = 0;
22034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22035 bool arg2 ;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 bool val2 ;
22039 int ecode2 = 0 ;
22040 PyObject *swig_obj[2] ;
22041
22042 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22044 if (!SWIG_IsOK(res1)) {
22045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22046 }
22047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22048 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22049 if (!SWIG_IsOK(ecode2)) {
22050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22051 }
22052 arg2 = static_cast< bool >(val2);
22053 if (arg1) (arg1)->m_middleDown = arg2;
22054
22055 resultobj = SWIG_Py_Void();
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22063 PyObject *resultobj = 0;
22064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22065 bool result;
22066 void *argp1 = 0 ;
22067 int res1 = 0 ;
22068 PyObject *swig_obj[1] ;
22069
22070 if (!args) SWIG_fail;
22071 swig_obj[0] = args;
22072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22073 if (!SWIG_IsOK(res1)) {
22074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22075 }
22076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22077 result = (bool) ((arg1)->m_middleDown);
22078 {
22079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22080 }
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22088 PyObject *resultobj = 0;
22089 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22090 bool arg2 ;
22091 void *argp1 = 0 ;
22092 int res1 = 0 ;
22093 bool val2 ;
22094 int ecode2 = 0 ;
22095 PyObject *swig_obj[2] ;
22096
22097 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22099 if (!SWIG_IsOK(res1)) {
22100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22101 }
22102 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22103 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22104 if (!SWIG_IsOK(ecode2)) {
22105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22106 }
22107 arg2 = static_cast< bool >(val2);
22108 if (arg1) (arg1)->m_rightDown = arg2;
22109
22110 resultobj = SWIG_Py_Void();
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22118 PyObject *resultobj = 0;
22119 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22120 bool result;
22121 void *argp1 = 0 ;
22122 int res1 = 0 ;
22123 PyObject *swig_obj[1] ;
22124
22125 if (!args) SWIG_fail;
22126 swig_obj[0] = args;
22127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22130 }
22131 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22132 result = (bool) ((arg1)->m_rightDown);
22133 {
22134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22135 }
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22143 PyObject *resultobj = 0;
22144 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22145 bool arg2 ;
22146 void *argp1 = 0 ;
22147 int res1 = 0 ;
22148 bool val2 ;
22149 int ecode2 = 0 ;
22150 PyObject *swig_obj[2] ;
22151
22152 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22154 if (!SWIG_IsOK(res1)) {
22155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22156 }
22157 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22158 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22159 if (!SWIG_IsOK(ecode2)) {
22160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22161 }
22162 arg2 = static_cast< bool >(val2);
22163 if (arg1) (arg1)->m_controlDown = arg2;
22164
22165 resultobj = SWIG_Py_Void();
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22173 PyObject *resultobj = 0;
22174 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22175 bool result;
22176 void *argp1 = 0 ;
22177 int res1 = 0 ;
22178 PyObject *swig_obj[1] ;
22179
22180 if (!args) SWIG_fail;
22181 swig_obj[0] = args;
22182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22185 }
22186 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22187 result = (bool) ((arg1)->m_controlDown);
22188 {
22189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22190 }
22191 return resultobj;
22192 fail:
22193 return NULL;
22194 }
22195
22196
22197 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22198 PyObject *resultobj = 0;
22199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22200 bool arg2 ;
22201 void *argp1 = 0 ;
22202 int res1 = 0 ;
22203 bool val2 ;
22204 int ecode2 = 0 ;
22205 PyObject *swig_obj[2] ;
22206
22207 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22209 if (!SWIG_IsOK(res1)) {
22210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22211 }
22212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22213 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22214 if (!SWIG_IsOK(ecode2)) {
22215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22216 }
22217 arg2 = static_cast< bool >(val2);
22218 if (arg1) (arg1)->m_shiftDown = arg2;
22219
22220 resultobj = SWIG_Py_Void();
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22228 PyObject *resultobj = 0;
22229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22230 bool result;
22231 void *argp1 = 0 ;
22232 int res1 = 0 ;
22233 PyObject *swig_obj[1] ;
22234
22235 if (!args) SWIG_fail;
22236 swig_obj[0] = args;
22237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22238 if (!SWIG_IsOK(res1)) {
22239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22240 }
22241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22242 result = (bool) ((arg1)->m_shiftDown);
22243 {
22244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22245 }
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22253 PyObject *resultobj = 0;
22254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22255 bool arg2 ;
22256 void *argp1 = 0 ;
22257 int res1 = 0 ;
22258 bool val2 ;
22259 int ecode2 = 0 ;
22260 PyObject *swig_obj[2] ;
22261
22262 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22266 }
22267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22268 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22269 if (!SWIG_IsOK(ecode2)) {
22270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22271 }
22272 arg2 = static_cast< bool >(val2);
22273 if (arg1) (arg1)->m_altDown = arg2;
22274
22275 resultobj = SWIG_Py_Void();
22276 return resultobj;
22277 fail:
22278 return NULL;
22279 }
22280
22281
22282 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22283 PyObject *resultobj = 0;
22284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22285 bool result;
22286 void *argp1 = 0 ;
22287 int res1 = 0 ;
22288 PyObject *swig_obj[1] ;
22289
22290 if (!args) SWIG_fail;
22291 swig_obj[0] = args;
22292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22295 }
22296 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22297 result = (bool) ((arg1)->m_altDown);
22298 {
22299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22300 }
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22308 PyObject *resultobj = 0;
22309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22310 bool arg2 ;
22311 void *argp1 = 0 ;
22312 int res1 = 0 ;
22313 bool val2 ;
22314 int ecode2 = 0 ;
22315 PyObject *swig_obj[2] ;
22316
22317 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22319 if (!SWIG_IsOK(res1)) {
22320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22321 }
22322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22323 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22324 if (!SWIG_IsOK(ecode2)) {
22325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22326 }
22327 arg2 = static_cast< bool >(val2);
22328 if (arg1) (arg1)->m_metaDown = arg2;
22329
22330 resultobj = SWIG_Py_Void();
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22338 PyObject *resultobj = 0;
22339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22340 bool result;
22341 void *argp1 = 0 ;
22342 int res1 = 0 ;
22343 PyObject *swig_obj[1] ;
22344
22345 if (!args) SWIG_fail;
22346 swig_obj[0] = args;
22347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22348 if (!SWIG_IsOK(res1)) {
22349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22350 }
22351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22352 result = (bool) ((arg1)->m_metaDown);
22353 {
22354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22355 }
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22363 PyObject *resultobj = 0;
22364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22365 int arg2 ;
22366 void *argp1 = 0 ;
22367 int res1 = 0 ;
22368 int val2 ;
22369 int ecode2 = 0 ;
22370 PyObject *swig_obj[2] ;
22371
22372 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22374 if (!SWIG_IsOK(res1)) {
22375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22376 }
22377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22378 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22379 if (!SWIG_IsOK(ecode2)) {
22380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22381 }
22382 arg2 = static_cast< int >(val2);
22383 if (arg1) (arg1)->m_wheelRotation = arg2;
22384
22385 resultobj = SWIG_Py_Void();
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22393 PyObject *resultobj = 0;
22394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22395 int result;
22396 void *argp1 = 0 ;
22397 int res1 = 0 ;
22398 PyObject *swig_obj[1] ;
22399
22400 if (!args) SWIG_fail;
22401 swig_obj[0] = args;
22402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22407 result = (int) ((arg1)->m_wheelRotation);
22408 resultobj = SWIG_From_int(static_cast< int >(result));
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22416 PyObject *resultobj = 0;
22417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22418 int arg2 ;
22419 void *argp1 = 0 ;
22420 int res1 = 0 ;
22421 int val2 ;
22422 int ecode2 = 0 ;
22423 PyObject *swig_obj[2] ;
22424
22425 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22427 if (!SWIG_IsOK(res1)) {
22428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22429 }
22430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22431 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22432 if (!SWIG_IsOK(ecode2)) {
22433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22434 }
22435 arg2 = static_cast< int >(val2);
22436 if (arg1) (arg1)->m_wheelDelta = arg2;
22437
22438 resultobj = SWIG_Py_Void();
22439 return resultobj;
22440 fail:
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22448 int result;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 PyObject *swig_obj[1] ;
22452
22453 if (!args) SWIG_fail;
22454 swig_obj[0] = args;
22455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22456 if (!SWIG_IsOK(res1)) {
22457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22458 }
22459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22460 result = (int) ((arg1)->m_wheelDelta);
22461 resultobj = SWIG_From_int(static_cast< int >(result));
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22469 PyObject *resultobj = 0;
22470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22471 int arg2 ;
22472 void *argp1 = 0 ;
22473 int res1 = 0 ;
22474 int val2 ;
22475 int ecode2 = 0 ;
22476 PyObject *swig_obj[2] ;
22477
22478 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22480 if (!SWIG_IsOK(res1)) {
22481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22482 }
22483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22484 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22485 if (!SWIG_IsOK(ecode2)) {
22486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22487 }
22488 arg2 = static_cast< int >(val2);
22489 if (arg1) (arg1)->m_linesPerAction = arg2;
22490
22491 resultobj = SWIG_Py_Void();
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22501 int result;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 PyObject *swig_obj[1] ;
22505
22506 if (!args) SWIG_fail;
22507 swig_obj[0] = args;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22513 result = (int) ((arg1)->m_linesPerAction);
22514 resultobj = SWIG_From_int(static_cast< int >(result));
22515 return resultobj;
22516 fail:
22517 return NULL;
22518 }
22519
22520
22521 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22522 PyObject *obj;
22523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22524 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22525 return SWIG_Py_Void();
22526 }
22527
22528 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22529 return SWIG_Python_InitShadowInstance(args);
22530 }
22531
22532 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22533 PyObject *resultobj = 0;
22534 int arg1 = (int) 0 ;
22535 int arg2 = (int) 0 ;
22536 wxSetCursorEvent *result = 0 ;
22537 int val1 ;
22538 int ecode1 = 0 ;
22539 int val2 ;
22540 int ecode2 = 0 ;
22541 PyObject * obj0 = 0 ;
22542 PyObject * obj1 = 0 ;
22543 char * kwnames[] = {
22544 (char *) "x",(char *) "y", NULL
22545 };
22546
22547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22548 if (obj0) {
22549 ecode1 = SWIG_AsVal_int(obj0, &val1);
22550 if (!SWIG_IsOK(ecode1)) {
22551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22552 }
22553 arg1 = static_cast< int >(val1);
22554 }
22555 if (obj1) {
22556 ecode2 = SWIG_AsVal_int(obj1, &val2);
22557 if (!SWIG_IsOK(ecode2)) {
22558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22559 }
22560 arg2 = static_cast< int >(val2);
22561 }
22562 {
22563 PyThreadState* __tstate = wxPyBeginAllowThreads();
22564 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22576 PyObject *resultobj = 0;
22577 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22578 int result;
22579 void *argp1 = 0 ;
22580 int res1 = 0 ;
22581 PyObject *swig_obj[1] ;
22582
22583 if (!args) SWIG_fail;
22584 swig_obj[0] = args;
22585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22586 if (!SWIG_IsOK(res1)) {
22587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22588 }
22589 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22593 wxPyEndAllowThreads(__tstate);
22594 if (PyErr_Occurred()) SWIG_fail;
22595 }
22596 resultobj = SWIG_From_int(static_cast< int >(result));
22597 return resultobj;
22598 fail:
22599 return NULL;
22600 }
22601
22602
22603 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22604 PyObject *resultobj = 0;
22605 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22606 int result;
22607 void *argp1 = 0 ;
22608 int res1 = 0 ;
22609 PyObject *swig_obj[1] ;
22610
22611 if (!args) SWIG_fail;
22612 swig_obj[0] = args;
22613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22614 if (!SWIG_IsOK(res1)) {
22615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22616 }
22617 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22618 {
22619 PyThreadState* __tstate = wxPyBeginAllowThreads();
22620 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22621 wxPyEndAllowThreads(__tstate);
22622 if (PyErr_Occurred()) SWIG_fail;
22623 }
22624 resultobj = SWIG_From_int(static_cast< int >(result));
22625 return resultobj;
22626 fail:
22627 return NULL;
22628 }
22629
22630
22631 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22632 PyObject *resultobj = 0;
22633 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22634 wxCursor *arg2 = 0 ;
22635 void *argp1 = 0 ;
22636 int res1 = 0 ;
22637 void *argp2 = 0 ;
22638 int res2 = 0 ;
22639 PyObject * obj0 = 0 ;
22640 PyObject * obj1 = 0 ;
22641 char * kwnames[] = {
22642 (char *) "self",(char *) "cursor", NULL
22643 };
22644
22645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22647 if (!SWIG_IsOK(res1)) {
22648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22649 }
22650 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22652 if (!SWIG_IsOK(res2)) {
22653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22654 }
22655 if (!argp2) {
22656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22657 }
22658 arg2 = reinterpret_cast< wxCursor * >(argp2);
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 (arg1)->SetCursor((wxCursor const &)*arg2);
22662 wxPyEndAllowThreads(__tstate);
22663 if (PyErr_Occurred()) SWIG_fail;
22664 }
22665 resultobj = SWIG_Py_Void();
22666 return resultobj;
22667 fail:
22668 return NULL;
22669 }
22670
22671
22672 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22673 PyObject *resultobj = 0;
22674 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22675 wxCursor *result = 0 ;
22676 void *argp1 = 0 ;
22677 int res1 = 0 ;
22678 PyObject *swig_obj[1] ;
22679
22680 if (!args) SWIG_fail;
22681 swig_obj[0] = args;
22682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22683 if (!SWIG_IsOK(res1)) {
22684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22685 }
22686 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22687 {
22688 PyThreadState* __tstate = wxPyBeginAllowThreads();
22689 {
22690 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22691 result = (wxCursor *) &_result_ref;
22692 }
22693 wxPyEndAllowThreads(__tstate);
22694 if (PyErr_Occurred()) SWIG_fail;
22695 }
22696 {
22697 wxCursor* resultptr = new wxCursor(*result);
22698 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22699 }
22700 return resultobj;
22701 fail:
22702 return NULL;
22703 }
22704
22705
22706 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22707 PyObject *resultobj = 0;
22708 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22709 bool result;
22710 void *argp1 = 0 ;
22711 int res1 = 0 ;
22712 PyObject *swig_obj[1] ;
22713
22714 if (!args) SWIG_fail;
22715 swig_obj[0] = args;
22716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22717 if (!SWIG_IsOK(res1)) {
22718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22719 }
22720 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22721 {
22722 PyThreadState* __tstate = wxPyBeginAllowThreads();
22723 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22724 wxPyEndAllowThreads(__tstate);
22725 if (PyErr_Occurred()) SWIG_fail;
22726 }
22727 {
22728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22729 }
22730 return resultobj;
22731 fail:
22732 return NULL;
22733 }
22734
22735
22736 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22737 PyObject *obj;
22738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22739 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22740 return SWIG_Py_Void();
22741 }
22742
22743 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22744 return SWIG_Python_InitShadowInstance(args);
22745 }
22746
22747 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22748 PyObject *resultobj = 0;
22749 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22750 wxKeyEvent *result = 0 ;
22751 int val1 ;
22752 int ecode1 = 0 ;
22753 PyObject * obj0 = 0 ;
22754 char * kwnames[] = {
22755 (char *) "eventType", NULL
22756 };
22757
22758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22759 if (obj0) {
22760 ecode1 = SWIG_AsVal_int(obj0, &val1);
22761 if (!SWIG_IsOK(ecode1)) {
22762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22763 }
22764 arg1 = static_cast< wxEventType >(val1);
22765 }
22766 {
22767 PyThreadState* __tstate = wxPyBeginAllowThreads();
22768 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22769 wxPyEndAllowThreads(__tstate);
22770 if (PyErr_Occurred()) SWIG_fail;
22771 }
22772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22773 return resultobj;
22774 fail:
22775 return NULL;
22776 }
22777
22778
22779 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22780 PyObject *resultobj = 0;
22781 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22782 int result;
22783 void *argp1 = 0 ;
22784 int res1 = 0 ;
22785 PyObject *swig_obj[1] ;
22786
22787 if (!args) SWIG_fail;
22788 swig_obj[0] = args;
22789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22790 if (!SWIG_IsOK(res1)) {
22791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22792 }
22793 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22794 {
22795 PyThreadState* __tstate = wxPyBeginAllowThreads();
22796 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22797 wxPyEndAllowThreads(__tstate);
22798 if (PyErr_Occurred()) SWIG_fail;
22799 }
22800 resultobj = SWIG_From_int(static_cast< int >(result));
22801 return resultobj;
22802 fail:
22803 return NULL;
22804 }
22805
22806
22807 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22808 PyObject *resultobj = 0;
22809 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22810 bool result;
22811 void *argp1 = 0 ;
22812 int res1 = 0 ;
22813 PyObject *swig_obj[1] ;
22814
22815 if (!args) SWIG_fail;
22816 swig_obj[0] = args;
22817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22818 if (!SWIG_IsOK(res1)) {
22819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22820 }
22821 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22822 {
22823 PyThreadState* __tstate = wxPyBeginAllowThreads();
22824 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22825 wxPyEndAllowThreads(__tstate);
22826 if (PyErr_Occurred()) SWIG_fail;
22827 }
22828 {
22829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22830 }
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22838 PyObject *resultobj = 0;
22839 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22840 bool result;
22841 void *argp1 = 0 ;
22842 int res1 = 0 ;
22843 PyObject *swig_obj[1] ;
22844
22845 if (!args) SWIG_fail;
22846 swig_obj[0] = args;
22847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22848 if (!SWIG_IsOK(res1)) {
22849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22850 }
22851 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22855 wxPyEndAllowThreads(__tstate);
22856 if (PyErr_Occurred()) SWIG_fail;
22857 }
22858 {
22859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22860 }
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 PyObject *resultobj = 0;
22869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22870 bool result;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 PyObject *swig_obj[1] ;
22874
22875 if (!args) SWIG_fail;
22876 swig_obj[0] = args;
22877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22878 if (!SWIG_IsOK(res1)) {
22879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22880 }
22881 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 {
22889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22890 }
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 PyObject *swig_obj[1] ;
22904
22905 if (!args) SWIG_fail;
22906 swig_obj[0] = args;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22910 }
22911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22928 PyObject *resultobj = 0;
22929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22930 bool result;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 PyObject *swig_obj[1] ;
22934
22935 if (!args) SWIG_fail;
22936 swig_obj[0] = args;
22937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22938 if (!SWIG_IsOK(res1)) {
22939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22940 }
22941 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22942 {
22943 PyThreadState* __tstate = wxPyBeginAllowThreads();
22944 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 {
22949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22950 }
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22958 PyObject *resultobj = 0;
22959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22960 bool result;
22961 void *argp1 = 0 ;
22962 int res1 = 0 ;
22963 PyObject *swig_obj[1] ;
22964
22965 if (!args) SWIG_fail;
22966 swig_obj[0] = args;
22967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22968 if (!SWIG_IsOK(res1)) {
22969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22970 }
22971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22975 wxPyEndAllowThreads(__tstate);
22976 if (PyErr_Occurred()) SWIG_fail;
22977 }
22978 {
22979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22980 }
22981 return resultobj;
22982 fail:
22983 return NULL;
22984 }
22985
22986
22987 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22988 PyObject *resultobj = 0;
22989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22990 int result;
22991 void *argp1 = 0 ;
22992 int res1 = 0 ;
22993 PyObject *swig_obj[1] ;
22994
22995 if (!args) SWIG_fail;
22996 swig_obj[0] = args;
22997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22998 if (!SWIG_IsOK(res1)) {
22999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23000 }
23001 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23002 {
23003 PyThreadState* __tstate = wxPyBeginAllowThreads();
23004 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
23005 wxPyEndAllowThreads(__tstate);
23006 if (PyErr_Occurred()) SWIG_fail;
23007 }
23008 resultobj = SWIG_From_int(static_cast< int >(result));
23009 return resultobj;
23010 fail:
23011 return NULL;
23012 }
23013
23014
23015 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23016 PyObject *resultobj = 0;
23017 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23018 int result;
23019 void *argp1 = 0 ;
23020 int res1 = 0 ;
23021 PyObject *swig_obj[1] ;
23022
23023 if (!args) SWIG_fail;
23024 swig_obj[0] = args;
23025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23026 if (!SWIG_IsOK(res1)) {
23027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23028 }
23029 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23033 wxPyEndAllowThreads(__tstate);
23034 if (PyErr_Occurred()) SWIG_fail;
23035 }
23036 resultobj = SWIG_From_int(static_cast< int >(result));
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23044 PyObject *resultobj = 0;
23045 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23046 int arg2 ;
23047 void *argp1 = 0 ;
23048 int res1 = 0 ;
23049 int val2 ;
23050 int ecode2 = 0 ;
23051 PyObject * obj0 = 0 ;
23052 PyObject * obj1 = 0 ;
23053 char * kwnames[] = {
23054 (char *) "self",(char *) "uniChar", NULL
23055 };
23056
23057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23059 if (!SWIG_IsOK(res1)) {
23060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23061 }
23062 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23063 ecode2 = SWIG_AsVal_int(obj1, &val2);
23064 if (!SWIG_IsOK(ecode2)) {
23065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23066 }
23067 arg2 = static_cast< int >(val2);
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 resultobj = SWIG_Py_Void();
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23084 unsigned int result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23112 unsigned int result;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23122 }
23123 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23138 PyObject *resultobj = 0;
23139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23140 wxPoint result;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 PyObject *swig_obj[1] ;
23144
23145 if (!args) SWIG_fail;
23146 swig_obj[0] = args;
23147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23150 }
23151 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 result = (arg1)->GetPosition();
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23159 return resultobj;
23160 fail:
23161 return NULL;
23162 }
23163
23164
23165 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23166 PyObject *resultobj = 0;
23167 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23168 long *arg2 = (long *) 0 ;
23169 long *arg3 = (long *) 0 ;
23170 void *argp1 = 0 ;
23171 int res1 = 0 ;
23172 long temp2 ;
23173 int res2 = SWIG_TMPOBJ ;
23174 long temp3 ;
23175 int res3 = SWIG_TMPOBJ ;
23176 PyObject *swig_obj[1] ;
23177
23178 arg2 = &temp2;
23179 arg3 = &temp3;
23180 if (!args) SWIG_fail;
23181 swig_obj[0] = args;
23182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23183 if (!SWIG_IsOK(res1)) {
23184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23185 }
23186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23187 {
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 (arg1)->GetPosition(arg2,arg3);
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 resultobj = SWIG_Py_Void();
23194 if (SWIG_IsTmpObj(res2)) {
23195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23196 } else {
23197 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23199 }
23200 if (SWIG_IsTmpObj(res3)) {
23201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23202 } else {
23203 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23205 }
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213 PyObject *resultobj = 0;
23214 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23215 int 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_wxKeyEvent, 0 | 0 );
23223 if (!SWIG_IsOK(res1)) {
23224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23225 }
23226 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = (int)((wxKeyEvent const *)arg1)->GetX();
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 resultobj = SWIG_From_int(static_cast< int >(result));
23234 return resultobj;
23235 fail:
23236 return NULL;
23237 }
23238
23239
23240 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23241 PyObject *resultobj = 0;
23242 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23243 int result;
23244 void *argp1 = 0 ;
23245 int res1 = 0 ;
23246 PyObject *swig_obj[1] ;
23247
23248 if (!args) SWIG_fail;
23249 swig_obj[0] = args;
23250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23251 if (!SWIG_IsOK(res1)) {
23252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23253 }
23254 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23255 {
23256 PyThreadState* __tstate = wxPyBeginAllowThreads();
23257 result = (int)((wxKeyEvent const *)arg1)->GetY();
23258 wxPyEndAllowThreads(__tstate);
23259 if (PyErr_Occurred()) SWIG_fail;
23260 }
23261 resultobj = SWIG_From_int(static_cast< int >(result));
23262 return resultobj;
23263 fail:
23264 return NULL;
23265 }
23266
23267
23268 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23269 PyObject *resultobj = 0;
23270 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23271 int arg2 ;
23272 void *argp1 = 0 ;
23273 int res1 = 0 ;
23274 int val2 ;
23275 int ecode2 = 0 ;
23276 PyObject *swig_obj[2] ;
23277
23278 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23280 if (!SWIG_IsOK(res1)) {
23281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23282 }
23283 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23284 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23285 if (!SWIG_IsOK(ecode2)) {
23286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23287 }
23288 arg2 = static_cast< int >(val2);
23289 if (arg1) (arg1)->m_x = arg2;
23290
23291 resultobj = SWIG_Py_Void();
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23299 PyObject *resultobj = 0;
23300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23301 int result;
23302 void *argp1 = 0 ;
23303 int res1 = 0 ;
23304 PyObject *swig_obj[1] ;
23305
23306 if (!args) SWIG_fail;
23307 swig_obj[0] = args;
23308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23309 if (!SWIG_IsOK(res1)) {
23310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23311 }
23312 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23313 result = (int) ((arg1)->m_x);
23314 resultobj = SWIG_From_int(static_cast< int >(result));
23315 return resultobj;
23316 fail:
23317 return NULL;
23318 }
23319
23320
23321 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 PyObject *resultobj = 0;
23323 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23324 int arg2 ;
23325 void *argp1 = 0 ;
23326 int res1 = 0 ;
23327 int val2 ;
23328 int ecode2 = 0 ;
23329 PyObject *swig_obj[2] ;
23330
23331 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23333 if (!SWIG_IsOK(res1)) {
23334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23335 }
23336 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23337 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23338 if (!SWIG_IsOK(ecode2)) {
23339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23340 }
23341 arg2 = static_cast< int >(val2);
23342 if (arg1) (arg1)->m_y = arg2;
23343
23344 resultobj = SWIG_Py_Void();
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23352 PyObject *resultobj = 0;
23353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23354 int result;
23355 void *argp1 = 0 ;
23356 int res1 = 0 ;
23357 PyObject *swig_obj[1] ;
23358
23359 if (!args) SWIG_fail;
23360 swig_obj[0] = args;
23361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23362 if (!SWIG_IsOK(res1)) {
23363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23364 }
23365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23366 result = (int) ((arg1)->m_y);
23367 resultobj = SWIG_From_int(static_cast< int >(result));
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 PyObject *resultobj = 0;
23376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23377 long arg2 ;
23378 void *argp1 = 0 ;
23379 int res1 = 0 ;
23380 long val2 ;
23381 int ecode2 = 0 ;
23382 PyObject *swig_obj[2] ;
23383
23384 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23386 if (!SWIG_IsOK(res1)) {
23387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23388 }
23389 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23390 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23391 if (!SWIG_IsOK(ecode2)) {
23392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23393 }
23394 arg2 = static_cast< long >(val2);
23395 if (arg1) (arg1)->m_keyCode = arg2;
23396
23397 resultobj = SWIG_Py_Void();
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23405 PyObject *resultobj = 0;
23406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23407 long result;
23408 void *argp1 = 0 ;
23409 int res1 = 0 ;
23410 PyObject *swig_obj[1] ;
23411
23412 if (!args) SWIG_fail;
23413 swig_obj[0] = args;
23414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23415 if (!SWIG_IsOK(res1)) {
23416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23417 }
23418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23419 result = (long) ((arg1)->m_keyCode);
23420 resultobj = SWIG_From_long(static_cast< long >(result));
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23428 PyObject *resultobj = 0;
23429 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23430 bool arg2 ;
23431 void *argp1 = 0 ;
23432 int res1 = 0 ;
23433 bool val2 ;
23434 int ecode2 = 0 ;
23435 PyObject *swig_obj[2] ;
23436
23437 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23439 if (!SWIG_IsOK(res1)) {
23440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23441 }
23442 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23443 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23444 if (!SWIG_IsOK(ecode2)) {
23445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23446 }
23447 arg2 = static_cast< bool >(val2);
23448 if (arg1) (arg1)->m_controlDown = arg2;
23449
23450 resultobj = SWIG_Py_Void();
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23458 PyObject *resultobj = 0;
23459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23460 bool result;
23461 void *argp1 = 0 ;
23462 int res1 = 0 ;
23463 PyObject *swig_obj[1] ;
23464
23465 if (!args) SWIG_fail;
23466 swig_obj[0] = args;
23467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23470 }
23471 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23472 result = (bool) ((arg1)->m_controlDown);
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_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23483 PyObject *resultobj = 0;
23484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23485 bool arg2 ;
23486 void *argp1 = 0 ;
23487 int res1 = 0 ;
23488 bool val2 ;
23489 int ecode2 = 0 ;
23490 PyObject *swig_obj[2] ;
23491
23492 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23494 if (!SWIG_IsOK(res1)) {
23495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23496 }
23497 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23498 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23499 if (!SWIG_IsOK(ecode2)) {
23500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23501 }
23502 arg2 = static_cast< bool >(val2);
23503 if (arg1) (arg1)->m_shiftDown = arg2;
23504
23505 resultobj = SWIG_Py_Void();
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23513 PyObject *resultobj = 0;
23514 wxKeyEvent *arg1 = (wxKeyEvent *) 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_wxKeyEvent, 0 | 0 );
23523 if (!SWIG_IsOK(res1)) {
23524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23525 }
23526 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23527 result = (bool) ((arg1)->m_shiftDown);
23528 {
23529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23530 }
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23538 PyObject *resultobj = 0;
23539 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23540 bool arg2 ;
23541 void *argp1 = 0 ;
23542 int res1 = 0 ;
23543 bool val2 ;
23544 int ecode2 = 0 ;
23545 PyObject *swig_obj[2] ;
23546
23547 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23549 if (!SWIG_IsOK(res1)) {
23550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23551 }
23552 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23553 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23554 if (!SWIG_IsOK(ecode2)) {
23555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23556 }
23557 arg2 = static_cast< bool >(val2);
23558 if (arg1) (arg1)->m_altDown = arg2;
23559
23560 resultobj = SWIG_Py_Void();
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23568 PyObject *resultobj = 0;
23569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23570 bool result;
23571 void *argp1 = 0 ;
23572 int res1 = 0 ;
23573 PyObject *swig_obj[1] ;
23574
23575 if (!args) SWIG_fail;
23576 swig_obj[0] = args;
23577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23578 if (!SWIG_IsOK(res1)) {
23579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23580 }
23581 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23582 result = (bool) ((arg1)->m_altDown);
23583 {
23584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23585 }
23586 return resultobj;
23587 fail:
23588 return NULL;
23589 }
23590
23591
23592 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23593 PyObject *resultobj = 0;
23594 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23595 bool arg2 ;
23596 void *argp1 = 0 ;
23597 int res1 = 0 ;
23598 bool val2 ;
23599 int ecode2 = 0 ;
23600 PyObject *swig_obj[2] ;
23601
23602 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23604 if (!SWIG_IsOK(res1)) {
23605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23606 }
23607 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23608 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23609 if (!SWIG_IsOK(ecode2)) {
23610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23611 }
23612 arg2 = static_cast< bool >(val2);
23613 if (arg1) (arg1)->m_metaDown = arg2;
23614
23615 resultobj = SWIG_Py_Void();
23616 return resultobj;
23617 fail:
23618 return NULL;
23619 }
23620
23621
23622 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23623 PyObject *resultobj = 0;
23624 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23625 bool result;
23626 void *argp1 = 0 ;
23627 int res1 = 0 ;
23628 PyObject *swig_obj[1] ;
23629
23630 if (!args) SWIG_fail;
23631 swig_obj[0] = args;
23632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23633 if (!SWIG_IsOK(res1)) {
23634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23635 }
23636 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23637 result = (bool) ((arg1)->m_metaDown);
23638 {
23639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 PyObject *resultobj = 0;
23649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23650 bool arg2 ;
23651 void *argp1 = 0 ;
23652 int res1 = 0 ;
23653 bool val2 ;
23654 int ecode2 = 0 ;
23655 PyObject *swig_obj[2] ;
23656
23657 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23659 if (!SWIG_IsOK(res1)) {
23660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23661 }
23662 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23663 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23664 if (!SWIG_IsOK(ecode2)) {
23665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23666 }
23667 arg2 = static_cast< bool >(val2);
23668 if (arg1) (arg1)->m_scanCode = arg2;
23669
23670 resultobj = SWIG_Py_Void();
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23680 bool result;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 PyObject *swig_obj[1] ;
23684
23685 if (!args) SWIG_fail;
23686 swig_obj[0] = args;
23687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23688 if (!SWIG_IsOK(res1)) {
23689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23690 }
23691 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23692 result = (bool) ((arg1)->m_scanCode);
23693 {
23694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23695 }
23696 return resultobj;
23697 fail:
23698 return NULL;
23699 }
23700
23701
23702 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23703 PyObject *resultobj = 0;
23704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23705 unsigned int arg2 ;
23706 void *argp1 = 0 ;
23707 int res1 = 0 ;
23708 unsigned int val2 ;
23709 int ecode2 = 0 ;
23710 PyObject *swig_obj[2] ;
23711
23712 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23714 if (!SWIG_IsOK(res1)) {
23715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23716 }
23717 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23718 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23719 if (!SWIG_IsOK(ecode2)) {
23720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23721 }
23722 arg2 = static_cast< unsigned int >(val2);
23723 if (arg1) (arg1)->m_rawCode = arg2;
23724
23725 resultobj = SWIG_Py_Void();
23726 return resultobj;
23727 fail:
23728 return NULL;
23729 }
23730
23731
23732 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23733 PyObject *resultobj = 0;
23734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23735 unsigned int result;
23736 void *argp1 = 0 ;
23737 int res1 = 0 ;
23738 PyObject *swig_obj[1] ;
23739
23740 if (!args) SWIG_fail;
23741 swig_obj[0] = args;
23742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23745 }
23746 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23747 result = (unsigned int) ((arg1)->m_rawCode);
23748 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23749 return resultobj;
23750 fail:
23751 return NULL;
23752 }
23753
23754
23755 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23756 PyObject *resultobj = 0;
23757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23758 unsigned int arg2 ;
23759 void *argp1 = 0 ;
23760 int res1 = 0 ;
23761 unsigned int val2 ;
23762 int ecode2 = 0 ;
23763 PyObject *swig_obj[2] ;
23764
23765 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23767 if (!SWIG_IsOK(res1)) {
23768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23769 }
23770 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23771 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23772 if (!SWIG_IsOK(ecode2)) {
23773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23774 }
23775 arg2 = static_cast< unsigned int >(val2);
23776 if (arg1) (arg1)->m_rawFlags = arg2;
23777
23778 resultobj = SWIG_Py_Void();
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23786 PyObject *resultobj = 0;
23787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23788 unsigned int result;
23789 void *argp1 = 0 ;
23790 int res1 = 0 ;
23791 PyObject *swig_obj[1] ;
23792
23793 if (!args) SWIG_fail;
23794 swig_obj[0] = args;
23795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23796 if (!SWIG_IsOK(res1)) {
23797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23798 }
23799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23800 result = (unsigned int) ((arg1)->m_rawFlags);
23801 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 wxSize const &arg1_defvalue = wxDefaultSize ;
23822 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23823 int arg2 = (int) 0 ;
23824 wxSizeEvent *result = 0 ;
23825 wxSize temp1 ;
23826 int val2 ;
23827 int ecode2 = 0 ;
23828 PyObject * obj0 = 0 ;
23829 PyObject * obj1 = 0 ;
23830 char * kwnames[] = {
23831 (char *) "sz",(char *) "winid", NULL
23832 };
23833
23834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23835 if (obj0) {
23836 {
23837 arg1 = &temp1;
23838 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23839 }
23840 }
23841 if (obj1) {
23842 ecode2 = SWIG_AsVal_int(obj1, &val2);
23843 if (!SWIG_IsOK(ecode2)) {
23844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23845 }
23846 arg2 = static_cast< int >(val2);
23847 }
23848 {
23849 PyThreadState* __tstate = wxPyBeginAllowThreads();
23850 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23851 wxPyEndAllowThreads(__tstate);
23852 if (PyErr_Occurred()) SWIG_fail;
23853 }
23854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23855 return resultobj;
23856 fail:
23857 return NULL;
23858 }
23859
23860
23861 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23862 PyObject *resultobj = 0;
23863 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23864 wxSize result;
23865 void *argp1 = 0 ;
23866 int res1 = 0 ;
23867 PyObject *swig_obj[1] ;
23868
23869 if (!args) SWIG_fail;
23870 swig_obj[0] = args;
23871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23872 if (!SWIG_IsOK(res1)) {
23873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23874 }
23875 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = ((wxSizeEvent const *)arg1)->GetSize();
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23883 return resultobj;
23884 fail:
23885 return NULL;
23886 }
23887
23888
23889 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23890 PyObject *resultobj = 0;
23891 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23892 wxRect result;
23893 void *argp1 = 0 ;
23894 int res1 = 0 ;
23895 PyObject *swig_obj[1] ;
23896
23897 if (!args) SWIG_fail;
23898 swig_obj[0] = args;
23899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23900 if (!SWIG_IsOK(res1)) {
23901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23902 }
23903 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 result = ((wxSizeEvent const *)arg1)->GetRect();
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23918 PyObject *resultobj = 0;
23919 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23920 wxRect arg2 ;
23921 void *argp1 = 0 ;
23922 int res1 = 0 ;
23923 void *argp2 ;
23924 int res2 = 0 ;
23925 PyObject * obj0 = 0 ;
23926 PyObject * obj1 = 0 ;
23927 char * kwnames[] = {
23928 (char *) "self",(char *) "rect", NULL
23929 };
23930
23931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23933 if (!SWIG_IsOK(res1)) {
23934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23935 }
23936 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23937 {
23938 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23939 if (!SWIG_IsOK(res2)) {
23940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23941 }
23942 if (!argp2) {
23943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23944 } else {
23945 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23946 arg2 = *temp;
23947 if (SWIG_IsNewObj(res2)) delete temp;
23948 }
23949 }
23950 {
23951 PyThreadState* __tstate = wxPyBeginAllowThreads();
23952 (arg1)->SetRect(arg2);
23953 wxPyEndAllowThreads(__tstate);
23954 if (PyErr_Occurred()) SWIG_fail;
23955 }
23956 resultobj = SWIG_Py_Void();
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23964 PyObject *resultobj = 0;
23965 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23966 wxSize arg2 ;
23967 void *argp1 = 0 ;
23968 int res1 = 0 ;
23969 void *argp2 ;
23970 int res2 = 0 ;
23971 PyObject * obj0 = 0 ;
23972 PyObject * obj1 = 0 ;
23973 char * kwnames[] = {
23974 (char *) "self",(char *) "size", NULL
23975 };
23976
23977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23979 if (!SWIG_IsOK(res1)) {
23980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23981 }
23982 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23983 {
23984 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23985 if (!SWIG_IsOK(res2)) {
23986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23987 }
23988 if (!argp2) {
23989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23990 } else {
23991 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23992 arg2 = *temp;
23993 if (SWIG_IsNewObj(res2)) delete temp;
23994 }
23995 }
23996 {
23997 PyThreadState* __tstate = wxPyBeginAllowThreads();
23998 wxSizeEvent_SetSize(arg1,arg2);
23999 wxPyEndAllowThreads(__tstate);
24000 if (PyErr_Occurred()) SWIG_fail;
24001 }
24002 resultobj = SWIG_Py_Void();
24003 return resultobj;
24004 fail:
24005 return NULL;
24006 }
24007
24008
24009 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24010 PyObject *resultobj = 0;
24011 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24012 wxSize *arg2 = (wxSize *) 0 ;
24013 void *argp1 = 0 ;
24014 int res1 = 0 ;
24015 void *argp2 = 0 ;
24016 int res2 = 0 ;
24017 PyObject *swig_obj[2] ;
24018
24019 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24021 if (!SWIG_IsOK(res1)) {
24022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24023 }
24024 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24025 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24026 if (!SWIG_IsOK(res2)) {
24027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24028 }
24029 arg2 = reinterpret_cast< wxSize * >(argp2);
24030 if (arg1) (arg1)->m_size = *arg2;
24031
24032 resultobj = SWIG_Py_Void();
24033 return resultobj;
24034 fail:
24035 return NULL;
24036 }
24037
24038
24039 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24040 PyObject *resultobj = 0;
24041 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24042 wxSize *result = 0 ;
24043 void *argp1 = 0 ;
24044 int res1 = 0 ;
24045 PyObject *swig_obj[1] ;
24046
24047 if (!args) SWIG_fail;
24048 swig_obj[0] = args;
24049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24050 if (!SWIG_IsOK(res1)) {
24051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24052 }
24053 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24054 result = (wxSize *)& ((arg1)->m_size);
24055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24056 return resultobj;
24057 fail:
24058 return NULL;
24059 }
24060
24061
24062 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24063 PyObject *resultobj = 0;
24064 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24065 wxRect *arg2 = (wxRect *) 0 ;
24066 void *argp1 = 0 ;
24067 int res1 = 0 ;
24068 void *argp2 = 0 ;
24069 int res2 = 0 ;
24070 PyObject *swig_obj[2] ;
24071
24072 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24074 if (!SWIG_IsOK(res1)) {
24075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24076 }
24077 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24078 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24079 if (!SWIG_IsOK(res2)) {
24080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24081 }
24082 arg2 = reinterpret_cast< wxRect * >(argp2);
24083 if (arg1) (arg1)->m_rect = *arg2;
24084
24085 resultobj = SWIG_Py_Void();
24086 return resultobj;
24087 fail:
24088 return NULL;
24089 }
24090
24091
24092 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24093 PyObject *resultobj = 0;
24094 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24095 wxRect *result = 0 ;
24096 void *argp1 = 0 ;
24097 int res1 = 0 ;
24098 PyObject *swig_obj[1] ;
24099
24100 if (!args) SWIG_fail;
24101 swig_obj[0] = args;
24102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24103 if (!SWIG_IsOK(res1)) {
24104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24105 }
24106 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24107 result = (wxRect *)& ((arg1)->m_rect);
24108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *obj;
24117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24118 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24119 return SWIG_Py_Void();
24120 }
24121
24122 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24123 return SWIG_Python_InitShadowInstance(args);
24124 }
24125
24126 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj = 0;
24128 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24129 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24130 int arg2 = (int) 0 ;
24131 wxMoveEvent *result = 0 ;
24132 wxPoint temp1 ;
24133 int val2 ;
24134 int ecode2 = 0 ;
24135 PyObject * obj0 = 0 ;
24136 PyObject * obj1 = 0 ;
24137 char * kwnames[] = {
24138 (char *) "pos",(char *) "winid", NULL
24139 };
24140
24141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24142 if (obj0) {
24143 {
24144 arg1 = &temp1;
24145 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24146 }
24147 }
24148 if (obj1) {
24149 ecode2 = SWIG_AsVal_int(obj1, &val2);
24150 if (!SWIG_IsOK(ecode2)) {
24151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24152 }
24153 arg2 = static_cast< int >(val2);
24154 }
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24169 PyObject *resultobj = 0;
24170 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24171 wxPoint result;
24172 void *argp1 = 0 ;
24173 int res1 = 0 ;
24174 PyObject *swig_obj[1] ;
24175
24176 if (!args) SWIG_fail;
24177 swig_obj[0] = args;
24178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24179 if (!SWIG_IsOK(res1)) {
24180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24181 }
24182 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 result = ((wxMoveEvent const *)arg1)->GetPosition();
24186 wxPyEndAllowThreads(__tstate);
24187 if (PyErr_Occurred()) SWIG_fail;
24188 }
24189 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24190 return resultobj;
24191 fail:
24192 return NULL;
24193 }
24194
24195
24196 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197 PyObject *resultobj = 0;
24198 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24199 wxRect result;
24200 void *argp1 = 0 ;
24201 int res1 = 0 ;
24202 PyObject *swig_obj[1] ;
24203
24204 if (!args) SWIG_fail;
24205 swig_obj[0] = args;
24206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24207 if (!SWIG_IsOK(res1)) {
24208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24209 }
24210 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24211 {
24212 PyThreadState* __tstate = wxPyBeginAllowThreads();
24213 result = ((wxMoveEvent const *)arg1)->GetRect();
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = 0;
24226 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24227 wxRect *arg2 = 0 ;
24228 void *argp1 = 0 ;
24229 int res1 = 0 ;
24230 wxRect temp2 ;
24231 PyObject * obj0 = 0 ;
24232 PyObject * obj1 = 0 ;
24233 char * kwnames[] = {
24234 (char *) "self",(char *) "rect", NULL
24235 };
24236
24237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24239 if (!SWIG_IsOK(res1)) {
24240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24241 }
24242 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24243 {
24244 arg2 = &temp2;
24245 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24246 }
24247 {
24248 PyThreadState* __tstate = wxPyBeginAllowThreads();
24249 (arg1)->SetRect((wxRect const &)*arg2);
24250 wxPyEndAllowThreads(__tstate);
24251 if (PyErr_Occurred()) SWIG_fail;
24252 }
24253 resultobj = SWIG_Py_Void();
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24261 PyObject *resultobj = 0;
24262 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24263 wxPoint *arg2 = 0 ;
24264 void *argp1 = 0 ;
24265 int res1 = 0 ;
24266 wxPoint temp2 ;
24267 PyObject * obj0 = 0 ;
24268 PyObject * obj1 = 0 ;
24269 char * kwnames[] = {
24270 (char *) "self",(char *) "pos", NULL
24271 };
24272
24273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24277 }
24278 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24279 {
24280 arg2 = &temp2;
24281 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24282 }
24283 {
24284 PyThreadState* __tstate = wxPyBeginAllowThreads();
24285 (arg1)->SetPosition((wxPoint const &)*arg2);
24286 wxPyEndAllowThreads(__tstate);
24287 if (PyErr_Occurred()) SWIG_fail;
24288 }
24289 resultobj = SWIG_Py_Void();
24290 return resultobj;
24291 fail:
24292 return NULL;
24293 }
24294
24295
24296 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24297 PyObject *obj;
24298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24299 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24300 return SWIG_Py_Void();
24301 }
24302
24303 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24304 return SWIG_Python_InitShadowInstance(args);
24305 }
24306
24307 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24308 PyObject *resultobj = 0;
24309 int arg1 = (int) 0 ;
24310 wxPaintEvent *result = 0 ;
24311 int val1 ;
24312 int ecode1 = 0 ;
24313 PyObject * obj0 = 0 ;
24314 char * kwnames[] = {
24315 (char *) "Id", NULL
24316 };
24317
24318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24319 if (obj0) {
24320 ecode1 = SWIG_AsVal_int(obj0, &val1);
24321 if (!SWIG_IsOK(ecode1)) {
24322 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24323 }
24324 arg1 = static_cast< int >(val1);
24325 }
24326 {
24327 PyThreadState* __tstate = wxPyBeginAllowThreads();
24328 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24329 wxPyEndAllowThreads(__tstate);
24330 if (PyErr_Occurred()) SWIG_fail;
24331 }
24332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *obj;
24341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24342 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24343 return SWIG_Py_Void();
24344 }
24345
24346 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24347 return SWIG_Python_InitShadowInstance(args);
24348 }
24349
24350 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 int arg1 = (int) 0 ;
24353 wxNcPaintEvent *result = 0 ;
24354 int val1 ;
24355 int ecode1 = 0 ;
24356 PyObject * obj0 = 0 ;
24357 char * kwnames[] = {
24358 (char *) "winid", NULL
24359 };
24360
24361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24362 if (obj0) {
24363 ecode1 = SWIG_AsVal_int(obj0, &val1);
24364 if (!SWIG_IsOK(ecode1)) {
24365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24366 }
24367 arg1 = static_cast< int >(val1);
24368 }
24369 {
24370 PyThreadState* __tstate = wxPyBeginAllowThreads();
24371 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24372 wxPyEndAllowThreads(__tstate);
24373 if (PyErr_Occurred()) SWIG_fail;
24374 }
24375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24376 return resultobj;
24377 fail:
24378 return NULL;
24379 }
24380
24381
24382 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24383 PyObject *obj;
24384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24385 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24386 return SWIG_Py_Void();
24387 }
24388
24389 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24390 return SWIG_Python_InitShadowInstance(args);
24391 }
24392
24393 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24394 PyObject *resultobj = 0;
24395 int arg1 = (int) 0 ;
24396 wxDC *arg2 = (wxDC *) NULL ;
24397 wxEraseEvent *result = 0 ;
24398 int val1 ;
24399 int ecode1 = 0 ;
24400 void *argp2 = 0 ;
24401 int res2 = 0 ;
24402 PyObject * obj0 = 0 ;
24403 PyObject * obj1 = 0 ;
24404 char * kwnames[] = {
24405 (char *) "Id",(char *) "dc", NULL
24406 };
24407
24408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24409 if (obj0) {
24410 ecode1 = SWIG_AsVal_int(obj0, &val1);
24411 if (!SWIG_IsOK(ecode1)) {
24412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24413 }
24414 arg1 = static_cast< int >(val1);
24415 }
24416 if (obj1) {
24417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24418 if (!SWIG_IsOK(res2)) {
24419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24420 }
24421 arg2 = reinterpret_cast< wxDC * >(argp2);
24422 }
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24437 PyObject *resultobj = 0;
24438 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24439 wxDC *result = 0 ;
24440 void *argp1 = 0 ;
24441 int res1 = 0 ;
24442 PyObject *swig_obj[1] ;
24443
24444 if (!args) SWIG_fail;
24445 swig_obj[0] = args;
24446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24447 if (!SWIG_IsOK(res1)) {
24448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24449 }
24450 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 {
24458 resultobj = wxPyMake_wxObject(result, (bool)0);
24459 }
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24467 PyObject *obj;
24468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24469 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24470 return SWIG_Py_Void();
24471 }
24472
24473 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 return SWIG_Python_InitShadowInstance(args);
24475 }
24476
24477 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24478 PyObject *resultobj = 0;
24479 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24480 int arg2 = (int) 0 ;
24481 wxFocusEvent *result = 0 ;
24482 int val1 ;
24483 int ecode1 = 0 ;
24484 int val2 ;
24485 int ecode2 = 0 ;
24486 PyObject * obj0 = 0 ;
24487 PyObject * obj1 = 0 ;
24488 char * kwnames[] = {
24489 (char *) "type",(char *) "winid", NULL
24490 };
24491
24492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24493 if (obj0) {
24494 ecode1 = SWIG_AsVal_int(obj0, &val1);
24495 if (!SWIG_IsOK(ecode1)) {
24496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24497 }
24498 arg1 = static_cast< wxEventType >(val1);
24499 }
24500 if (obj1) {
24501 ecode2 = SWIG_AsVal_int(obj1, &val2);
24502 if (!SWIG_IsOK(ecode2)) {
24503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24504 }
24505 arg2 = static_cast< int >(val2);
24506 }
24507 {
24508 PyThreadState* __tstate = wxPyBeginAllowThreads();
24509 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24514 return resultobj;
24515 fail:
24516 return NULL;
24517 }
24518
24519
24520 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24521 PyObject *resultobj = 0;
24522 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24523 wxWindow *result = 0 ;
24524 void *argp1 = 0 ;
24525 int res1 = 0 ;
24526 PyObject *swig_obj[1] ;
24527
24528 if (!args) SWIG_fail;
24529 swig_obj[0] = args;
24530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24531 if (!SWIG_IsOK(res1)) {
24532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24533 }
24534 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24535 {
24536 PyThreadState* __tstate = wxPyBeginAllowThreads();
24537 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 {
24542 resultobj = wxPyMake_wxObject(result, (bool)0);
24543 }
24544 return resultobj;
24545 fail:
24546 return NULL;
24547 }
24548
24549
24550 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24551 PyObject *resultobj = 0;
24552 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24553 wxWindow *arg2 = (wxWindow *) 0 ;
24554 void *argp1 = 0 ;
24555 int res1 = 0 ;
24556 void *argp2 = 0 ;
24557 int res2 = 0 ;
24558 PyObject * obj0 = 0 ;
24559 PyObject * obj1 = 0 ;
24560 char * kwnames[] = {
24561 (char *) "self",(char *) "win", NULL
24562 };
24563
24564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24566 if (!SWIG_IsOK(res1)) {
24567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24568 }
24569 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24571 if (!SWIG_IsOK(res2)) {
24572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24573 }
24574 arg2 = reinterpret_cast< wxWindow * >(argp2);
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 (arg1)->SetWindow(arg2);
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 resultobj = SWIG_Py_Void();
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24589 PyObject *obj;
24590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24591 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24592 return SWIG_Py_Void();
24593 }
24594
24595 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 return SWIG_Python_InitShadowInstance(args);
24597 }
24598
24599 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj = 0;
24601 wxWindow *arg1 = (wxWindow *) NULL ;
24602 wxChildFocusEvent *result = 0 ;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject * obj0 = 0 ;
24606 char * kwnames[] = {
24607 (char *) "win", NULL
24608 };
24609
24610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24611 if (obj0) {
24612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24613 if (!SWIG_IsOK(res1)) {
24614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24615 }
24616 arg1 = reinterpret_cast< wxWindow * >(argp1);
24617 }
24618 {
24619 PyThreadState* __tstate = wxPyBeginAllowThreads();
24620 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24621 wxPyEndAllowThreads(__tstate);
24622 if (PyErr_Occurred()) SWIG_fail;
24623 }
24624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24625 return resultobj;
24626 fail:
24627 return NULL;
24628 }
24629
24630
24631 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24632 PyObject *resultobj = 0;
24633 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24634 wxWindow *result = 0 ;
24635 void *argp1 = 0 ;
24636 int res1 = 0 ;
24637 PyObject *swig_obj[1] ;
24638
24639 if (!args) SWIG_fail;
24640 swig_obj[0] = args;
24641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24642 if (!SWIG_IsOK(res1)) {
24643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24644 }
24645 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24649 wxPyEndAllowThreads(__tstate);
24650 if (PyErr_Occurred()) SWIG_fail;
24651 }
24652 {
24653 resultobj = wxPyMake_wxObject(result, (bool)0);
24654 }
24655 return resultobj;
24656 fail:
24657 return NULL;
24658 }
24659
24660
24661 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24662 PyObject *obj;
24663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24664 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24665 return SWIG_Py_Void();
24666 }
24667
24668 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24669 return SWIG_Python_InitShadowInstance(args);
24670 }
24671
24672 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24673 PyObject *resultobj = 0;
24674 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24675 bool arg2 = (bool) true ;
24676 int arg3 = (int) 0 ;
24677 wxActivateEvent *result = 0 ;
24678 int val1 ;
24679 int ecode1 = 0 ;
24680 bool val2 ;
24681 int ecode2 = 0 ;
24682 int val3 ;
24683 int ecode3 = 0 ;
24684 PyObject * obj0 = 0 ;
24685 PyObject * obj1 = 0 ;
24686 PyObject * obj2 = 0 ;
24687 char * kwnames[] = {
24688 (char *) "type",(char *) "active",(char *) "Id", NULL
24689 };
24690
24691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24692 if (obj0) {
24693 ecode1 = SWIG_AsVal_int(obj0, &val1);
24694 if (!SWIG_IsOK(ecode1)) {
24695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24696 }
24697 arg1 = static_cast< wxEventType >(val1);
24698 }
24699 if (obj1) {
24700 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24701 if (!SWIG_IsOK(ecode2)) {
24702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24703 }
24704 arg2 = static_cast< bool >(val2);
24705 }
24706 if (obj2) {
24707 ecode3 = SWIG_AsVal_int(obj2, &val3);
24708 if (!SWIG_IsOK(ecode3)) {
24709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24710 }
24711 arg3 = static_cast< int >(val3);
24712 }
24713 {
24714 PyThreadState* __tstate = wxPyBeginAllowThreads();
24715 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24739 }
24740 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *obj;
24758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24759 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24760 return SWIG_Py_Void();
24761 }
24762
24763 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24764 return SWIG_Python_InitShadowInstance(args);
24765 }
24766
24767 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj = 0;
24769 int arg1 = (int) 0 ;
24770 wxInitDialogEvent *result = 0 ;
24771 int val1 ;
24772 int ecode1 = 0 ;
24773 PyObject * obj0 = 0 ;
24774 char * kwnames[] = {
24775 (char *) "Id", NULL
24776 };
24777
24778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24779 if (obj0) {
24780 ecode1 = SWIG_AsVal_int(obj0, &val1);
24781 if (!SWIG_IsOK(ecode1)) {
24782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24783 }
24784 arg1 = static_cast< int >(val1);
24785 }
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24800 PyObject *obj;
24801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24802 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24803 return SWIG_Py_Void();
24804 }
24805
24806 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24807 return SWIG_Python_InitShadowInstance(args);
24808 }
24809
24810 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj = 0;
24812 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24813 int arg2 = (int) 0 ;
24814 wxMenu *arg3 = (wxMenu *) NULL ;
24815 wxMenuEvent *result = 0 ;
24816 int val1 ;
24817 int ecode1 = 0 ;
24818 int val2 ;
24819 int ecode2 = 0 ;
24820 void *argp3 = 0 ;
24821 int res3 = 0 ;
24822 PyObject * obj0 = 0 ;
24823 PyObject * obj1 = 0 ;
24824 PyObject * obj2 = 0 ;
24825 char * kwnames[] = {
24826 (char *) "type",(char *) "winid",(char *) "menu", NULL
24827 };
24828
24829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24830 if (obj0) {
24831 ecode1 = SWIG_AsVal_int(obj0, &val1);
24832 if (!SWIG_IsOK(ecode1)) {
24833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24834 }
24835 arg1 = static_cast< wxEventType >(val1);
24836 }
24837 if (obj1) {
24838 ecode2 = SWIG_AsVal_int(obj1, &val2);
24839 if (!SWIG_IsOK(ecode2)) {
24840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24841 }
24842 arg2 = static_cast< int >(val2);
24843 }
24844 if (obj2) {
24845 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24846 if (!SWIG_IsOK(res3)) {
24847 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24848 }
24849 arg3 = reinterpret_cast< wxMenu * >(argp3);
24850 }
24851 {
24852 PyThreadState* __tstate = wxPyBeginAllowThreads();
24853 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24865 PyObject *resultobj = 0;
24866 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24867 int result;
24868 void *argp1 = 0 ;
24869 int res1 = 0 ;
24870 PyObject *swig_obj[1] ;
24871
24872 if (!args) SWIG_fail;
24873 swig_obj[0] = args;
24874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24875 if (!SWIG_IsOK(res1)) {
24876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24877 }
24878 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = SWIG_From_int(static_cast< int >(result));
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24893 PyObject *resultobj = 0;
24894 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24895 bool result;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 PyObject *swig_obj[1] ;
24899
24900 if (!args) SWIG_fail;
24901 swig_obj[0] = args;
24902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24903 if (!SWIG_IsOK(res1)) {
24904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24905 }
24906 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24907 {
24908 PyThreadState* __tstate = wxPyBeginAllowThreads();
24909 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24910 wxPyEndAllowThreads(__tstate);
24911 if (PyErr_Occurred()) SWIG_fail;
24912 }
24913 {
24914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24915 }
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24923 PyObject *resultobj = 0;
24924 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24925 wxMenu *result = 0 ;
24926 void *argp1 = 0 ;
24927 int res1 = 0 ;
24928 PyObject *swig_obj[1] ;
24929
24930 if (!args) SWIG_fail;
24931 swig_obj[0] = args;
24932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24933 if (!SWIG_IsOK(res1)) {
24934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24935 }
24936 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 {
24944 resultobj = wxPyMake_wxObject(result, (bool)0);
24945 }
24946 return resultobj;
24947 fail:
24948 return NULL;
24949 }
24950
24951
24952 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24953 PyObject *obj;
24954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24955 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24956 return SWIG_Py_Void();
24957 }
24958
24959 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24960 return SWIG_Python_InitShadowInstance(args);
24961 }
24962
24963 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24964 PyObject *resultobj = 0;
24965 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24966 int arg2 = (int) 0 ;
24967 wxCloseEvent *result = 0 ;
24968 int val1 ;
24969 int ecode1 = 0 ;
24970 int val2 ;
24971 int ecode2 = 0 ;
24972 PyObject * obj0 = 0 ;
24973 PyObject * obj1 = 0 ;
24974 char * kwnames[] = {
24975 (char *) "type",(char *) "winid", NULL
24976 };
24977
24978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24979 if (obj0) {
24980 ecode1 = SWIG_AsVal_int(obj0, &val1);
24981 if (!SWIG_IsOK(ecode1)) {
24982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24983 }
24984 arg1 = static_cast< wxEventType >(val1);
24985 }
24986 if (obj1) {
24987 ecode2 = SWIG_AsVal_int(obj1, &val2);
24988 if (!SWIG_IsOK(ecode2)) {
24989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24990 }
24991 arg2 = static_cast< int >(val2);
24992 }
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj = 0;
25008 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25009 bool arg2 ;
25010 void *argp1 = 0 ;
25011 int res1 = 0 ;
25012 bool val2 ;
25013 int ecode2 = 0 ;
25014 PyObject * obj0 = 0 ;
25015 PyObject * obj1 = 0 ;
25016 char * kwnames[] = {
25017 (char *) "self",(char *) "logOff", NULL
25018 };
25019
25020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25024 }
25025 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25027 if (!SWIG_IsOK(ecode2)) {
25028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25029 }
25030 arg2 = static_cast< bool >(val2);
25031 {
25032 PyThreadState* __tstate = wxPyBeginAllowThreads();
25033 (arg1)->SetLoggingOff(arg2);
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 resultobj = SWIG_Py_Void();
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25045 PyObject *resultobj = 0;
25046 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25047 bool result;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 PyObject *swig_obj[1] ;
25051
25052 if (!args) SWIG_fail;
25053 swig_obj[0] = args;
25054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25055 if (!SWIG_IsOK(res1)) {
25056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25057 }
25058 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 {
25066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25067 }
25068 return resultobj;
25069 fail:
25070 return NULL;
25071 }
25072
25073
25074 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25075 PyObject *resultobj = 0;
25076 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25077 bool arg2 = (bool) true ;
25078 void *argp1 = 0 ;
25079 int res1 = 0 ;
25080 bool val2 ;
25081 int ecode2 = 0 ;
25082 PyObject * obj0 = 0 ;
25083 PyObject * obj1 = 0 ;
25084 char * kwnames[] = {
25085 (char *) "self",(char *) "veto", NULL
25086 };
25087
25088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25092 }
25093 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25094 if (obj1) {
25095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25096 if (!SWIG_IsOK(ecode2)) {
25097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25098 }
25099 arg2 = static_cast< bool >(val2);
25100 }
25101 {
25102 PyThreadState* __tstate = wxPyBeginAllowThreads();
25103 (arg1)->Veto(arg2);
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 resultobj = SWIG_Py_Void();
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25115 PyObject *resultobj = 0;
25116 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25117 bool result;
25118 void *argp1 = 0 ;
25119 int res1 = 0 ;
25120 PyObject *swig_obj[1] ;
25121
25122 if (!args) SWIG_fail;
25123 swig_obj[0] = args;
25124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25125 if (!SWIG_IsOK(res1)) {
25126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25127 }
25128 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25129 {
25130 PyThreadState* __tstate = wxPyBeginAllowThreads();
25131 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 {
25136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj = 0;
25146 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25147 bool arg2 ;
25148 void *argp1 = 0 ;
25149 int res1 = 0 ;
25150 bool val2 ;
25151 int ecode2 = 0 ;
25152 PyObject * obj0 = 0 ;
25153 PyObject * obj1 = 0 ;
25154 char * kwnames[] = {
25155 (char *) "self",(char *) "canVeto", NULL
25156 };
25157
25158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25160 if (!SWIG_IsOK(res1)) {
25161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25162 }
25163 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25165 if (!SWIG_IsOK(ecode2)) {
25166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25167 }
25168 arg2 = static_cast< bool >(val2);
25169 {
25170 PyThreadState* __tstate = wxPyBeginAllowThreads();
25171 (arg1)->SetCanVeto(arg2);
25172 wxPyEndAllowThreads(__tstate);
25173 if (PyErr_Occurred()) SWIG_fail;
25174 }
25175 resultobj = SWIG_Py_Void();
25176 return resultobj;
25177 fail:
25178 return NULL;
25179 }
25180
25181
25182 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25183 PyObject *resultobj = 0;
25184 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25185 bool result;
25186 void *argp1 = 0 ;
25187 int res1 = 0 ;
25188 PyObject *swig_obj[1] ;
25189
25190 if (!args) SWIG_fail;
25191 swig_obj[0] = args;
25192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25193 if (!SWIG_IsOK(res1)) {
25194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25195 }
25196 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 {
25204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25205 }
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25213 PyObject *obj;
25214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25215 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25216 return SWIG_Py_Void();
25217 }
25218
25219 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 return SWIG_Python_InitShadowInstance(args);
25221 }
25222
25223 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25224 PyObject *resultobj = 0;
25225 int arg1 = (int) 0 ;
25226 bool arg2 = (bool) false ;
25227 wxShowEvent *result = 0 ;
25228 int val1 ;
25229 int ecode1 = 0 ;
25230 bool val2 ;
25231 int ecode2 = 0 ;
25232 PyObject * obj0 = 0 ;
25233 PyObject * obj1 = 0 ;
25234 char * kwnames[] = {
25235 (char *) "winid",(char *) "show", NULL
25236 };
25237
25238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25239 if (obj0) {
25240 ecode1 = SWIG_AsVal_int(obj0, &val1);
25241 if (!SWIG_IsOK(ecode1)) {
25242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25243 }
25244 arg1 = static_cast< int >(val1);
25245 }
25246 if (obj1) {
25247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25248 if (!SWIG_IsOK(ecode2)) {
25249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25250 }
25251 arg2 = static_cast< bool >(val2);
25252 }
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj = 0;
25268 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25269 bool arg2 ;
25270 void *argp1 = 0 ;
25271 int res1 = 0 ;
25272 bool val2 ;
25273 int ecode2 = 0 ;
25274 PyObject * obj0 = 0 ;
25275 PyObject * obj1 = 0 ;
25276 char * kwnames[] = {
25277 (char *) "self",(char *) "show", NULL
25278 };
25279
25280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25282 if (!SWIG_IsOK(res1)) {
25283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25284 }
25285 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25286 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25287 if (!SWIG_IsOK(ecode2)) {
25288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25289 }
25290 arg2 = static_cast< bool >(val2);
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 (arg1)->SetShow(arg2);
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 resultobj = SWIG_Py_Void();
25298 return resultobj;
25299 fail:
25300 return NULL;
25301 }
25302
25303
25304 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25305 PyObject *resultobj = 0;
25306 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25307 bool result;
25308 void *argp1 = 0 ;
25309 int res1 = 0 ;
25310 PyObject *swig_obj[1] ;
25311
25312 if (!args) SWIG_fail;
25313 swig_obj[0] = args;
25314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25315 if (!SWIG_IsOK(res1)) {
25316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25317 }
25318 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 {
25326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25327 }
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25335 PyObject *obj;
25336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25337 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25338 return SWIG_Py_Void();
25339 }
25340
25341 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25342 return SWIG_Python_InitShadowInstance(args);
25343 }
25344
25345 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj = 0;
25347 int arg1 = (int) 0 ;
25348 bool arg2 = (bool) true ;
25349 wxIconizeEvent *result = 0 ;
25350 int val1 ;
25351 int ecode1 = 0 ;
25352 bool val2 ;
25353 int ecode2 = 0 ;
25354 PyObject * obj0 = 0 ;
25355 PyObject * obj1 = 0 ;
25356 char * kwnames[] = {
25357 (char *) "id",(char *) "iconized", NULL
25358 };
25359
25360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25361 if (obj0) {
25362 ecode1 = SWIG_AsVal_int(obj0, &val1);
25363 if (!SWIG_IsOK(ecode1)) {
25364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25365 }
25366 arg1 = static_cast< int >(val1);
25367 }
25368 if (obj1) {
25369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25370 if (!SWIG_IsOK(ecode2)) {
25371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25372 }
25373 arg2 = static_cast< bool >(val2);
25374 }
25375 {
25376 PyThreadState* __tstate = wxPyBeginAllowThreads();
25377 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25378 wxPyEndAllowThreads(__tstate);
25379 if (PyErr_Occurred()) SWIG_fail;
25380 }
25381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25389 PyObject *resultobj = 0;
25390 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25391 bool result;
25392 void *argp1 = 0 ;
25393 int res1 = 0 ;
25394 PyObject *swig_obj[1] ;
25395
25396 if (!args) SWIG_fail;
25397 swig_obj[0] = args;
25398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25399 if (!SWIG_IsOK(res1)) {
25400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25401 }
25402 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 result = (bool)(arg1)->Iconized();
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 {
25410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25411 }
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *obj;
25420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25421 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25422 return SWIG_Py_Void();
25423 }
25424
25425 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25426 return SWIG_Python_InitShadowInstance(args);
25427 }
25428
25429 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25430 PyObject *resultobj = 0;
25431 int arg1 = (int) 0 ;
25432 wxMaximizeEvent *result = 0 ;
25433 int val1 ;
25434 int ecode1 = 0 ;
25435 PyObject * obj0 = 0 ;
25436 char * kwnames[] = {
25437 (char *) "id", NULL
25438 };
25439
25440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25441 if (obj0) {
25442 ecode1 = SWIG_AsVal_int(obj0, &val1);
25443 if (!SWIG_IsOK(ecode1)) {
25444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25445 }
25446 arg1 = static_cast< int >(val1);
25447 }
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25451 wxPyEndAllowThreads(__tstate);
25452 if (PyErr_Occurred()) SWIG_fail;
25453 }
25454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25462 PyObject *obj;
25463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25464 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25465 return SWIG_Py_Void();
25466 }
25467
25468 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25469 return SWIG_Python_InitShadowInstance(args);
25470 }
25471
25472 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 PyObject *resultobj = 0;
25474 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25475 wxPoint result;
25476 void *argp1 = 0 ;
25477 int res1 = 0 ;
25478 PyObject *swig_obj[1] ;
25479
25480 if (!args) SWIG_fail;
25481 swig_obj[0] = args;
25482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25483 if (!SWIG_IsOK(res1)) {
25484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25485 }
25486 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25487 {
25488 PyThreadState* __tstate = wxPyBeginAllowThreads();
25489 result = (arg1)->GetPosition();
25490 wxPyEndAllowThreads(__tstate);
25491 if (PyErr_Occurred()) SWIG_fail;
25492 }
25493 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25501 PyObject *resultobj = 0;
25502 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25503 int result;
25504 void *argp1 = 0 ;
25505 int res1 = 0 ;
25506 PyObject *swig_obj[1] ;
25507
25508 if (!args) SWIG_fail;
25509 swig_obj[0] = args;
25510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25511 if (!SWIG_IsOK(res1)) {
25512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25513 }
25514 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 result = (int)(arg1)->GetNumberOfFiles();
25518 wxPyEndAllowThreads(__tstate);
25519 if (PyErr_Occurred()) SWIG_fail;
25520 }
25521 resultobj = SWIG_From_int(static_cast< int >(result));
25522 return resultobj;
25523 fail:
25524 return NULL;
25525 }
25526
25527
25528 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25529 PyObject *resultobj = 0;
25530 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25531 PyObject *result = 0 ;
25532 void *argp1 = 0 ;
25533 int res1 = 0 ;
25534 PyObject *swig_obj[1] ;
25535
25536 if (!args) SWIG_fail;
25537 swig_obj[0] = args;
25538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25539 if (!SWIG_IsOK(res1)) {
25540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25541 }
25542 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 resultobj = result;
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *obj;
25558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25559 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25560 return SWIG_Py_Void();
25561 }
25562
25563 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25564 PyObject *resultobj = 0;
25565 int arg1 = (int) 0 ;
25566 wxUpdateUIEvent *result = 0 ;
25567 int val1 ;
25568 int ecode1 = 0 ;
25569 PyObject * obj0 = 0 ;
25570 char * kwnames[] = {
25571 (char *) "commandId", NULL
25572 };
25573
25574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25575 if (obj0) {
25576 ecode1 = SWIG_AsVal_int(obj0, &val1);
25577 if (!SWIG_IsOK(ecode1)) {
25578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25579 }
25580 arg1 = static_cast< int >(val1);
25581 }
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25585 wxPyEndAllowThreads(__tstate);
25586 if (PyErr_Occurred()) SWIG_fail;
25587 }
25588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25596 PyObject *resultobj = 0;
25597 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25598 bool result;
25599 void *argp1 = 0 ;
25600 int res1 = 0 ;
25601 PyObject *swig_obj[1] ;
25602
25603 if (!args) SWIG_fail;
25604 swig_obj[0] = args;
25605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25608 }
25609 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25610 {
25611 PyThreadState* __tstate = wxPyBeginAllowThreads();
25612 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25613 wxPyEndAllowThreads(__tstate);
25614 if (PyErr_Occurred()) SWIG_fail;
25615 }
25616 {
25617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25618 }
25619 return resultobj;
25620 fail:
25621 return NULL;
25622 }
25623
25624
25625 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25626 PyObject *resultobj = 0;
25627 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25628 bool result;
25629 void *argp1 = 0 ;
25630 int res1 = 0 ;
25631 PyObject *swig_obj[1] ;
25632
25633 if (!args) SWIG_fail;
25634 swig_obj[0] = args;
25635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25636 if (!SWIG_IsOK(res1)) {
25637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25638 }
25639 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25640 {
25641 PyThreadState* __tstate = wxPyBeginAllowThreads();
25642 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 {
25647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25648 }
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25656 PyObject *resultobj = 0;
25657 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25658 bool result;
25659 void *argp1 = 0 ;
25660 int res1 = 0 ;
25661 PyObject *swig_obj[1] ;
25662
25663 if (!args) SWIG_fail;
25664 swig_obj[0] = args;
25665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25666 if (!SWIG_IsOK(res1)) {
25667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25668 }
25669 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25670 {
25671 PyThreadState* __tstate = wxPyBeginAllowThreads();
25672 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25673 wxPyEndAllowThreads(__tstate);
25674 if (PyErr_Occurred()) SWIG_fail;
25675 }
25676 {
25677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25678 }
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *resultobj = 0;
25687 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25688 wxString result;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 PyObject *swig_obj[1] ;
25692
25693 if (!args) SWIG_fail;
25694 swig_obj[0] = args;
25695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25696 if (!SWIG_IsOK(res1)) {
25697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25698 }
25699 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 {
25707 #if wxUSE_UNICODE
25708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25709 #else
25710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25711 #endif
25712 }
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25720 PyObject *resultobj = 0;
25721 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25722 bool result;
25723 void *argp1 = 0 ;
25724 int res1 = 0 ;
25725 PyObject *swig_obj[1] ;
25726
25727 if (!args) SWIG_fail;
25728 swig_obj[0] = args;
25729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25730 if (!SWIG_IsOK(res1)) {
25731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25732 }
25733 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25734 {
25735 PyThreadState* __tstate = wxPyBeginAllowThreads();
25736 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25737 wxPyEndAllowThreads(__tstate);
25738 if (PyErr_Occurred()) SWIG_fail;
25739 }
25740 {
25741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25742 }
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25752 bool result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25762 }
25763 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 {
25771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25772 }
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25780 PyObject *resultobj = 0;
25781 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25782 bool result;
25783 void *argp1 = 0 ;
25784 int res1 = 0 ;
25785 PyObject *swig_obj[1] ;
25786
25787 if (!args) SWIG_fail;
25788 swig_obj[0] = args;
25789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25790 if (!SWIG_IsOK(res1)) {
25791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25792 }
25793 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25794 {
25795 PyThreadState* __tstate = wxPyBeginAllowThreads();
25796 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 {
25801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25802 }
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25810 PyObject *resultobj = 0;
25811 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25812 bool result;
25813 void *argp1 = 0 ;
25814 int res1 = 0 ;
25815 PyObject *swig_obj[1] ;
25816
25817 if (!args) SWIG_fail;
25818 swig_obj[0] = args;
25819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25820 if (!SWIG_IsOK(res1)) {
25821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25822 }
25823 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25824 {
25825 PyThreadState* __tstate = wxPyBeginAllowThreads();
25826 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25827 wxPyEndAllowThreads(__tstate);
25828 if (PyErr_Occurred()) SWIG_fail;
25829 }
25830 {
25831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25832 }
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25840 PyObject *resultobj = 0;
25841 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25842 bool arg2 ;
25843 void *argp1 = 0 ;
25844 int res1 = 0 ;
25845 bool val2 ;
25846 int ecode2 = 0 ;
25847 PyObject * obj0 = 0 ;
25848 PyObject * obj1 = 0 ;
25849 char * kwnames[] = {
25850 (char *) "self",(char *) "check", NULL
25851 };
25852
25853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25855 if (!SWIG_IsOK(res1)) {
25856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25857 }
25858 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25860 if (!SWIG_IsOK(ecode2)) {
25861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25862 }
25863 arg2 = static_cast< bool >(val2);
25864 {
25865 PyThreadState* __tstate = wxPyBeginAllowThreads();
25866 (arg1)->Check(arg2);
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 resultobj = SWIG_Py_Void();
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj = 0;
25879 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25880 bool arg2 ;
25881 void *argp1 = 0 ;
25882 int res1 = 0 ;
25883 bool val2 ;
25884 int ecode2 = 0 ;
25885 PyObject * obj0 = 0 ;
25886 PyObject * obj1 = 0 ;
25887 char * kwnames[] = {
25888 (char *) "self",(char *) "enable", NULL
25889 };
25890
25891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25893 if (!SWIG_IsOK(res1)) {
25894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25895 }
25896 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25898 if (!SWIG_IsOK(ecode2)) {
25899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25900 }
25901 arg2 = static_cast< bool >(val2);
25902 {
25903 PyThreadState* __tstate = wxPyBeginAllowThreads();
25904 (arg1)->Enable(arg2);
25905 wxPyEndAllowThreads(__tstate);
25906 if (PyErr_Occurred()) SWIG_fail;
25907 }
25908 resultobj = SWIG_Py_Void();
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25916 PyObject *resultobj = 0;
25917 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25918 bool arg2 ;
25919 void *argp1 = 0 ;
25920 int res1 = 0 ;
25921 bool val2 ;
25922 int ecode2 = 0 ;
25923 PyObject * obj0 = 0 ;
25924 PyObject * obj1 = 0 ;
25925 char * kwnames[] = {
25926 (char *) "self",(char *) "show", NULL
25927 };
25928
25929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25931 if (!SWIG_IsOK(res1)) {
25932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25933 }
25934 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25935 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25936 if (!SWIG_IsOK(ecode2)) {
25937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25938 }
25939 arg2 = static_cast< bool >(val2);
25940 {
25941 PyThreadState* __tstate = wxPyBeginAllowThreads();
25942 (arg1)->Show(arg2);
25943 wxPyEndAllowThreads(__tstate);
25944 if (PyErr_Occurred()) SWIG_fail;
25945 }
25946 resultobj = SWIG_Py_Void();
25947 return resultobj;
25948 fail:
25949 return NULL;
25950 }
25951
25952
25953 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25954 PyObject *resultobj = 0;
25955 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25956 wxString *arg2 = 0 ;
25957 void *argp1 = 0 ;
25958 int res1 = 0 ;
25959 bool temp2 = false ;
25960 PyObject * obj0 = 0 ;
25961 PyObject * obj1 = 0 ;
25962 char * kwnames[] = {
25963 (char *) "self",(char *) "text", NULL
25964 };
25965
25966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25968 if (!SWIG_IsOK(res1)) {
25969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25970 }
25971 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25972 {
25973 arg2 = wxString_in_helper(obj1);
25974 if (arg2 == NULL) SWIG_fail;
25975 temp2 = true;
25976 }
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 (arg1)->SetText((wxString const &)*arg2);
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 resultobj = SWIG_Py_Void();
25984 {
25985 if (temp2)
25986 delete arg2;
25987 }
25988 return resultobj;
25989 fail:
25990 {
25991 if (temp2)
25992 delete arg2;
25993 }
25994 return NULL;
25995 }
25996
25997
25998 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj = 0;
26000 long arg1 ;
26001 long val1 ;
26002 int ecode1 = 0 ;
26003 PyObject * obj0 = 0 ;
26004 char * kwnames[] = {
26005 (char *) "updateInterval", NULL
26006 };
26007
26008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
26009 ecode1 = SWIG_AsVal_long(obj0, &val1);
26010 if (!SWIG_IsOK(ecode1)) {
26011 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26012 }
26013 arg1 = static_cast< long >(val1);
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 wxUpdateUIEvent::SetUpdateInterval(arg1);
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_Py_Void();
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26028 PyObject *resultobj = 0;
26029 long result;
26030
26031 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 resultobj = SWIG_From_long(static_cast< long >(result));
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj = 0;
26047 wxWindow *arg1 = (wxWindow *) 0 ;
26048 bool result;
26049 void *argp1 = 0 ;
26050 int res1 = 0 ;
26051 PyObject * obj0 = 0 ;
26052 char * kwnames[] = {
26053 (char *) "win", NULL
26054 };
26055
26056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26058 if (!SWIG_IsOK(res1)) {
26059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26060 }
26061 arg1 = reinterpret_cast< wxWindow * >(argp1);
26062 {
26063 PyThreadState* __tstate = wxPyBeginAllowThreads();
26064 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26065 wxPyEndAllowThreads(__tstate);
26066 if (PyErr_Occurred()) SWIG_fail;
26067 }
26068 {
26069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26070 }
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26078 PyObject *resultobj = 0;
26079
26080 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26081 {
26082 PyThreadState* __tstate = wxPyBeginAllowThreads();
26083 wxUpdateUIEvent::ResetUpdateTime();
26084 wxPyEndAllowThreads(__tstate);
26085 if (PyErr_Occurred()) SWIG_fail;
26086 }
26087 resultobj = SWIG_Py_Void();
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj = 0;
26096 wxUpdateUIMode arg1 ;
26097 int val1 ;
26098 int ecode1 = 0 ;
26099 PyObject * obj0 = 0 ;
26100 char * kwnames[] = {
26101 (char *) "mode", NULL
26102 };
26103
26104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26105 ecode1 = SWIG_AsVal_int(obj0, &val1);
26106 if (!SWIG_IsOK(ecode1)) {
26107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26108 }
26109 arg1 = static_cast< wxUpdateUIMode >(val1);
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 wxUpdateUIEvent::SetMode(arg1);
26113 wxPyEndAllowThreads(__tstate);
26114 if (PyErr_Occurred()) SWIG_fail;
26115 }
26116 resultobj = SWIG_Py_Void();
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 wxUpdateUIMode result;
26126
26127 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26128 {
26129 PyThreadState* __tstate = wxPyBeginAllowThreads();
26130 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 resultobj = SWIG_From_int(static_cast< int >(result));
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26142 PyObject *obj;
26143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26144 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26145 return SWIG_Py_Void();
26146 }
26147
26148 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26149 return SWIG_Python_InitShadowInstance(args);
26150 }
26151
26152 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26153 PyObject *resultobj = 0;
26154 wxSysColourChangedEvent *result = 0 ;
26155
26156 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26157 {
26158 PyThreadState* __tstate = wxPyBeginAllowThreads();
26159 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26171 PyObject *obj;
26172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26173 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26174 return SWIG_Py_Void();
26175 }
26176
26177 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26178 return SWIG_Python_InitShadowInstance(args);
26179 }
26180
26181 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26182 PyObject *resultobj = 0;
26183 int arg1 = (int) 0 ;
26184 wxWindow *arg2 = (wxWindow *) NULL ;
26185 wxMouseCaptureChangedEvent *result = 0 ;
26186 int val1 ;
26187 int ecode1 = 0 ;
26188 void *argp2 = 0 ;
26189 int res2 = 0 ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char * kwnames[] = {
26193 (char *) "winid",(char *) "gainedCapture", NULL
26194 };
26195
26196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26197 if (obj0) {
26198 ecode1 = SWIG_AsVal_int(obj0, &val1);
26199 if (!SWIG_IsOK(ecode1)) {
26200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26201 }
26202 arg1 = static_cast< int >(val1);
26203 }
26204 if (obj1) {
26205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26206 if (!SWIG_IsOK(res2)) {
26207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26208 }
26209 arg2 = reinterpret_cast< wxWindow * >(argp2);
26210 }
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26214 wxPyEndAllowThreads(__tstate);
26215 if (PyErr_Occurred()) SWIG_fail;
26216 }
26217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26225 PyObject *resultobj = 0;
26226 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26227 wxWindow *result = 0 ;
26228 void *argp1 = 0 ;
26229 int res1 = 0 ;
26230 PyObject *swig_obj[1] ;
26231
26232 if (!args) SWIG_fail;
26233 swig_obj[0] = args;
26234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26237 }
26238 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26242 wxPyEndAllowThreads(__tstate);
26243 if (PyErr_Occurred()) SWIG_fail;
26244 }
26245 {
26246 resultobj = wxPyMake_wxObject(result, (bool)0);
26247 }
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26255 PyObject *obj;
26256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26257 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26258 return SWIG_Py_Void();
26259 }
26260
26261 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26262 return SWIG_Python_InitShadowInstance(args);
26263 }
26264
26265 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj = 0;
26267 int arg1 = (int) 0 ;
26268 wxMouseCaptureLostEvent *result = 0 ;
26269 int val1 ;
26270 int ecode1 = 0 ;
26271 PyObject * obj0 = 0 ;
26272 char * kwnames[] = {
26273 (char *) "winid", NULL
26274 };
26275
26276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26277 if (obj0) {
26278 ecode1 = SWIG_AsVal_int(obj0, &val1);
26279 if (!SWIG_IsOK(ecode1)) {
26280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26281 }
26282 arg1 = static_cast< int >(val1);
26283 }
26284 {
26285 PyThreadState* __tstate = wxPyBeginAllowThreads();
26286 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26287 wxPyEndAllowThreads(__tstate);
26288 if (PyErr_Occurred()) SWIG_fail;
26289 }
26290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26298 PyObject *obj;
26299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26300 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26301 return SWIG_Py_Void();
26302 }
26303
26304 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 return SWIG_Python_InitShadowInstance(args);
26306 }
26307
26308 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26309 PyObject *resultobj = 0;
26310 wxDisplayChangedEvent *result = 0 ;
26311
26312 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26316 wxPyEndAllowThreads(__tstate);
26317 if (PyErr_Occurred()) SWIG_fail;
26318 }
26319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26320 return resultobj;
26321 fail:
26322 return NULL;
26323 }
26324
26325
26326 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26327 PyObject *obj;
26328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26329 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26330 return SWIG_Py_Void();
26331 }
26332
26333 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26334 return SWIG_Python_InitShadowInstance(args);
26335 }
26336
26337 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj = 0;
26339 int arg1 = (int) 0 ;
26340 wxPaletteChangedEvent *result = 0 ;
26341 int val1 ;
26342 int ecode1 = 0 ;
26343 PyObject * obj0 = 0 ;
26344 char * kwnames[] = {
26345 (char *) "id", NULL
26346 };
26347
26348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26349 if (obj0) {
26350 ecode1 = SWIG_AsVal_int(obj0, &val1);
26351 if (!SWIG_IsOK(ecode1)) {
26352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26353 }
26354 arg1 = static_cast< int >(val1);
26355 }
26356 {
26357 PyThreadState* __tstate = wxPyBeginAllowThreads();
26358 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26359 wxPyEndAllowThreads(__tstate);
26360 if (PyErr_Occurred()) SWIG_fail;
26361 }
26362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj = 0;
26371 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26372 wxWindow *arg2 = (wxWindow *) 0 ;
26373 void *argp1 = 0 ;
26374 int res1 = 0 ;
26375 void *argp2 = 0 ;
26376 int res2 = 0 ;
26377 PyObject * obj0 = 0 ;
26378 PyObject * obj1 = 0 ;
26379 char * kwnames[] = {
26380 (char *) "self",(char *) "win", NULL
26381 };
26382
26383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26385 if (!SWIG_IsOK(res1)) {
26386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26387 }
26388 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26390 if (!SWIG_IsOK(res2)) {
26391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26392 }
26393 arg2 = reinterpret_cast< wxWindow * >(argp2);
26394 {
26395 PyThreadState* __tstate = wxPyBeginAllowThreads();
26396 (arg1)->SetChangedWindow(arg2);
26397 wxPyEndAllowThreads(__tstate);
26398 if (PyErr_Occurred()) SWIG_fail;
26399 }
26400 resultobj = SWIG_Py_Void();
26401 return resultobj;
26402 fail:
26403 return NULL;
26404 }
26405
26406
26407 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26408 PyObject *resultobj = 0;
26409 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26410 wxWindow *result = 0 ;
26411 void *argp1 = 0 ;
26412 int res1 = 0 ;
26413 PyObject *swig_obj[1] ;
26414
26415 if (!args) SWIG_fail;
26416 swig_obj[0] = args;
26417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26418 if (!SWIG_IsOK(res1)) {
26419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26420 }
26421 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26422 {
26423 PyThreadState* __tstate = wxPyBeginAllowThreads();
26424 result = (wxWindow *)(arg1)->GetChangedWindow();
26425 wxPyEndAllowThreads(__tstate);
26426 if (PyErr_Occurred()) SWIG_fail;
26427 }
26428 {
26429 resultobj = wxPyMake_wxObject(result, (bool)0);
26430 }
26431 return resultobj;
26432 fail:
26433 return NULL;
26434 }
26435
26436
26437 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26438 PyObject *obj;
26439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26441 return SWIG_Py_Void();
26442 }
26443
26444 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26445 return SWIG_Python_InitShadowInstance(args);
26446 }
26447
26448 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26449 PyObject *resultobj = 0;
26450 int arg1 = (int) 0 ;
26451 wxQueryNewPaletteEvent *result = 0 ;
26452 int val1 ;
26453 int ecode1 = 0 ;
26454 PyObject * obj0 = 0 ;
26455 char * kwnames[] = {
26456 (char *) "winid", NULL
26457 };
26458
26459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26460 if (obj0) {
26461 ecode1 = SWIG_AsVal_int(obj0, &val1);
26462 if (!SWIG_IsOK(ecode1)) {
26463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26464 }
26465 arg1 = static_cast< int >(val1);
26466 }
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26470 wxPyEndAllowThreads(__tstate);
26471 if (PyErr_Occurred()) SWIG_fail;
26472 }
26473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj = 0;
26482 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26483 bool arg2 ;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 bool val2 ;
26487 int ecode2 = 0 ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 char * kwnames[] = {
26491 (char *) "self",(char *) "realized", NULL
26492 };
26493
26494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26496 if (!SWIG_IsOK(res1)) {
26497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26498 }
26499 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26501 if (!SWIG_IsOK(ecode2)) {
26502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26503 }
26504 arg2 = static_cast< bool >(val2);
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 (arg1)->SetPaletteRealized(arg2);
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 resultobj = SWIG_Py_Void();
26512 return resultobj;
26513 fail:
26514 return NULL;
26515 }
26516
26517
26518 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 PyObject *resultobj = 0;
26520 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26521 bool result;
26522 void *argp1 = 0 ;
26523 int res1 = 0 ;
26524 PyObject *swig_obj[1] ;
26525
26526 if (!args) SWIG_fail;
26527 swig_obj[0] = args;
26528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26529 if (!SWIG_IsOK(res1)) {
26530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26531 }
26532 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 {
26540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26541 }
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *QueryNewPaletteEvent_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_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26552 return SWIG_Py_Void();
26553 }
26554
26555 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26556 return SWIG_Python_InitShadowInstance(args);
26557 }
26558
26559 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26560 PyObject *resultobj = 0;
26561 wxNavigationKeyEvent *result = 0 ;
26562
26563 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26564 {
26565 PyThreadState* __tstate = wxPyBeginAllowThreads();
26566 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26578 PyObject *resultobj = 0;
26579 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26580 bool result;
26581 void *argp1 = 0 ;
26582 int res1 = 0 ;
26583 PyObject *swig_obj[1] ;
26584
26585 if (!args) SWIG_fail;
26586 swig_obj[0] = args;
26587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26588 if (!SWIG_IsOK(res1)) {
26589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26590 }
26591 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26592 {
26593 PyThreadState* __tstate = wxPyBeginAllowThreads();
26594 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 {
26599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26600 }
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj = 0;
26609 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26610 bool arg2 ;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 bool val2 ;
26614 int ecode2 = 0 ;
26615 PyObject * obj0 = 0 ;
26616 PyObject * obj1 = 0 ;
26617 char * kwnames[] = {
26618 (char *) "self",(char *) "forward", NULL
26619 };
26620
26621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26623 if (!SWIG_IsOK(res1)) {
26624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26625 }
26626 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26627 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26628 if (!SWIG_IsOK(ecode2)) {
26629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26630 }
26631 arg2 = static_cast< bool >(val2);
26632 {
26633 PyThreadState* __tstate = wxPyBeginAllowThreads();
26634 (arg1)->SetDirection(arg2);
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 resultobj = SWIG_Py_Void();
26639 return resultobj;
26640 fail:
26641 return NULL;
26642 }
26643
26644
26645 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26646 PyObject *resultobj = 0;
26647 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26648 bool result;
26649 void *argp1 = 0 ;
26650 int res1 = 0 ;
26651 PyObject *swig_obj[1] ;
26652
26653 if (!args) SWIG_fail;
26654 swig_obj[0] = args;
26655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26656 if (!SWIG_IsOK(res1)) {
26657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26658 }
26659 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26660 {
26661 PyThreadState* __tstate = wxPyBeginAllowThreads();
26662 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26663 wxPyEndAllowThreads(__tstate);
26664 if (PyErr_Occurred()) SWIG_fail;
26665 }
26666 {
26667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26668 }
26669 return resultobj;
26670 fail:
26671 return NULL;
26672 }
26673
26674
26675 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26676 PyObject *resultobj = 0;
26677 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26678 bool arg2 ;
26679 void *argp1 = 0 ;
26680 int res1 = 0 ;
26681 bool val2 ;
26682 int ecode2 = 0 ;
26683 PyObject * obj0 = 0 ;
26684 PyObject * obj1 = 0 ;
26685 char * kwnames[] = {
26686 (char *) "self",(char *) "ischange", NULL
26687 };
26688
26689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26691 if (!SWIG_IsOK(res1)) {
26692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26693 }
26694 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26696 if (!SWIG_IsOK(ecode2)) {
26697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26698 }
26699 arg2 = static_cast< bool >(val2);
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 (arg1)->SetWindowChange(arg2);
26703 wxPyEndAllowThreads(__tstate);
26704 if (PyErr_Occurred()) SWIG_fail;
26705 }
26706 resultobj = SWIG_Py_Void();
26707 return resultobj;
26708 fail:
26709 return NULL;
26710 }
26711
26712
26713 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26714 PyObject *resultobj = 0;
26715 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26716 bool result;
26717 void *argp1 = 0 ;
26718 int res1 = 0 ;
26719 PyObject *swig_obj[1] ;
26720
26721 if (!args) SWIG_fail;
26722 swig_obj[0] = args;
26723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26726 }
26727 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 {
26735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26736 }
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj = 0;
26745 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26746 bool arg2 ;
26747 void *argp1 = 0 ;
26748 int res1 = 0 ;
26749 bool val2 ;
26750 int ecode2 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 char * kwnames[] = {
26754 (char *) "self",(char *) "bIs", NULL
26755 };
26756
26757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26759 if (!SWIG_IsOK(res1)) {
26760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26761 }
26762 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26764 if (!SWIG_IsOK(ecode2)) {
26765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26766 }
26767 arg2 = static_cast< bool >(val2);
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 (arg1)->SetFromTab(arg2);
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 resultobj = SWIG_Py_Void();
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26784 long arg2 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 long val2 ;
26788 int ecode2 = 0 ;
26789 PyObject * obj0 = 0 ;
26790 PyObject * obj1 = 0 ;
26791 char * kwnames[] = {
26792 (char *) "self",(char *) "flags", NULL
26793 };
26794
26795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26797 if (!SWIG_IsOK(res1)) {
26798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26799 }
26800 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26801 ecode2 = SWIG_AsVal_long(obj1, &val2);
26802 if (!SWIG_IsOK(ecode2)) {
26803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26804 }
26805 arg2 = static_cast< long >(val2);
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 (arg1)->SetFlags(arg2);
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 resultobj = SWIG_Py_Void();
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26820 PyObject *resultobj = 0;
26821 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26822 wxWindow *result = 0 ;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 PyObject *swig_obj[1] ;
26826
26827 if (!args) SWIG_fail;
26828 swig_obj[0] = args;
26829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26830 if (!SWIG_IsOK(res1)) {
26831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26832 }
26833 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26834 {
26835 PyThreadState* __tstate = wxPyBeginAllowThreads();
26836 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 {
26841 resultobj = wxPyMake_wxObject(result, (bool)0);
26842 }
26843 return resultobj;
26844 fail:
26845 return NULL;
26846 }
26847
26848
26849 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26850 PyObject *resultobj = 0;
26851 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26852 wxWindow *arg2 = (wxWindow *) 0 ;
26853 void *argp1 = 0 ;
26854 int res1 = 0 ;
26855 void *argp2 = 0 ;
26856 int res2 = 0 ;
26857 PyObject * obj0 = 0 ;
26858 PyObject * obj1 = 0 ;
26859 char * kwnames[] = {
26860 (char *) "self",(char *) "win", NULL
26861 };
26862
26863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26865 if (!SWIG_IsOK(res1)) {
26866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26867 }
26868 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26869 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26870 if (!SWIG_IsOK(res2)) {
26871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26872 }
26873 arg2 = reinterpret_cast< wxWindow * >(argp2);
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 (arg1)->SetCurrentFocus(arg2);
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_Py_Void();
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 PyObject *obj;
26889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26890 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26891 return SWIG_Py_Void();
26892 }
26893
26894 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26895 return SWIG_Python_InitShadowInstance(args);
26896 }
26897
26898 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj = 0;
26900 wxWindow *arg1 = (wxWindow *) NULL ;
26901 wxWindowCreateEvent *result = 0 ;
26902 void *argp1 = 0 ;
26903 int res1 = 0 ;
26904 PyObject * obj0 = 0 ;
26905 char * kwnames[] = {
26906 (char *) "win", NULL
26907 };
26908
26909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26910 if (obj0) {
26911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26912 if (!SWIG_IsOK(res1)) {
26913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26914 }
26915 arg1 = reinterpret_cast< wxWindow * >(argp1);
26916 }
26917 {
26918 PyThreadState* __tstate = wxPyBeginAllowThreads();
26919 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26920 wxPyEndAllowThreads(__tstate);
26921 if (PyErr_Occurred()) SWIG_fail;
26922 }
26923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26924 return resultobj;
26925 fail:
26926 return NULL;
26927 }
26928
26929
26930 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26931 PyObject *resultobj = 0;
26932 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26933 wxWindow *result = 0 ;
26934 void *argp1 = 0 ;
26935 int res1 = 0 ;
26936 PyObject *swig_obj[1] ;
26937
26938 if (!args) SWIG_fail;
26939 swig_obj[0] = args;
26940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26941 if (!SWIG_IsOK(res1)) {
26942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26943 }
26944 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 {
26952 resultobj = wxPyMake_wxObject(result, (bool)0);
26953 }
26954 return resultobj;
26955 fail:
26956 return NULL;
26957 }
26958
26959
26960 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26961 PyObject *obj;
26962 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26963 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26964 return SWIG_Py_Void();
26965 }
26966
26967 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26968 return SWIG_Python_InitShadowInstance(args);
26969 }
26970
26971 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj = 0;
26973 wxWindow *arg1 = (wxWindow *) NULL ;
26974 wxWindowDestroyEvent *result = 0 ;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 PyObject * obj0 = 0 ;
26978 char * kwnames[] = {
26979 (char *) "win", NULL
26980 };
26981
26982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26983 if (obj0) {
26984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26985 if (!SWIG_IsOK(res1)) {
26986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26987 }
26988 arg1 = reinterpret_cast< wxWindow * >(argp1);
26989 }
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27004 PyObject *resultobj = 0;
27005 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
27006 wxWindow *result = 0 ;
27007 void *argp1 = 0 ;
27008 int res1 = 0 ;
27009 PyObject *swig_obj[1] ;
27010
27011 if (!args) SWIG_fail;
27012 swig_obj[0] = args;
27013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27014 if (!SWIG_IsOK(res1)) {
27015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27016 }
27017 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27021 wxPyEndAllowThreads(__tstate);
27022 if (PyErr_Occurred()) SWIG_fail;
27023 }
27024 {
27025 resultobj = wxPyMake_wxObject(result, (bool)0);
27026 }
27027 return resultobj;
27028 fail:
27029 return NULL;
27030 }
27031
27032
27033 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27034 PyObject *obj;
27035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27036 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27037 return SWIG_Py_Void();
27038 }
27039
27040 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27041 return SWIG_Python_InitShadowInstance(args);
27042 }
27043
27044 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27045 PyObject *resultobj = 0;
27046 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27047 int arg2 = (int) 0 ;
27048 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27049 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27050 wxContextMenuEvent *result = 0 ;
27051 int val1 ;
27052 int ecode1 = 0 ;
27053 int val2 ;
27054 int ecode2 = 0 ;
27055 wxPoint temp3 ;
27056 PyObject * obj0 = 0 ;
27057 PyObject * obj1 = 0 ;
27058 PyObject * obj2 = 0 ;
27059 char * kwnames[] = {
27060 (char *) "type",(char *) "winid",(char *) "pt", NULL
27061 };
27062
27063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27064 if (obj0) {
27065 ecode1 = SWIG_AsVal_int(obj0, &val1);
27066 if (!SWIG_IsOK(ecode1)) {
27067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27068 }
27069 arg1 = static_cast< wxEventType >(val1);
27070 }
27071 if (obj1) {
27072 ecode2 = SWIG_AsVal_int(obj1, &val2);
27073 if (!SWIG_IsOK(ecode2)) {
27074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27075 }
27076 arg2 = static_cast< int >(val2);
27077 }
27078 if (obj2) {
27079 {
27080 arg3 = &temp3;
27081 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27082 }
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27087 wxPyEndAllowThreads(__tstate);
27088 if (PyErr_Occurred()) SWIG_fail;
27089 }
27090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27091 return resultobj;
27092 fail:
27093 return NULL;
27094 }
27095
27096
27097 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27098 PyObject *resultobj = 0;
27099 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27100 wxPoint *result = 0 ;
27101 void *argp1 = 0 ;
27102 int res1 = 0 ;
27103 PyObject *swig_obj[1] ;
27104
27105 if (!args) SWIG_fail;
27106 swig_obj[0] = args;
27107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27108 if (!SWIG_IsOK(res1)) {
27109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27110 }
27111 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27112 {
27113 PyThreadState* __tstate = wxPyBeginAllowThreads();
27114 {
27115 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27116 result = (wxPoint *) &_result_ref;
27117 }
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj = 0;
27130 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27131 wxPoint *arg2 = 0 ;
27132 void *argp1 = 0 ;
27133 int res1 = 0 ;
27134 wxPoint temp2 ;
27135 PyObject * obj0 = 0 ;
27136 PyObject * obj1 = 0 ;
27137 char * kwnames[] = {
27138 (char *) "self",(char *) "pos", NULL
27139 };
27140
27141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27143 if (!SWIG_IsOK(res1)) {
27144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27145 }
27146 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27147 {
27148 arg2 = &temp2;
27149 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27150 }
27151 {
27152 PyThreadState* __tstate = wxPyBeginAllowThreads();
27153 (arg1)->SetPosition((wxPoint const &)*arg2);
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 resultobj = SWIG_Py_Void();
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27165 PyObject *obj;
27166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27167 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27168 return SWIG_Py_Void();
27169 }
27170
27171 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27172 return SWIG_Python_InitShadowInstance(args);
27173 }
27174
27175 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27176 PyObject *resultobj = 0;
27177 wxIdleEvent *result = 0 ;
27178
27179 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27180 {
27181 PyThreadState* __tstate = wxPyBeginAllowThreads();
27182 result = (wxIdleEvent *)new wxIdleEvent();
27183 wxPyEndAllowThreads(__tstate);
27184 if (PyErr_Occurred()) SWIG_fail;
27185 }
27186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27187 return resultobj;
27188 fail:
27189 return NULL;
27190 }
27191
27192
27193 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27194 PyObject *resultobj = 0;
27195 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27196 bool arg2 = (bool) true ;
27197 void *argp1 = 0 ;
27198 int res1 = 0 ;
27199 bool val2 ;
27200 int ecode2 = 0 ;
27201 PyObject * obj0 = 0 ;
27202 PyObject * obj1 = 0 ;
27203 char * kwnames[] = {
27204 (char *) "self",(char *) "needMore", NULL
27205 };
27206
27207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27209 if (!SWIG_IsOK(res1)) {
27210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27211 }
27212 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27213 if (obj1) {
27214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27215 if (!SWIG_IsOK(ecode2)) {
27216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27217 }
27218 arg2 = static_cast< bool >(val2);
27219 }
27220 {
27221 PyThreadState* __tstate = wxPyBeginAllowThreads();
27222 (arg1)->RequestMore(arg2);
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 resultobj = SWIG_Py_Void();
27227 return resultobj;
27228 fail:
27229 return NULL;
27230 }
27231
27232
27233 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27234 PyObject *resultobj = 0;
27235 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27236 bool result;
27237 void *argp1 = 0 ;
27238 int res1 = 0 ;
27239 PyObject *swig_obj[1] ;
27240
27241 if (!args) SWIG_fail;
27242 swig_obj[0] = args;
27243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27244 if (!SWIG_IsOK(res1)) {
27245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27246 }
27247 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27251 wxPyEndAllowThreads(__tstate);
27252 if (PyErr_Occurred()) SWIG_fail;
27253 }
27254 {
27255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27256 }
27257 return resultobj;
27258 fail:
27259 return NULL;
27260 }
27261
27262
27263 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27264 PyObject *resultobj = 0;
27265 wxIdleMode arg1 ;
27266 int val1 ;
27267 int ecode1 = 0 ;
27268 PyObject * obj0 = 0 ;
27269 char * kwnames[] = {
27270 (char *) "mode", NULL
27271 };
27272
27273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27274 ecode1 = SWIG_AsVal_int(obj0, &val1);
27275 if (!SWIG_IsOK(ecode1)) {
27276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27277 }
27278 arg1 = static_cast< wxIdleMode >(val1);
27279 {
27280 PyThreadState* __tstate = wxPyBeginAllowThreads();
27281 wxIdleEvent::SetMode(arg1);
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 resultobj = SWIG_Py_Void();
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27293 PyObject *resultobj = 0;
27294 wxIdleMode result;
27295
27296 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 result = (wxIdleMode)wxIdleEvent::GetMode();
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 resultobj = SWIG_From_int(static_cast< int >(result));
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27311 PyObject *resultobj = 0;
27312 wxWindow *arg1 = (wxWindow *) 0 ;
27313 bool result;
27314 void *argp1 = 0 ;
27315 int res1 = 0 ;
27316 PyObject * obj0 = 0 ;
27317 char * kwnames[] = {
27318 (char *) "win", NULL
27319 };
27320
27321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27323 if (!SWIG_IsOK(res1)) {
27324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27325 }
27326 arg1 = reinterpret_cast< wxWindow * >(argp1);
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 result = (bool)wxIdleEvent::CanSend(arg1);
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 {
27334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27335 }
27336 return resultobj;
27337 fail:
27338 return NULL;
27339 }
27340
27341
27342 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27343 PyObject *obj;
27344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27345 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27346 return SWIG_Py_Void();
27347 }
27348
27349 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27350 return SWIG_Python_InitShadowInstance(args);
27351 }
27352
27353 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27354 PyObject *resultobj = 0;
27355 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27356 int arg2 = (int) 0 ;
27357 wxClipboardTextEvent *result = 0 ;
27358 int val1 ;
27359 int ecode1 = 0 ;
27360 int val2 ;
27361 int ecode2 = 0 ;
27362 PyObject * obj0 = 0 ;
27363 PyObject * obj1 = 0 ;
27364 char * kwnames[] = {
27365 (char *) "type",(char *) "winid", NULL
27366 };
27367
27368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27369 if (obj0) {
27370 ecode1 = SWIG_AsVal_int(obj0, &val1);
27371 if (!SWIG_IsOK(ecode1)) {
27372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27373 }
27374 arg1 = static_cast< wxEventType >(val1);
27375 }
27376 if (obj1) {
27377 ecode2 = SWIG_AsVal_int(obj1, &val2);
27378 if (!SWIG_IsOK(ecode2)) {
27379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27380 }
27381 arg2 = static_cast< int >(val2);
27382 }
27383 {
27384 PyThreadState* __tstate = wxPyBeginAllowThreads();
27385 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27386 wxPyEndAllowThreads(__tstate);
27387 if (PyErr_Occurred()) SWIG_fail;
27388 }
27389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27390 return resultobj;
27391 fail:
27392 return NULL;
27393 }
27394
27395
27396 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27397 PyObject *obj;
27398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27399 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27400 return SWIG_Py_Void();
27401 }
27402
27403 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27404 return SWIG_Python_InitShadowInstance(args);
27405 }
27406
27407 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27408 PyObject *resultobj = 0;
27409 int arg1 = (int) 0 ;
27410 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27411 wxPyEvent *result = 0 ;
27412 int val1 ;
27413 int ecode1 = 0 ;
27414 int val2 ;
27415 int ecode2 = 0 ;
27416 PyObject * obj0 = 0 ;
27417 PyObject * obj1 = 0 ;
27418 char * kwnames[] = {
27419 (char *) "winid",(char *) "eventType", NULL
27420 };
27421
27422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27423 if (obj0) {
27424 ecode1 = SWIG_AsVal_int(obj0, &val1);
27425 if (!SWIG_IsOK(ecode1)) {
27426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27427 }
27428 arg1 = static_cast< int >(val1);
27429 }
27430 if (obj1) {
27431 ecode2 = SWIG_AsVal_int(obj1, &val2);
27432 if (!SWIG_IsOK(ecode2)) {
27433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27434 }
27435 arg2 = static_cast< wxEventType >(val2);
27436 }
27437 {
27438 PyThreadState* __tstate = wxPyBeginAllowThreads();
27439 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27440 wxPyEndAllowThreads(__tstate);
27441 if (PyErr_Occurred()) SWIG_fail;
27442 }
27443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27451 PyObject *resultobj = 0;
27452 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27453 void *argp1 = 0 ;
27454 int res1 = 0 ;
27455 PyObject *swig_obj[1] ;
27456
27457 if (!args) SWIG_fail;
27458 swig_obj[0] = args;
27459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27460 if (!SWIG_IsOK(res1)) {
27461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27462 }
27463 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27464 {
27465 PyThreadState* __tstate = wxPyBeginAllowThreads();
27466 delete arg1;
27467
27468 wxPyEndAllowThreads(__tstate);
27469 if (PyErr_Occurred()) SWIG_fail;
27470 }
27471 resultobj = SWIG_Py_Void();
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27479 PyObject *resultobj = 0;
27480 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27481 PyObject *arg2 = (PyObject *) 0 ;
27482 void *argp1 = 0 ;
27483 int res1 = 0 ;
27484 PyObject * obj0 = 0 ;
27485 PyObject * obj1 = 0 ;
27486 char * kwnames[] = {
27487 (char *) "self",(char *) "self", NULL
27488 };
27489
27490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27494 }
27495 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27496 arg2 = obj1;
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 (arg1)->SetSelf(arg2);
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 resultobj = SWIG_Py_Void();
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27511 PyObject *resultobj = 0;
27512 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27513 PyObject *result = 0 ;
27514 void *argp1 = 0 ;
27515 int res1 = 0 ;
27516 PyObject *swig_obj[1] ;
27517
27518 if (!args) SWIG_fail;
27519 swig_obj[0] = args;
27520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27521 if (!SWIG_IsOK(res1)) {
27522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27523 }
27524 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27525 {
27526 PyThreadState* __tstate = wxPyBeginAllowThreads();
27527 result = (PyObject *)(arg1)->GetSelf();
27528 wxPyEndAllowThreads(__tstate);
27529 if (PyErr_Occurred()) SWIG_fail;
27530 }
27531 resultobj = result;
27532 return resultobj;
27533 fail:
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27539 PyObject *obj;
27540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27541 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27542 return SWIG_Py_Void();
27543 }
27544
27545 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27546 return SWIG_Python_InitShadowInstance(args);
27547 }
27548
27549 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27550 PyObject *resultobj = 0;
27551 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27552 int arg2 = (int) 0 ;
27553 wxPyCommandEvent *result = 0 ;
27554 int val1 ;
27555 int ecode1 = 0 ;
27556 int val2 ;
27557 int ecode2 = 0 ;
27558 PyObject * obj0 = 0 ;
27559 PyObject * obj1 = 0 ;
27560 char * kwnames[] = {
27561 (char *) "eventType",(char *) "id", NULL
27562 };
27563
27564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27565 if (obj0) {
27566 ecode1 = SWIG_AsVal_int(obj0, &val1);
27567 if (!SWIG_IsOK(ecode1)) {
27568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27569 }
27570 arg1 = static_cast< wxEventType >(val1);
27571 }
27572 if (obj1) {
27573 ecode2 = SWIG_AsVal_int(obj1, &val2);
27574 if (!SWIG_IsOK(ecode2)) {
27575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27576 }
27577 arg2 = static_cast< int >(val2);
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27593 PyObject *resultobj = 0;
27594 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27595 void *argp1 = 0 ;
27596 int res1 = 0 ;
27597 PyObject *swig_obj[1] ;
27598
27599 if (!args) SWIG_fail;
27600 swig_obj[0] = args;
27601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27602 if (!SWIG_IsOK(res1)) {
27603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27604 }
27605 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27606 {
27607 PyThreadState* __tstate = wxPyBeginAllowThreads();
27608 delete arg1;
27609
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 resultobj = SWIG_Py_Void();
27614 return resultobj;
27615 fail:
27616 return NULL;
27617 }
27618
27619
27620 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27621 PyObject *resultobj = 0;
27622 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27623 PyObject *arg2 = (PyObject *) 0 ;
27624 void *argp1 = 0 ;
27625 int res1 = 0 ;
27626 PyObject * obj0 = 0 ;
27627 PyObject * obj1 = 0 ;
27628 char * kwnames[] = {
27629 (char *) "self",(char *) "self", NULL
27630 };
27631
27632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27634 if (!SWIG_IsOK(res1)) {
27635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27636 }
27637 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27638 arg2 = obj1;
27639 {
27640 PyThreadState* __tstate = wxPyBeginAllowThreads();
27641 (arg1)->SetSelf(arg2);
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 resultobj = SWIG_Py_Void();
27646 return resultobj;
27647 fail:
27648 return NULL;
27649 }
27650
27651
27652 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27653 PyObject *resultobj = 0;
27654 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27655 PyObject *result = 0 ;
27656 void *argp1 = 0 ;
27657 int res1 = 0 ;
27658 PyObject *swig_obj[1] ;
27659
27660 if (!args) SWIG_fail;
27661 swig_obj[0] = args;
27662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27663 if (!SWIG_IsOK(res1)) {
27664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27665 }
27666 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = (PyObject *)(arg1)->GetSelf();
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 resultobj = result;
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27681 PyObject *obj;
27682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27683 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27684 return SWIG_Py_Void();
27685 }
27686
27687 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27688 return SWIG_Python_InitShadowInstance(args);
27689 }
27690
27691 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27692 PyObject *resultobj = 0;
27693 wxWindow *arg1 = (wxWindow *) 0 ;
27694 wxDateTime *arg2 = 0 ;
27695 wxEventType arg3 ;
27696 wxDateEvent *result = 0 ;
27697 void *argp1 = 0 ;
27698 int res1 = 0 ;
27699 void *argp2 = 0 ;
27700 int res2 = 0 ;
27701 int val3 ;
27702 int ecode3 = 0 ;
27703 PyObject * obj0 = 0 ;
27704 PyObject * obj1 = 0 ;
27705 PyObject * obj2 = 0 ;
27706 char * kwnames[] = {
27707 (char *) "win",(char *) "dt",(char *) "type", NULL
27708 };
27709
27710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27714 }
27715 arg1 = reinterpret_cast< wxWindow * >(argp1);
27716 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27717 if (!SWIG_IsOK(res2)) {
27718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27719 }
27720 if (!argp2) {
27721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27722 }
27723 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27724 ecode3 = SWIG_AsVal_int(obj2, &val3);
27725 if (!SWIG_IsOK(ecode3)) {
27726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27727 }
27728 arg3 = static_cast< wxEventType >(val3);
27729 {
27730 PyThreadState* __tstate = wxPyBeginAllowThreads();
27731 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27732 wxPyEndAllowThreads(__tstate);
27733 if (PyErr_Occurred()) SWIG_fail;
27734 }
27735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27736 return resultobj;
27737 fail:
27738 return NULL;
27739 }
27740
27741
27742 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27743 PyObject *resultobj = 0;
27744 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27745 wxDateTime *result = 0 ;
27746 void *argp1 = 0 ;
27747 int res1 = 0 ;
27748 PyObject *swig_obj[1] ;
27749
27750 if (!args) SWIG_fail;
27751 swig_obj[0] = args;
27752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27753 if (!SWIG_IsOK(res1)) {
27754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27755 }
27756 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27757 {
27758 PyThreadState* __tstate = wxPyBeginAllowThreads();
27759 {
27760 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27761 result = (wxDateTime *) &_result_ref;
27762 }
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27767 return resultobj;
27768 fail:
27769 return NULL;
27770 }
27771
27772
27773 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27774 PyObject *resultobj = 0;
27775 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27776 wxDateTime *arg2 = 0 ;
27777 void *argp1 = 0 ;
27778 int res1 = 0 ;
27779 void *argp2 = 0 ;
27780 int res2 = 0 ;
27781 PyObject * obj0 = 0 ;
27782 PyObject * obj1 = 0 ;
27783 char * kwnames[] = {
27784 (char *) "self",(char *) "date", NULL
27785 };
27786
27787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27789 if (!SWIG_IsOK(res1)) {
27790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27791 }
27792 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27794 if (!SWIG_IsOK(res2)) {
27795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27796 }
27797 if (!argp2) {
27798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27799 }
27800 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 (arg1)->SetDate((wxDateTime const &)*arg2);
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 resultobj = SWIG_Py_Void();
27808 return resultobj;
27809 fail:
27810 return NULL;
27811 }
27812
27813
27814 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27815 PyObject *obj;
27816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27817 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27818 return SWIG_Py_Void();
27819 }
27820
27821 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27822 return SWIG_Python_InitShadowInstance(args);
27823 }
27824
27825 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 PyObject *resultobj = 0;
27827 wxPyApp *result = 0 ;
27828
27829 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27830 {
27831 PyThreadState* __tstate = wxPyBeginAllowThreads();
27832 result = (wxPyApp *)new_wxPyApp();
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27844 PyObject *resultobj = 0;
27845 wxPyApp *arg1 = (wxPyApp *) 0 ;
27846 void *argp1 = 0 ;
27847 int res1 = 0 ;
27848 PyObject *swig_obj[1] ;
27849
27850 if (!args) SWIG_fail;
27851 swig_obj[0] = args;
27852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27855 }
27856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 delete arg1;
27860
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 resultobj = SWIG_Py_Void();
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj = 0;
27873 wxPyApp *arg1 = (wxPyApp *) 0 ;
27874 PyObject *arg2 = (PyObject *) 0 ;
27875 PyObject *arg3 = (PyObject *) 0 ;
27876 bool arg4 ;
27877 void *argp1 = 0 ;
27878 int res1 = 0 ;
27879 bool val4 ;
27880 int ecode4 = 0 ;
27881 PyObject * obj0 = 0 ;
27882 PyObject * obj1 = 0 ;
27883 PyObject * obj2 = 0 ;
27884 PyObject * obj3 = 0 ;
27885 char * kwnames[] = {
27886 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27887 };
27888
27889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27891 if (!SWIG_IsOK(res1)) {
27892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27893 }
27894 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27895 arg2 = obj1;
27896 arg3 = obj2;
27897 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27898 if (!SWIG_IsOK(ecode4)) {
27899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27900 }
27901 arg4 = static_cast< bool >(val4);
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 resultobj = SWIG_Py_Void();
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27916 PyObject *resultobj = 0;
27917 wxPyApp *arg1 = (wxPyApp *) 0 ;
27918 wxString 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_wxPyApp, 0 | 0 );
27926 if (!SWIG_IsOK(res1)) {
27927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27928 }
27929 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 result = ((wxPyApp const *)arg1)->GetAppName();
27933 wxPyEndAllowThreads(__tstate);
27934 if (PyErr_Occurred()) SWIG_fail;
27935 }
27936 {
27937 #if wxUSE_UNICODE
27938 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27939 #else
27940 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27941 #endif
27942 }
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj = 0;
27951 wxPyApp *arg1 = (wxPyApp *) 0 ;
27952 wxString *arg2 = 0 ;
27953 void *argp1 = 0 ;
27954 int res1 = 0 ;
27955 bool temp2 = false ;
27956 PyObject * obj0 = 0 ;
27957 PyObject * obj1 = 0 ;
27958 char * kwnames[] = {
27959 (char *) "self",(char *) "name", NULL
27960 };
27961
27962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27964 if (!SWIG_IsOK(res1)) {
27965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27966 }
27967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27968 {
27969 arg2 = wxString_in_helper(obj1);
27970 if (arg2 == NULL) SWIG_fail;
27971 temp2 = true;
27972 }
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 (arg1)->SetAppName((wxString const &)*arg2);
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 resultobj = SWIG_Py_Void();
27980 {
27981 if (temp2)
27982 delete arg2;
27983 }
27984 return resultobj;
27985 fail:
27986 {
27987 if (temp2)
27988 delete arg2;
27989 }
27990 return NULL;
27991 }
27992
27993
27994 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27995 PyObject *resultobj = 0;
27996 wxPyApp *arg1 = (wxPyApp *) 0 ;
27997 wxString result;
27998 void *argp1 = 0 ;
27999 int res1 = 0 ;
28000 PyObject *swig_obj[1] ;
28001
28002 if (!args) SWIG_fail;
28003 swig_obj[0] = args;
28004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28005 if (!SWIG_IsOK(res1)) {
28006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28007 }
28008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 result = ((wxPyApp const *)arg1)->GetClassName();
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 {
28016 #if wxUSE_UNICODE
28017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28018 #else
28019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28020 #endif
28021 }
28022 return resultobj;
28023 fail:
28024 return NULL;
28025 }
28026
28027
28028 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28029 PyObject *resultobj = 0;
28030 wxPyApp *arg1 = (wxPyApp *) 0 ;
28031 wxString *arg2 = 0 ;
28032 void *argp1 = 0 ;
28033 int res1 = 0 ;
28034 bool temp2 = false ;
28035 PyObject * obj0 = 0 ;
28036 PyObject * obj1 = 0 ;
28037 char * kwnames[] = {
28038 (char *) "self",(char *) "name", NULL
28039 };
28040
28041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28043 if (!SWIG_IsOK(res1)) {
28044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28045 }
28046 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28047 {
28048 arg2 = wxString_in_helper(obj1);
28049 if (arg2 == NULL) SWIG_fail;
28050 temp2 = true;
28051 }
28052 {
28053 PyThreadState* __tstate = wxPyBeginAllowThreads();
28054 (arg1)->SetClassName((wxString const &)*arg2);
28055 wxPyEndAllowThreads(__tstate);
28056 if (PyErr_Occurred()) SWIG_fail;
28057 }
28058 resultobj = SWIG_Py_Void();
28059 {
28060 if (temp2)
28061 delete arg2;
28062 }
28063 return resultobj;
28064 fail:
28065 {
28066 if (temp2)
28067 delete arg2;
28068 }
28069 return NULL;
28070 }
28071
28072
28073 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28074 PyObject *resultobj = 0;
28075 wxPyApp *arg1 = (wxPyApp *) 0 ;
28076 wxString *result = 0 ;
28077 void *argp1 = 0 ;
28078 int res1 = 0 ;
28079 PyObject *swig_obj[1] ;
28080
28081 if (!args) SWIG_fail;
28082 swig_obj[0] = args;
28083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28084 if (!SWIG_IsOK(res1)) {
28085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28086 }
28087 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28088 {
28089 PyThreadState* __tstate = wxPyBeginAllowThreads();
28090 {
28091 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28092 result = (wxString *) &_result_ref;
28093 }
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 {
28098 #if wxUSE_UNICODE
28099 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28100 #else
28101 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28102 #endif
28103 }
28104 return resultobj;
28105 fail:
28106 return NULL;
28107 }
28108
28109
28110 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28111 PyObject *resultobj = 0;
28112 wxPyApp *arg1 = (wxPyApp *) 0 ;
28113 wxString *arg2 = 0 ;
28114 void *argp1 = 0 ;
28115 int res1 = 0 ;
28116 bool temp2 = false ;
28117 PyObject * obj0 = 0 ;
28118 PyObject * obj1 = 0 ;
28119 char * kwnames[] = {
28120 (char *) "self",(char *) "name", NULL
28121 };
28122
28123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28125 if (!SWIG_IsOK(res1)) {
28126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28127 }
28128 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28129 {
28130 arg2 = wxString_in_helper(obj1);
28131 if (arg2 == NULL) SWIG_fail;
28132 temp2 = true;
28133 }
28134 {
28135 PyThreadState* __tstate = wxPyBeginAllowThreads();
28136 (arg1)->SetVendorName((wxString const &)*arg2);
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 resultobj = SWIG_Py_Void();
28141 {
28142 if (temp2)
28143 delete arg2;
28144 }
28145 return resultobj;
28146 fail:
28147 {
28148 if (temp2)
28149 delete arg2;
28150 }
28151 return NULL;
28152 }
28153
28154
28155 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28156 PyObject *resultobj = 0;
28157 wxPyApp *arg1 = (wxPyApp *) 0 ;
28158 wxAppTraits *result = 0 ;
28159 void *argp1 = 0 ;
28160 int res1 = 0 ;
28161 PyObject *swig_obj[1] ;
28162
28163 if (!args) SWIG_fail;
28164 swig_obj[0] = args;
28165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28166 if (!SWIG_IsOK(res1)) {
28167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28168 }
28169 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28170 {
28171 PyThreadState* __tstate = wxPyBeginAllowThreads();
28172 result = (wxAppTraits *)(arg1)->GetTraits();
28173 wxPyEndAllowThreads(__tstate);
28174 if (PyErr_Occurred()) SWIG_fail;
28175 }
28176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28177 return resultobj;
28178 fail:
28179 return NULL;
28180 }
28181
28182
28183 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28184 PyObject *resultobj = 0;
28185 wxPyApp *arg1 = (wxPyApp *) 0 ;
28186 void *argp1 = 0 ;
28187 int res1 = 0 ;
28188 PyObject *swig_obj[1] ;
28189
28190 if (!args) SWIG_fail;
28191 swig_obj[0] = args;
28192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28193 if (!SWIG_IsOK(res1)) {
28194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28195 }
28196 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 (arg1)->ProcessPendingEvents();
28200 wxPyEndAllowThreads(__tstate);
28201 if (PyErr_Occurred()) SWIG_fail;
28202 }
28203 resultobj = SWIG_Py_Void();
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj = 0;
28212 wxPyApp *arg1 = (wxPyApp *) 0 ;
28213 bool arg2 = (bool) false ;
28214 bool result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 bool val2 ;
28218 int ecode2 = 0 ;
28219 PyObject * obj0 = 0 ;
28220 PyObject * obj1 = 0 ;
28221 char * kwnames[] = {
28222 (char *) "self",(char *) "onlyIfNeeded", NULL
28223 };
28224
28225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28227 if (!SWIG_IsOK(res1)) {
28228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28229 }
28230 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28231 if (obj1) {
28232 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28233 if (!SWIG_IsOK(ecode2)) {
28234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28235 }
28236 arg2 = static_cast< bool >(val2);
28237 }
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (bool)(arg1)->Yield(arg2);
28241 wxPyEndAllowThreads(__tstate);
28242 if (PyErr_Occurred()) SWIG_fail;
28243 }
28244 {
28245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28246 }
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28254 PyObject *resultobj = 0;
28255 wxPyApp *arg1 = (wxPyApp *) 0 ;
28256 void *argp1 = 0 ;
28257 int res1 = 0 ;
28258 PyObject *swig_obj[1] ;
28259
28260 if (!args) SWIG_fail;
28261 swig_obj[0] = args;
28262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28263 if (!SWIG_IsOK(res1)) {
28264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28265 }
28266 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 (arg1)->WakeUpIdle();
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 resultobj = SWIG_Py_Void();
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28281 PyObject *resultobj = 0;
28282 bool result;
28283
28284 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = (bool)wxPyApp::IsMainLoopRunning();
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 {
28292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28293 }
28294 return resultobj;
28295 fail:
28296 return NULL;
28297 }
28298
28299
28300 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28301 PyObject *resultobj = 0;
28302 wxPyApp *arg1 = (wxPyApp *) 0 ;
28303 int result;
28304 void *argp1 = 0 ;
28305 int res1 = 0 ;
28306 PyObject *swig_obj[1] ;
28307
28308 if (!args) SWIG_fail;
28309 swig_obj[0] = args;
28310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28311 if (!SWIG_IsOK(res1)) {
28312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28313 }
28314 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 result = (int)(arg1)->MainLoop();
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 resultobj = SWIG_From_int(static_cast< int >(result));
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 PyObject *resultobj = 0;
28330 wxPyApp *arg1 = (wxPyApp *) 0 ;
28331 void *argp1 = 0 ;
28332 int res1 = 0 ;
28333 PyObject *swig_obj[1] ;
28334
28335 if (!args) SWIG_fail;
28336 swig_obj[0] = args;
28337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28338 if (!SWIG_IsOK(res1)) {
28339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28340 }
28341 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28342 {
28343 PyThreadState* __tstate = wxPyBeginAllowThreads();
28344 (arg1)->Exit();
28345 wxPyEndAllowThreads(__tstate);
28346 if (PyErr_Occurred()) SWIG_fail;
28347 }
28348 resultobj = SWIG_Py_Void();
28349 return resultobj;
28350 fail:
28351 return NULL;
28352 }
28353
28354
28355 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28356 PyObject *resultobj = 0;
28357 wxPyApp *arg1 = (wxPyApp *) 0 ;
28358 wxLayoutDirection result;
28359 void *argp1 = 0 ;
28360 int res1 = 0 ;
28361 PyObject *swig_obj[1] ;
28362
28363 if (!args) SWIG_fail;
28364 swig_obj[0] = args;
28365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28366 if (!SWIG_IsOK(res1)) {
28367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28368 }
28369 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28370 {
28371 PyThreadState* __tstate = wxPyBeginAllowThreads();
28372 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28373 wxPyEndAllowThreads(__tstate);
28374 if (PyErr_Occurred()) SWIG_fail;
28375 }
28376 resultobj = SWIG_From_int(static_cast< int >(result));
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28384 PyObject *resultobj = 0;
28385 wxPyApp *arg1 = (wxPyApp *) 0 ;
28386 void *argp1 = 0 ;
28387 int res1 = 0 ;
28388 PyObject *swig_obj[1] ;
28389
28390 if (!args) SWIG_fail;
28391 swig_obj[0] = args;
28392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28393 if (!SWIG_IsOK(res1)) {
28394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28395 }
28396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28397 {
28398 PyThreadState* __tstate = wxPyBeginAllowThreads();
28399 (arg1)->ExitMainLoop();
28400 wxPyEndAllowThreads(__tstate);
28401 if (PyErr_Occurred()) SWIG_fail;
28402 }
28403 resultobj = SWIG_Py_Void();
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28411 PyObject *resultobj = 0;
28412 wxPyApp *arg1 = (wxPyApp *) 0 ;
28413 bool result;
28414 void *argp1 = 0 ;
28415 int res1 = 0 ;
28416 PyObject *swig_obj[1] ;
28417
28418 if (!args) SWIG_fail;
28419 swig_obj[0] = args;
28420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28421 if (!SWIG_IsOK(res1)) {
28422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28423 }
28424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 result = (bool)(arg1)->Pending();
28428 wxPyEndAllowThreads(__tstate);
28429 if (PyErr_Occurred()) SWIG_fail;
28430 }
28431 {
28432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28433 }
28434 return resultobj;
28435 fail:
28436 return NULL;
28437 }
28438
28439
28440 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28441 PyObject *resultobj = 0;
28442 wxPyApp *arg1 = (wxPyApp *) 0 ;
28443 bool result;
28444 void *argp1 = 0 ;
28445 int res1 = 0 ;
28446 PyObject *swig_obj[1] ;
28447
28448 if (!args) SWIG_fail;
28449 swig_obj[0] = args;
28450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28451 if (!SWIG_IsOK(res1)) {
28452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28453 }
28454 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28455 {
28456 PyThreadState* __tstate = wxPyBeginAllowThreads();
28457 result = (bool)(arg1)->Dispatch();
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 {
28462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28463 }
28464 return resultobj;
28465 fail:
28466 return NULL;
28467 }
28468
28469
28470 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28471 PyObject *resultobj = 0;
28472 wxPyApp *arg1 = (wxPyApp *) 0 ;
28473 bool result;
28474 void *argp1 = 0 ;
28475 int res1 = 0 ;
28476 PyObject *swig_obj[1] ;
28477
28478 if (!args) SWIG_fail;
28479 swig_obj[0] = args;
28480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28481 if (!SWIG_IsOK(res1)) {
28482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28483 }
28484 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 result = (bool)(arg1)->ProcessIdle();
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 {
28492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28493 }
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28501 PyObject *resultobj = 0;
28502 wxPyApp *arg1 = (wxPyApp *) 0 ;
28503 wxWindow *arg2 = (wxWindow *) 0 ;
28504 wxIdleEvent *arg3 = 0 ;
28505 bool result;
28506 void *argp1 = 0 ;
28507 int res1 = 0 ;
28508 void *argp2 = 0 ;
28509 int res2 = 0 ;
28510 void *argp3 = 0 ;
28511 int res3 = 0 ;
28512 PyObject * obj0 = 0 ;
28513 PyObject * obj1 = 0 ;
28514 PyObject * obj2 = 0 ;
28515 char * kwnames[] = {
28516 (char *) "self",(char *) "win",(char *) "event", NULL
28517 };
28518
28519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28521 if (!SWIG_IsOK(res1)) {
28522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28523 }
28524 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28526 if (!SWIG_IsOK(res2)) {
28527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28528 }
28529 arg2 = reinterpret_cast< wxWindow * >(argp2);
28530 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28531 if (!SWIG_IsOK(res3)) {
28532 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28533 }
28534 if (!argp3) {
28535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28536 }
28537 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 {
28545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28546 }
28547 return resultobj;
28548 fail:
28549 return NULL;
28550 }
28551
28552
28553 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28554 PyObject *resultobj = 0;
28555 wxPyApp *arg1 = (wxPyApp *) 0 ;
28556 bool result;
28557 void *argp1 = 0 ;
28558 int res1 = 0 ;
28559 PyObject *swig_obj[1] ;
28560
28561 if (!args) SWIG_fail;
28562 swig_obj[0] = args;
28563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28564 if (!SWIG_IsOK(res1)) {
28565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28566 }
28567 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28568 {
28569 PyThreadState* __tstate = wxPyBeginAllowThreads();
28570 result = (bool)((wxPyApp const *)arg1)->IsActive();
28571 wxPyEndAllowThreads(__tstate);
28572 if (PyErr_Occurred()) SWIG_fail;
28573 }
28574 {
28575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28576 }
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj = 0;
28585 wxPyApp *arg1 = (wxPyApp *) 0 ;
28586 wxWindow *arg2 = (wxWindow *) 0 ;
28587 void *argp1 = 0 ;
28588 int res1 = 0 ;
28589 void *argp2 = 0 ;
28590 int res2 = 0 ;
28591 PyObject * obj0 = 0 ;
28592 PyObject * obj1 = 0 ;
28593 char * kwnames[] = {
28594 (char *) "self",(char *) "win", NULL
28595 };
28596
28597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28601 }
28602 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28604 if (!SWIG_IsOK(res2)) {
28605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28606 }
28607 arg2 = reinterpret_cast< wxWindow * >(argp2);
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 (arg1)->SetTopWindow(arg2);
28611 wxPyEndAllowThreads(__tstate);
28612 if (PyErr_Occurred()) SWIG_fail;
28613 }
28614 resultobj = SWIG_Py_Void();
28615 return resultobj;
28616 fail:
28617 return NULL;
28618 }
28619
28620
28621 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28622 PyObject *resultobj = 0;
28623 wxPyApp *arg1 = (wxPyApp *) 0 ;
28624 wxWindow *result = 0 ;
28625 void *argp1 = 0 ;
28626 int res1 = 0 ;
28627 PyObject *swig_obj[1] ;
28628
28629 if (!args) SWIG_fail;
28630 swig_obj[0] = args;
28631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28632 if (!SWIG_IsOK(res1)) {
28633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28634 }
28635 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28636 {
28637 PyThreadState* __tstate = wxPyBeginAllowThreads();
28638 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28639 wxPyEndAllowThreads(__tstate);
28640 if (PyErr_Occurred()) SWIG_fail;
28641 }
28642 {
28643 resultobj = wxPyMake_wxObject(result, (bool)0);
28644 }
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28652 PyObject *resultobj = 0;
28653 wxPyApp *arg1 = (wxPyApp *) 0 ;
28654 bool arg2 ;
28655 void *argp1 = 0 ;
28656 int res1 = 0 ;
28657 bool val2 ;
28658 int ecode2 = 0 ;
28659 PyObject * obj0 = 0 ;
28660 PyObject * obj1 = 0 ;
28661 char * kwnames[] = {
28662 (char *) "self",(char *) "flag", NULL
28663 };
28664
28665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28667 if (!SWIG_IsOK(res1)) {
28668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28669 }
28670 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28671 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28672 if (!SWIG_IsOK(ecode2)) {
28673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28674 }
28675 arg2 = static_cast< bool >(val2);
28676 {
28677 PyThreadState* __tstate = wxPyBeginAllowThreads();
28678 (arg1)->SetExitOnFrameDelete(arg2);
28679 wxPyEndAllowThreads(__tstate);
28680 if (PyErr_Occurred()) SWIG_fail;
28681 }
28682 resultobj = SWIG_Py_Void();
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28690 PyObject *resultobj = 0;
28691 wxPyApp *arg1 = (wxPyApp *) 0 ;
28692 bool result;
28693 void *argp1 = 0 ;
28694 int res1 = 0 ;
28695 PyObject *swig_obj[1] ;
28696
28697 if (!args) SWIG_fail;
28698 swig_obj[0] = args;
28699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28700 if (!SWIG_IsOK(res1)) {
28701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28702 }
28703 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 {
28711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28712 }
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj = 0;
28721 wxPyApp *arg1 = (wxPyApp *) 0 ;
28722 bool arg2 ;
28723 void *argp1 = 0 ;
28724 int res1 = 0 ;
28725 bool val2 ;
28726 int ecode2 = 0 ;
28727 PyObject * obj0 = 0 ;
28728 PyObject * obj1 = 0 ;
28729 char * kwnames[] = {
28730 (char *) "self",(char *) "flag", NULL
28731 };
28732
28733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28735 if (!SWIG_IsOK(res1)) {
28736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28737 }
28738 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28740 if (!SWIG_IsOK(ecode2)) {
28741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28742 }
28743 arg2 = static_cast< bool >(val2);
28744 {
28745 PyThreadState* __tstate = wxPyBeginAllowThreads();
28746 (arg1)->SetUseBestVisual(arg2);
28747 wxPyEndAllowThreads(__tstate);
28748 if (PyErr_Occurred()) SWIG_fail;
28749 }
28750 resultobj = SWIG_Py_Void();
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28758 PyObject *resultobj = 0;
28759 wxPyApp *arg1 = (wxPyApp *) 0 ;
28760 bool result;
28761 void *argp1 = 0 ;
28762 int res1 = 0 ;
28763 PyObject *swig_obj[1] ;
28764
28765 if (!args) SWIG_fail;
28766 swig_obj[0] = args;
28767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28768 if (!SWIG_IsOK(res1)) {
28769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28770 }
28771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28772 {
28773 PyThreadState* __tstate = wxPyBeginAllowThreads();
28774 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 {
28779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28780 }
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj = 0;
28789 wxPyApp *arg1 = (wxPyApp *) 0 ;
28790 int arg2 ;
28791 void *argp1 = 0 ;
28792 int res1 = 0 ;
28793 int val2 ;
28794 int ecode2 = 0 ;
28795 PyObject * obj0 = 0 ;
28796 PyObject * obj1 = 0 ;
28797 char * kwnames[] = {
28798 (char *) "self",(char *) "mode", NULL
28799 };
28800
28801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28803 if (!SWIG_IsOK(res1)) {
28804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28805 }
28806 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28807 ecode2 = SWIG_AsVal_int(obj1, &val2);
28808 if (!SWIG_IsOK(ecode2)) {
28809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28810 }
28811 arg2 = static_cast< int >(val2);
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 (arg1)->SetPrintMode(arg2);
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 resultobj = SWIG_Py_Void();
28819 return resultobj;
28820 fail:
28821 return NULL;
28822 }
28823
28824
28825 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28826 PyObject *resultobj = 0;
28827 wxPyApp *arg1 = (wxPyApp *) 0 ;
28828 int result;
28829 void *argp1 = 0 ;
28830 int res1 = 0 ;
28831 PyObject *swig_obj[1] ;
28832
28833 if (!args) SWIG_fail;
28834 swig_obj[0] = args;
28835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28836 if (!SWIG_IsOK(res1)) {
28837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28838 }
28839 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28840 {
28841 PyThreadState* __tstate = wxPyBeginAllowThreads();
28842 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 resultobj = SWIG_From_int(static_cast< int >(result));
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj = 0;
28855 wxPyApp *arg1 = (wxPyApp *) 0 ;
28856 int arg2 ;
28857 void *argp1 = 0 ;
28858 int res1 = 0 ;
28859 int val2 ;
28860 int ecode2 = 0 ;
28861 PyObject * obj0 = 0 ;
28862 PyObject * obj1 = 0 ;
28863 char * kwnames[] = {
28864 (char *) "self",(char *) "mode", NULL
28865 };
28866
28867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28869 if (!SWIG_IsOK(res1)) {
28870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28871 }
28872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28873 ecode2 = SWIG_AsVal_int(obj1, &val2);
28874 if (!SWIG_IsOK(ecode2)) {
28875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28876 }
28877 arg2 = static_cast< int >(val2);
28878 {
28879 PyThreadState* __tstate = wxPyBeginAllowThreads();
28880 (arg1)->SetAssertMode(arg2);
28881 wxPyEndAllowThreads(__tstate);
28882 if (PyErr_Occurred()) SWIG_fail;
28883 }
28884 resultobj = SWIG_Py_Void();
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893 wxPyApp *arg1 = (wxPyApp *) 0 ;
28894 int result;
28895 void *argp1 = 0 ;
28896 int res1 = 0 ;
28897 PyObject *swig_obj[1] ;
28898
28899 if (!args) SWIG_fail;
28900 swig_obj[0] = args;
28901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28902 if (!SWIG_IsOK(res1)) {
28903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28904 }
28905 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 result = (int)(arg1)->GetAssertMode();
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 resultobj = SWIG_From_int(static_cast< int >(result));
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28920 PyObject *resultobj = 0;
28921 bool result;
28922
28923 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 {
28931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28932 }
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 long result;
28942
28943 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28944 {
28945 PyThreadState* __tstate = wxPyBeginAllowThreads();
28946 result = (long)wxPyApp::GetMacAboutMenuItemId();
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 resultobj = SWIG_From_long(static_cast< long >(result));
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28958 PyObject *resultobj = 0;
28959 long result;
28960
28961 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 resultobj = SWIG_From_long(static_cast< long >(result));
28969 return resultobj;
28970 fail:
28971 return NULL;
28972 }
28973
28974
28975 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28976 PyObject *resultobj = 0;
28977 long result;
28978
28979 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28980 {
28981 PyThreadState* __tstate = wxPyBeginAllowThreads();
28982 result = (long)wxPyApp::GetMacExitMenuItemId();
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 resultobj = SWIG_From_long(static_cast< long >(result));
28987 return resultobj;
28988 fail:
28989 return NULL;
28990 }
28991
28992
28993 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28994 PyObject *resultobj = 0;
28995 wxString result;
28996
28997 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = wxPyApp::GetMacHelpMenuTitleName();
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 {
29005 #if wxUSE_UNICODE
29006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29007 #else
29008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29009 #endif
29010 }
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29018 PyObject *resultobj = 0;
29019 bool arg1 ;
29020 bool val1 ;
29021 int ecode1 = 0 ;
29022 PyObject * obj0 = 0 ;
29023 char * kwnames[] = {
29024 (char *) "val", NULL
29025 };
29026
29027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29028 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29029 if (!SWIG_IsOK(ecode1)) {
29030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29031 }
29032 arg1 = static_cast< bool >(val1);
29033 {
29034 PyThreadState* __tstate = wxPyBeginAllowThreads();
29035 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 resultobj = SWIG_Py_Void();
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29047 PyObject *resultobj = 0;
29048 long arg1 ;
29049 long val1 ;
29050 int ecode1 = 0 ;
29051 PyObject * obj0 = 0 ;
29052 char * kwnames[] = {
29053 (char *) "val", NULL
29054 };
29055
29056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29057 ecode1 = SWIG_AsVal_long(obj0, &val1);
29058 if (!SWIG_IsOK(ecode1)) {
29059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29060 }
29061 arg1 = static_cast< long >(val1);
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 wxPyApp::SetMacAboutMenuItemId(arg1);
29065 wxPyEndAllowThreads(__tstate);
29066 if (PyErr_Occurred()) SWIG_fail;
29067 }
29068 resultobj = SWIG_Py_Void();
29069 return resultobj;
29070 fail:
29071 return NULL;
29072 }
29073
29074
29075 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29076 PyObject *resultobj = 0;
29077 long arg1 ;
29078 long val1 ;
29079 int ecode1 = 0 ;
29080 PyObject * obj0 = 0 ;
29081 char * kwnames[] = {
29082 (char *) "val", NULL
29083 };
29084
29085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29086 ecode1 = SWIG_AsVal_long(obj0, &val1);
29087 if (!SWIG_IsOK(ecode1)) {
29088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29089 }
29090 arg1 = static_cast< long >(val1);
29091 {
29092 PyThreadState* __tstate = wxPyBeginAllowThreads();
29093 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29094 wxPyEndAllowThreads(__tstate);
29095 if (PyErr_Occurred()) SWIG_fail;
29096 }
29097 resultobj = SWIG_Py_Void();
29098 return resultobj;
29099 fail:
29100 return NULL;
29101 }
29102
29103
29104 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29105 PyObject *resultobj = 0;
29106 long arg1 ;
29107 long val1 ;
29108 int ecode1 = 0 ;
29109 PyObject * obj0 = 0 ;
29110 char * kwnames[] = {
29111 (char *) "val", NULL
29112 };
29113
29114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29115 ecode1 = SWIG_AsVal_long(obj0, &val1);
29116 if (!SWIG_IsOK(ecode1)) {
29117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29118 }
29119 arg1 = static_cast< long >(val1);
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 wxPyApp::SetMacExitMenuItemId(arg1);
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_Py_Void();
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj = 0;
29135 wxString *arg1 = 0 ;
29136 bool temp1 = false ;
29137 PyObject * obj0 = 0 ;
29138 char * kwnames[] = {
29139 (char *) "val", NULL
29140 };
29141
29142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29143 {
29144 arg1 = wxString_in_helper(obj0);
29145 if (arg1 == NULL) SWIG_fail;
29146 temp1 = true;
29147 }
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_Py_Void();
29155 {
29156 if (temp1)
29157 delete arg1;
29158 }
29159 return resultobj;
29160 fail:
29161 {
29162 if (temp1)
29163 delete arg1;
29164 }
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29170 PyObject *resultobj = 0;
29171 wxPyApp *arg1 = (wxPyApp *) 0 ;
29172 void *argp1 = 0 ;
29173 int res1 = 0 ;
29174 PyObject *swig_obj[1] ;
29175
29176 if (!args) SWIG_fail;
29177 swig_obj[0] = args;
29178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29179 if (!SWIG_IsOK(res1)) {
29180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29181 }
29182 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29183 {
29184 PyThreadState* __tstate = wxPyBeginAllowThreads();
29185 (arg1)->_BootstrapApp();
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 resultobj = SWIG_Py_Void();
29190 return resultobj;
29191 fail:
29192 return NULL;
29193 }
29194
29195
29196 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29197 PyObject *resultobj = 0;
29198 int result;
29199
29200 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 result = (int)wxPyApp_GetComCtl32Version();
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 resultobj = SWIG_From_int(static_cast< int >(result));
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *resultobj = 0;
29216 bool result;
29217
29218 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29219 {
29220 PyThreadState* __tstate = wxPyBeginAllowThreads();
29221 result = (bool)wxPyApp_IsDisplayAvailable();
29222 wxPyEndAllowThreads(__tstate);
29223 if (PyErr_Occurred()) SWIG_fail;
29224 }
29225 {
29226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29227 }
29228 return resultobj;
29229 fail:
29230 return NULL;
29231 }
29232
29233
29234 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29235 PyObject *obj;
29236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29237 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29238 return SWIG_Py_Void();
29239 }
29240
29241 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29242 return SWIG_Python_InitShadowInstance(args);
29243 }
29244
29245 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29246 PyObject *resultobj = 0;
29247
29248 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29249 {
29250 PyThreadState* __tstate = wxPyBeginAllowThreads();
29251 wxExit();
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 resultobj = SWIG_Py_Void();
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *resultobj = 0;
29264 bool result;
29265
29266 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (bool)wxYield();
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 {
29274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29275 }
29276 return resultobj;
29277 fail:
29278 return NULL;
29279 }
29280
29281
29282 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29283 PyObject *resultobj = 0;
29284 bool result;
29285
29286 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 result = (bool)wxYieldIfNeeded();
29290 wxPyEndAllowThreads(__tstate);
29291 if (PyErr_Occurred()) SWIG_fail;
29292 }
29293 {
29294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29295 }
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj = 0;
29304 wxWindow *arg1 = (wxWindow *) NULL ;
29305 bool arg2 = (bool) false ;
29306 bool result;
29307 void *argp1 = 0 ;
29308 int res1 = 0 ;
29309 bool val2 ;
29310 int ecode2 = 0 ;
29311 PyObject * obj0 = 0 ;
29312 PyObject * obj1 = 0 ;
29313 char * kwnames[] = {
29314 (char *) "win",(char *) "onlyIfNeeded", NULL
29315 };
29316
29317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29318 if (obj0) {
29319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29320 if (!SWIG_IsOK(res1)) {
29321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29322 }
29323 arg1 = reinterpret_cast< wxWindow * >(argp1);
29324 }
29325 if (obj1) {
29326 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29327 if (!SWIG_IsOK(ecode2)) {
29328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29329 }
29330 arg2 = static_cast< bool >(val2);
29331 }
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 result = (bool)wxSafeYield(arg1,arg2);
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 {
29339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29340 }
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29348 PyObject *resultobj = 0;
29349
29350 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 wxWakeUpIdle();
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 resultobj = SWIG_Py_Void();
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj = 0;
29366 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29367 wxEvent *arg2 = 0 ;
29368 void *argp1 = 0 ;
29369 int res1 = 0 ;
29370 void *argp2 = 0 ;
29371 int res2 = 0 ;
29372 PyObject * obj0 = 0 ;
29373 PyObject * obj1 = 0 ;
29374 char * kwnames[] = {
29375 (char *) "dest",(char *) "event", NULL
29376 };
29377
29378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29380 if (!SWIG_IsOK(res1)) {
29381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29382 }
29383 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29384 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29385 if (!SWIG_IsOK(res2)) {
29386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29387 }
29388 if (!argp2) {
29389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29390 }
29391 arg2 = reinterpret_cast< wxEvent * >(argp2);
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 wxPostEvent(arg1,*arg2);
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 resultobj = SWIG_Py_Void();
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29406 PyObject *resultobj = 0;
29407
29408 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29409 {
29410 PyThreadState* __tstate = wxPyBeginAllowThreads();
29411 wxApp_CleanUp();
29412 wxPyEndAllowThreads(__tstate);
29413 if (PyErr_Occurred()) SWIG_fail;
29414 }
29415 resultobj = SWIG_Py_Void();
29416 return resultobj;
29417 fail:
29418 return NULL;
29419 }
29420
29421
29422 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29423 PyObject *resultobj = 0;
29424 wxPyApp *result = 0 ;
29425
29426 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 result = (wxPyApp *)wxPyGetApp();
29430 wxPyEndAllowThreads(__tstate);
29431 if (PyErr_Occurred()) SWIG_fail;
29432 }
29433 {
29434 resultobj = wxPyMake_wxObject(result, 0);
29435 }
29436 return resultobj;
29437 fail:
29438 return NULL;
29439 }
29440
29441
29442 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29443 PyObject *resultobj = 0;
29444 char *arg1 = (char *) 0 ;
29445 int res1 ;
29446 char *buf1 = 0 ;
29447 int alloc1 = 0 ;
29448 PyObject * obj0 = 0 ;
29449 char * kwnames[] = {
29450 (char *) "encoding", NULL
29451 };
29452
29453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29454 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29457 }
29458 arg1 = buf1;
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 wxSetDefaultPyEncoding((char const *)arg1);
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 resultobj = SWIG_Py_Void();
29466 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29467 return resultobj;
29468 fail:
29469 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *resultobj = 0;
29476 char *result = 0 ;
29477
29478 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 result = (char *)wxGetDefaultPyEncoding();
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 resultobj = SWIG_FromCharPtr(result);
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29493 PyObject *resultobj = 0;
29494 wxEventLoop *result = 0 ;
29495
29496 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (wxEventLoop *)new wxEventLoop();
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29511 PyObject *resultobj = 0;
29512 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29513 void *argp1 = 0 ;
29514 int res1 = 0 ;
29515 PyObject *swig_obj[1] ;
29516
29517 if (!args) SWIG_fail;
29518 swig_obj[0] = args;
29519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29520 if (!SWIG_IsOK(res1)) {
29521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29522 }
29523 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 delete arg1;
29527
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 resultobj = SWIG_Py_Void();
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29539 PyObject *resultobj = 0;
29540 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29541 int result;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 PyObject *swig_obj[1] ;
29545
29546 if (!args) SWIG_fail;
29547 swig_obj[0] = args;
29548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29549 if (!SWIG_IsOK(res1)) {
29550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29551 }
29552 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (int)(arg1)->Run();
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 resultobj = SWIG_From_int(static_cast< int >(result));
29560 return resultobj;
29561 fail:
29562 return NULL;
29563 }
29564
29565
29566 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29567 PyObject *resultobj = 0;
29568 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29569 int arg2 = (int) 0 ;
29570 void *argp1 = 0 ;
29571 int res1 = 0 ;
29572 int val2 ;
29573 int ecode2 = 0 ;
29574 PyObject * obj0 = 0 ;
29575 PyObject * obj1 = 0 ;
29576 char * kwnames[] = {
29577 (char *) "self",(char *) "rc", NULL
29578 };
29579
29580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29582 if (!SWIG_IsOK(res1)) {
29583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29584 }
29585 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29586 if (obj1) {
29587 ecode2 = SWIG_AsVal_int(obj1, &val2);
29588 if (!SWIG_IsOK(ecode2)) {
29589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29590 }
29591 arg2 = static_cast< int >(val2);
29592 }
29593 {
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 (arg1)->Exit(arg2);
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_Py_Void();
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29607 PyObject *resultobj = 0;
29608 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29609 bool result;
29610 void *argp1 = 0 ;
29611 int res1 = 0 ;
29612 PyObject *swig_obj[1] ;
29613
29614 if (!args) SWIG_fail;
29615 swig_obj[0] = args;
29616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29617 if (!SWIG_IsOK(res1)) {
29618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29619 }
29620 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29621 {
29622 PyThreadState* __tstate = wxPyBeginAllowThreads();
29623 result = (bool)((wxEventLoop const *)arg1)->Pending();
29624 wxPyEndAllowThreads(__tstate);
29625 if (PyErr_Occurred()) SWIG_fail;
29626 }
29627 {
29628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29629 }
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29637 PyObject *resultobj = 0;
29638 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29639 bool result;
29640 void *argp1 = 0 ;
29641 int res1 = 0 ;
29642 PyObject *swig_obj[1] ;
29643
29644 if (!args) SWIG_fail;
29645 swig_obj[0] = args;
29646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29649 }
29650 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29651 {
29652 PyThreadState* __tstate = wxPyBeginAllowThreads();
29653 result = (bool)(arg1)->Dispatch();
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 {
29658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29659 }
29660 return resultobj;
29661 fail:
29662 return NULL;
29663 }
29664
29665
29666 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29667 PyObject *resultobj = 0;
29668 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29669 bool result;
29670 void *argp1 = 0 ;
29671 int res1 = 0 ;
29672 PyObject *swig_obj[1] ;
29673
29674 if (!args) SWIG_fail;
29675 swig_obj[0] = args;
29676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29677 if (!SWIG_IsOK(res1)) {
29678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29679 }
29680 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29681 {
29682 PyThreadState* __tstate = wxPyBeginAllowThreads();
29683 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29684 wxPyEndAllowThreads(__tstate);
29685 if (PyErr_Occurred()) SWIG_fail;
29686 }
29687 {
29688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29689 }
29690 return resultobj;
29691 fail:
29692 return NULL;
29693 }
29694
29695
29696 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29697 PyObject *resultobj = 0;
29698 wxEventLoop *result = 0 ;
29699
29700 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 result = (wxEventLoop *)wxEventLoop::GetActive();
29704 wxPyEndAllowThreads(__tstate);
29705 if (PyErr_Occurred()) SWIG_fail;
29706 }
29707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29708 return resultobj;
29709 fail:
29710 return NULL;
29711 }
29712
29713
29714 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29715 PyObject *resultobj = 0;
29716 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29717 void *argp1 = 0 ;
29718 int res1 = 0 ;
29719 PyObject * obj0 = 0 ;
29720 char * kwnames[] = {
29721 (char *) "loop", NULL
29722 };
29723
29724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29726 if (!SWIG_IsOK(res1)) {
29727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29728 }
29729 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29730 {
29731 PyThreadState* __tstate = wxPyBeginAllowThreads();
29732 wxEventLoop::SetActive(arg1);
29733 wxPyEndAllowThreads(__tstate);
29734 if (PyErr_Occurred()) SWIG_fail;
29735 }
29736 resultobj = SWIG_Py_Void();
29737 return resultobj;
29738 fail:
29739 return NULL;
29740 }
29741
29742
29743 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29744 PyObject *obj;
29745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29746 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29747 return SWIG_Py_Void();
29748 }
29749
29750 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29751 return SWIG_Python_InitShadowInstance(args);
29752 }
29753
29754 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj = 0;
29756 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29757 wxEventLoopActivator *result = 0 ;
29758 void *argp1 = 0 ;
29759 int res1 = 0 ;
29760 PyObject * obj0 = 0 ;
29761 char * kwnames[] = {
29762 (char *) "evtLoop", NULL
29763 };
29764
29765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29767 if (!SWIG_IsOK(res1)) {
29768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29769 }
29770 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29771 {
29772 PyThreadState* __tstate = wxPyBeginAllowThreads();
29773 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29778 return resultobj;
29779 fail:
29780 return NULL;
29781 }
29782
29783
29784 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29785 PyObject *resultobj = 0;
29786 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29787 void *argp1 = 0 ;
29788 int res1 = 0 ;
29789 PyObject *swig_obj[1] ;
29790
29791 if (!args) SWIG_fail;
29792 swig_obj[0] = args;
29793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29794 if (!SWIG_IsOK(res1)) {
29795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29796 }
29797 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 delete arg1;
29801
29802 wxPyEndAllowThreads(__tstate);
29803 if (PyErr_Occurred()) SWIG_fail;
29804 }
29805 resultobj = SWIG_Py_Void();
29806 return resultobj;
29807 fail:
29808 return NULL;
29809 }
29810
29811
29812 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29813 PyObject *obj;
29814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29815 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29816 return SWIG_Py_Void();
29817 }
29818
29819 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 return SWIG_Python_InitShadowInstance(args);
29821 }
29822
29823 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29824 PyObject *resultobj = 0;
29825 int arg1 = (int) 0 ;
29826 int arg2 = (int) 0 ;
29827 int arg3 = (int) 0 ;
29828 wxAcceleratorEntry *result = 0 ;
29829 int val1 ;
29830 int ecode1 = 0 ;
29831 int val2 ;
29832 int ecode2 = 0 ;
29833 int val3 ;
29834 int ecode3 = 0 ;
29835 PyObject * obj0 = 0 ;
29836 PyObject * obj1 = 0 ;
29837 PyObject * obj2 = 0 ;
29838 char * kwnames[] = {
29839 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29840 };
29841
29842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29843 if (obj0) {
29844 ecode1 = SWIG_AsVal_int(obj0, &val1);
29845 if (!SWIG_IsOK(ecode1)) {
29846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29847 }
29848 arg1 = static_cast< int >(val1);
29849 }
29850 if (obj1) {
29851 ecode2 = SWIG_AsVal_int(obj1, &val2);
29852 if (!SWIG_IsOK(ecode2)) {
29853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29854 }
29855 arg2 = static_cast< int >(val2);
29856 }
29857 if (obj2) {
29858 ecode3 = SWIG_AsVal_int(obj2, &val3);
29859 if (!SWIG_IsOK(ecode3)) {
29860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29861 }
29862 arg3 = static_cast< int >(val3);
29863 }
29864 {
29865 PyThreadState* __tstate = wxPyBeginAllowThreads();
29866 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29871 return resultobj;
29872 fail:
29873 return NULL;
29874 }
29875
29876
29877 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29878 PyObject *resultobj = 0;
29879 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29880 void *argp1 = 0 ;
29881 int res1 = 0 ;
29882 PyObject *swig_obj[1] ;
29883
29884 if (!args) SWIG_fail;
29885 swig_obj[0] = args;
29886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29887 if (!SWIG_IsOK(res1)) {
29888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29889 }
29890 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29891 {
29892 PyThreadState* __tstate = wxPyBeginAllowThreads();
29893 delete arg1;
29894
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_Py_Void();
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29906 PyObject *resultobj = 0;
29907 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29908 int arg2 ;
29909 int arg3 ;
29910 int arg4 ;
29911 void *argp1 = 0 ;
29912 int res1 = 0 ;
29913 int val2 ;
29914 int ecode2 = 0 ;
29915 int val3 ;
29916 int ecode3 = 0 ;
29917 int val4 ;
29918 int ecode4 = 0 ;
29919 PyObject * obj0 = 0 ;
29920 PyObject * obj1 = 0 ;
29921 PyObject * obj2 = 0 ;
29922 PyObject * obj3 = 0 ;
29923 char * kwnames[] = {
29924 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29925 };
29926
29927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29929 if (!SWIG_IsOK(res1)) {
29930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29931 }
29932 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29933 ecode2 = SWIG_AsVal_int(obj1, &val2);
29934 if (!SWIG_IsOK(ecode2)) {
29935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29936 }
29937 arg2 = static_cast< int >(val2);
29938 ecode3 = SWIG_AsVal_int(obj2, &val3);
29939 if (!SWIG_IsOK(ecode3)) {
29940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29941 }
29942 arg3 = static_cast< int >(val3);
29943 ecode4 = SWIG_AsVal_int(obj3, &val4);
29944 if (!SWIG_IsOK(ecode4)) {
29945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29946 }
29947 arg4 = static_cast< int >(val4);
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 (arg1)->Set(arg2,arg3,arg4);
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 resultobj = SWIG_Py_Void();
29955 return resultobj;
29956 fail:
29957 return NULL;
29958 }
29959
29960
29961 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29962 PyObject *resultobj = 0;
29963 wxString *arg1 = 0 ;
29964 wxAcceleratorEntry *result = 0 ;
29965 bool temp1 = false ;
29966 PyObject * obj0 = 0 ;
29967 char * kwnames[] = {
29968 (char *) "str", NULL
29969 };
29970
29971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29972 {
29973 arg1 = wxString_in_helper(obj0);
29974 if (arg1 == NULL) SWIG_fail;
29975 temp1 = true;
29976 }
29977 {
29978 PyThreadState* __tstate = wxPyBeginAllowThreads();
29979 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29980 wxPyEndAllowThreads(__tstate);
29981 if (PyErr_Occurred()) SWIG_fail;
29982 }
29983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29984 {
29985 if (temp1)
29986 delete arg1;
29987 }
29988 return resultobj;
29989 fail:
29990 {
29991 if (temp1)
29992 delete arg1;
29993 }
29994 return NULL;
29995 }
29996
29997
29998 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29999 PyObject *resultobj = 0;
30000 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30001 int result;
30002 void *argp1 = 0 ;
30003 int res1 = 0 ;
30004 PyObject *swig_obj[1] ;
30005
30006 if (!args) SWIG_fail;
30007 swig_obj[0] = args;
30008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30009 if (!SWIG_IsOK(res1)) {
30010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30011 }
30012 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = (int)(arg1)->GetFlags();
30016 wxPyEndAllowThreads(__tstate);
30017 if (PyErr_Occurred()) SWIG_fail;
30018 }
30019 resultobj = SWIG_From_int(static_cast< int >(result));
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30027 PyObject *resultobj = 0;
30028 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30029 int result;
30030 void *argp1 = 0 ;
30031 int res1 = 0 ;
30032 PyObject *swig_obj[1] ;
30033
30034 if (!args) SWIG_fail;
30035 swig_obj[0] = args;
30036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30037 if (!SWIG_IsOK(res1)) {
30038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30039 }
30040 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30041 {
30042 PyThreadState* __tstate = wxPyBeginAllowThreads();
30043 result = (int)(arg1)->GetKeyCode();
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 resultobj = SWIG_From_int(static_cast< int >(result));
30048 return resultobj;
30049 fail:
30050 return NULL;
30051 }
30052
30053
30054 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30055 PyObject *resultobj = 0;
30056 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30057 int result;
30058 void *argp1 = 0 ;
30059 int res1 = 0 ;
30060 PyObject *swig_obj[1] ;
30061
30062 if (!args) SWIG_fail;
30063 swig_obj[0] = args;
30064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30065 if (!SWIG_IsOK(res1)) {
30066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30067 }
30068 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 result = (int)(arg1)->GetCommand();
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_From_int(static_cast< int >(result));
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30083 PyObject *resultobj = 0;
30084 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30085 bool result;
30086 void *argp1 = 0 ;
30087 int res1 = 0 ;
30088 PyObject *swig_obj[1] ;
30089
30090 if (!args) SWIG_fail;
30091 swig_obj[0] = args;
30092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30095 }
30096 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30100 wxPyEndAllowThreads(__tstate);
30101 if (PyErr_Occurred()) SWIG_fail;
30102 }
30103 {
30104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30105 }
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30113 PyObject *resultobj = 0;
30114 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30115 wxString result;
30116 void *argp1 = 0 ;
30117 int res1 = 0 ;
30118 PyObject *swig_obj[1] ;
30119
30120 if (!args) SWIG_fail;
30121 swig_obj[0] = args;
30122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30123 if (!SWIG_IsOK(res1)) {
30124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30125 }
30126 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30127 {
30128 PyThreadState* __tstate = wxPyBeginAllowThreads();
30129 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30130 wxPyEndAllowThreads(__tstate);
30131 if (PyErr_Occurred()) SWIG_fail;
30132 }
30133 {
30134 #if wxUSE_UNICODE
30135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30136 #else
30137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30138 #endif
30139 }
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj = 0;
30148 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30149 wxString *arg2 = 0 ;
30150 bool result;
30151 void *argp1 = 0 ;
30152 int res1 = 0 ;
30153 bool temp2 = false ;
30154 PyObject * obj0 = 0 ;
30155 PyObject * obj1 = 0 ;
30156 char * kwnames[] = {
30157 (char *) "self",(char *) "str", NULL
30158 };
30159
30160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30162 if (!SWIG_IsOK(res1)) {
30163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30164 }
30165 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30166 {
30167 arg2 = wxString_in_helper(obj1);
30168 if (arg2 == NULL) SWIG_fail;
30169 temp2 = true;
30170 }
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 {
30178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30179 }
30180 {
30181 if (temp2)
30182 delete arg2;
30183 }
30184 return resultobj;
30185 fail:
30186 {
30187 if (temp2)
30188 delete arg2;
30189 }
30190 return NULL;
30191 }
30192
30193
30194 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30195 PyObject *obj;
30196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30197 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30198 return SWIG_Py_Void();
30199 }
30200
30201 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30202 return SWIG_Python_InitShadowInstance(args);
30203 }
30204
30205 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30206 PyObject *resultobj = 0;
30207 int arg1 ;
30208 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30209 wxAcceleratorTable *result = 0 ;
30210 PyObject * obj0 = 0 ;
30211 char * kwnames[] = {
30212 (char *) "n", NULL
30213 };
30214
30215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30216 {
30217 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30218 if (arg2) arg1 = PyList_Size(obj0);
30219 else arg1 = 0;
30220 }
30221 {
30222 PyThreadState* __tstate = wxPyBeginAllowThreads();
30223 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30224 wxPyEndAllowThreads(__tstate);
30225 if (PyErr_Occurred()) SWIG_fail;
30226 }
30227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30228 return resultobj;
30229 fail:
30230 return NULL;
30231 }
30232
30233
30234 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30235 PyObject *resultobj = 0;
30236 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30237 void *argp1 = 0 ;
30238 int res1 = 0 ;
30239 PyObject *swig_obj[1] ;
30240
30241 if (!args) SWIG_fail;
30242 swig_obj[0] = args;
30243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30244 if (!SWIG_IsOK(res1)) {
30245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30246 }
30247 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30248 {
30249 PyThreadState* __tstate = wxPyBeginAllowThreads();
30250 delete arg1;
30251
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 resultobj = SWIG_Py_Void();
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30263 PyObject *resultobj = 0;
30264 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30265 bool result;
30266 void *argp1 = 0 ;
30267 int res1 = 0 ;
30268 PyObject *swig_obj[1] ;
30269
30270 if (!args) SWIG_fail;
30271 swig_obj[0] = args;
30272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30273 if (!SWIG_IsOK(res1)) {
30274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30275 }
30276 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30277 {
30278 PyThreadState* __tstate = wxPyBeginAllowThreads();
30279 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30280 wxPyEndAllowThreads(__tstate);
30281 if (PyErr_Occurred()) SWIG_fail;
30282 }
30283 {
30284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30285 }
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30293 PyObject *obj;
30294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30295 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30296 return SWIG_Py_Void();
30297 }
30298
30299 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30300 return SWIG_Python_InitShadowInstance(args);
30301 }
30302
30303 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30304 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30305 return 1;
30306 }
30307
30308
30309 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30310 PyObject *pyobj = 0;
30311
30312 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30313 return pyobj;
30314 }
30315
30316
30317 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30318 PyObject *resultobj = 0;
30319 wxString *arg1 = 0 ;
30320 wxAcceleratorEntry *result = 0 ;
30321 bool temp1 = false ;
30322 PyObject * obj0 = 0 ;
30323 char * kwnames[] = {
30324 (char *) "label", NULL
30325 };
30326
30327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30328 {
30329 arg1 = wxString_in_helper(obj0);
30330 if (arg1 == NULL) SWIG_fail;
30331 temp1 = true;
30332 }
30333 {
30334 PyThreadState* __tstate = wxPyBeginAllowThreads();
30335 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30340 {
30341 if (temp1)
30342 delete arg1;
30343 }
30344 return resultobj;
30345 fail:
30346 {
30347 if (temp1)
30348 delete arg1;
30349 }
30350 return NULL;
30351 }
30352
30353
30354 SWIGINTERN int PanelNameStr_set(PyObject *) {
30355 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30356 return 1;
30357 }
30358
30359
30360 SWIGINTERN PyObject *PanelNameStr_get(void) {
30361 PyObject *pyobj = 0;
30362
30363 {
30364 #if wxUSE_UNICODE
30365 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30366 #else
30367 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30368 #endif
30369 }
30370 return pyobj;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30375 PyObject *resultobj = 0;
30376 wxVisualAttributes *result = 0 ;
30377
30378 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 result = (wxVisualAttributes *)new_wxVisualAttributes();
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30386 return resultobj;
30387 fail:
30388 return NULL;
30389 }
30390
30391
30392 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30393 PyObject *resultobj = 0;
30394 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30395 void *argp1 = 0 ;
30396 int res1 = 0 ;
30397 PyObject *swig_obj[1] ;
30398
30399 if (!args) SWIG_fail;
30400 swig_obj[0] = args;
30401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30402 if (!SWIG_IsOK(res1)) {
30403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30404 }
30405 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30406 {
30407 PyThreadState* __tstate = wxPyBeginAllowThreads();
30408 delete_wxVisualAttributes(arg1);
30409
30410 wxPyEndAllowThreads(__tstate);
30411 if (PyErr_Occurred()) SWIG_fail;
30412 }
30413 resultobj = SWIG_Py_Void();
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30421 PyObject *resultobj = 0;
30422 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30423 wxFont *arg2 = (wxFont *) 0 ;
30424 void *argp1 = 0 ;
30425 int res1 = 0 ;
30426 void *argp2 = 0 ;
30427 int res2 = 0 ;
30428 PyObject *swig_obj[2] ;
30429
30430 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30432 if (!SWIG_IsOK(res1)) {
30433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30434 }
30435 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30436 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30437 if (!SWIG_IsOK(res2)) {
30438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30439 }
30440 arg2 = reinterpret_cast< wxFont * >(argp2);
30441 if (arg1) (arg1)->font = *arg2;
30442
30443 resultobj = SWIG_Py_Void();
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30451 PyObject *resultobj = 0;
30452 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30453 wxFont *result = 0 ;
30454 void *argp1 = 0 ;
30455 int res1 = 0 ;
30456 PyObject *swig_obj[1] ;
30457
30458 if (!args) SWIG_fail;
30459 swig_obj[0] = args;
30460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30463 }
30464 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30465 result = (wxFont *)& ((arg1)->font);
30466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30467 return resultobj;
30468 fail:
30469 return NULL;
30470 }
30471
30472
30473 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30474 PyObject *resultobj = 0;
30475 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30476 wxColour *arg2 = (wxColour *) 0 ;
30477 void *argp1 = 0 ;
30478 int res1 = 0 ;
30479 void *argp2 = 0 ;
30480 int res2 = 0 ;
30481 PyObject *swig_obj[2] ;
30482
30483 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30485 if (!SWIG_IsOK(res1)) {
30486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30487 }
30488 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30489 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30490 if (!SWIG_IsOK(res2)) {
30491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30492 }
30493 arg2 = reinterpret_cast< wxColour * >(argp2);
30494 if (arg1) (arg1)->colFg = *arg2;
30495
30496 resultobj = SWIG_Py_Void();
30497 return resultobj;
30498 fail:
30499 return NULL;
30500 }
30501
30502
30503 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30504 PyObject *resultobj = 0;
30505 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30506 wxColour *result = 0 ;
30507 void *argp1 = 0 ;
30508 int res1 = 0 ;
30509 PyObject *swig_obj[1] ;
30510
30511 if (!args) SWIG_fail;
30512 swig_obj[0] = args;
30513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30514 if (!SWIG_IsOK(res1)) {
30515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30516 }
30517 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30518 result = (wxColour *)& ((arg1)->colFg);
30519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30520 return resultobj;
30521 fail:
30522 return NULL;
30523 }
30524
30525
30526 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30527 PyObject *resultobj = 0;
30528 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30529 wxColour *arg2 = (wxColour *) 0 ;
30530 void *argp1 = 0 ;
30531 int res1 = 0 ;
30532 void *argp2 = 0 ;
30533 int res2 = 0 ;
30534 PyObject *swig_obj[2] ;
30535
30536 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30538 if (!SWIG_IsOK(res1)) {
30539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30540 }
30541 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30542 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30543 if (!SWIG_IsOK(res2)) {
30544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30545 }
30546 arg2 = reinterpret_cast< wxColour * >(argp2);
30547 if (arg1) (arg1)->colBg = *arg2;
30548
30549 resultobj = SWIG_Py_Void();
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557 PyObject *resultobj = 0;
30558 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30559 wxColour *result = 0 ;
30560 void *argp1 = 0 ;
30561 int res1 = 0 ;
30562 PyObject *swig_obj[1] ;
30563
30564 if (!args) SWIG_fail;
30565 swig_obj[0] = args;
30566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30567 if (!SWIG_IsOK(res1)) {
30568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30569 }
30570 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30571 result = (wxColour *)& ((arg1)->colBg);
30572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30573 return resultobj;
30574 fail:
30575 return NULL;
30576 }
30577
30578
30579 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30580 PyObject *obj;
30581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30582 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30583 return SWIG_Py_Void();
30584 }
30585
30586 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 return SWIG_Python_InitShadowInstance(args);
30588 }
30589
30590 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30591 PyObject *resultobj = 0;
30592 wxWindow *arg1 = (wxWindow *) 0 ;
30593 int arg2 = (int) (int)-1 ;
30594 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30595 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30596 wxSize const &arg4_defvalue = wxDefaultSize ;
30597 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30598 long arg5 = (long) 0 ;
30599 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30600 wxString *arg6 = (wxString *) &arg6_defvalue ;
30601 wxWindow *result = 0 ;
30602 void *argp1 = 0 ;
30603 int res1 = 0 ;
30604 int val2 ;
30605 int ecode2 = 0 ;
30606 wxPoint temp3 ;
30607 wxSize temp4 ;
30608 long val5 ;
30609 int ecode5 = 0 ;
30610 bool temp6 = false ;
30611 PyObject * obj0 = 0 ;
30612 PyObject * obj1 = 0 ;
30613 PyObject * obj2 = 0 ;
30614 PyObject * obj3 = 0 ;
30615 PyObject * obj4 = 0 ;
30616 PyObject * obj5 = 0 ;
30617 char * kwnames[] = {
30618 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30619 };
30620
30621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30625 }
30626 arg1 = reinterpret_cast< wxWindow * >(argp1);
30627 if (obj1) {
30628 ecode2 = SWIG_AsVal_int(obj1, &val2);
30629 if (!SWIG_IsOK(ecode2)) {
30630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30631 }
30632 arg2 = static_cast< int >(val2);
30633 }
30634 if (obj2) {
30635 {
30636 arg3 = &temp3;
30637 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30638 }
30639 }
30640 if (obj3) {
30641 {
30642 arg4 = &temp4;
30643 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30644 }
30645 }
30646 if (obj4) {
30647 ecode5 = SWIG_AsVal_long(obj4, &val5);
30648 if (!SWIG_IsOK(ecode5)) {
30649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30650 }
30651 arg5 = static_cast< long >(val5);
30652 }
30653 if (obj5) {
30654 {
30655 arg6 = wxString_in_helper(obj5);
30656 if (arg6 == NULL) SWIG_fail;
30657 temp6 = true;
30658 }
30659 }
30660 {
30661 if (!wxPyCheckForApp()) SWIG_fail;
30662 PyThreadState* __tstate = wxPyBeginAllowThreads();
30663 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30664 wxPyEndAllowThreads(__tstate);
30665 if (PyErr_Occurred()) SWIG_fail;
30666 }
30667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30668 {
30669 if (temp6)
30670 delete arg6;
30671 }
30672 return resultobj;
30673 fail:
30674 {
30675 if (temp6)
30676 delete arg6;
30677 }
30678 return NULL;
30679 }
30680
30681
30682 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30683 PyObject *resultobj = 0;
30684 wxWindow *result = 0 ;
30685
30686 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30687 {
30688 if (!wxPyCheckForApp()) SWIG_fail;
30689 PyThreadState* __tstate = wxPyBeginAllowThreads();
30690 result = (wxWindow *)new wxWindow();
30691 wxPyEndAllowThreads(__tstate);
30692 if (PyErr_Occurred()) SWIG_fail;
30693 }
30694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30695 return resultobj;
30696 fail:
30697 return NULL;
30698 }
30699
30700
30701 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30702 PyObject *resultobj = 0;
30703 wxWindow *arg1 = (wxWindow *) 0 ;
30704 wxWindow *arg2 = (wxWindow *) 0 ;
30705 int arg3 = (int) (int)-1 ;
30706 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30707 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30708 wxSize const &arg5_defvalue = wxDefaultSize ;
30709 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30710 long arg6 = (long) 0 ;
30711 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30712 wxString *arg7 = (wxString *) &arg7_defvalue ;
30713 bool result;
30714 void *argp1 = 0 ;
30715 int res1 = 0 ;
30716 void *argp2 = 0 ;
30717 int res2 = 0 ;
30718 int val3 ;
30719 int ecode3 = 0 ;
30720 wxPoint temp4 ;
30721 wxSize temp5 ;
30722 long val6 ;
30723 int ecode6 = 0 ;
30724 bool temp7 = false ;
30725 PyObject * obj0 = 0 ;
30726 PyObject * obj1 = 0 ;
30727 PyObject * obj2 = 0 ;
30728 PyObject * obj3 = 0 ;
30729 PyObject * obj4 = 0 ;
30730 PyObject * obj5 = 0 ;
30731 PyObject * obj6 = 0 ;
30732 char * kwnames[] = {
30733 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30734 };
30735
30736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30740 }
30741 arg1 = reinterpret_cast< wxWindow * >(argp1);
30742 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30743 if (!SWIG_IsOK(res2)) {
30744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30745 }
30746 arg2 = reinterpret_cast< wxWindow * >(argp2);
30747 if (obj2) {
30748 ecode3 = SWIG_AsVal_int(obj2, &val3);
30749 if (!SWIG_IsOK(ecode3)) {
30750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30751 }
30752 arg3 = static_cast< int >(val3);
30753 }
30754 if (obj3) {
30755 {
30756 arg4 = &temp4;
30757 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30758 }
30759 }
30760 if (obj4) {
30761 {
30762 arg5 = &temp5;
30763 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30764 }
30765 }
30766 if (obj5) {
30767 ecode6 = SWIG_AsVal_long(obj5, &val6);
30768 if (!SWIG_IsOK(ecode6)) {
30769 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30770 }
30771 arg6 = static_cast< long >(val6);
30772 }
30773 if (obj6) {
30774 {
30775 arg7 = wxString_in_helper(obj6);
30776 if (arg7 == NULL) SWIG_fail;
30777 temp7 = true;
30778 }
30779 }
30780 {
30781 PyThreadState* __tstate = wxPyBeginAllowThreads();
30782 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30783 wxPyEndAllowThreads(__tstate);
30784 if (PyErr_Occurred()) SWIG_fail;
30785 }
30786 {
30787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30788 }
30789 {
30790 if (temp7)
30791 delete arg7;
30792 }
30793 return resultobj;
30794 fail:
30795 {
30796 if (temp7)
30797 delete arg7;
30798 }
30799 return NULL;
30800 }
30801
30802
30803 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj = 0;
30805 wxWindow *arg1 = (wxWindow *) 0 ;
30806 bool arg2 = (bool) false ;
30807 bool result;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 bool val2 ;
30811 int ecode2 = 0 ;
30812 PyObject * obj0 = 0 ;
30813 PyObject * obj1 = 0 ;
30814 char * kwnames[] = {
30815 (char *) "self",(char *) "force", NULL
30816 };
30817
30818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30822 }
30823 arg1 = reinterpret_cast< wxWindow * >(argp1);
30824 if (obj1) {
30825 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30826 if (!SWIG_IsOK(ecode2)) {
30827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30828 }
30829 arg2 = static_cast< bool >(val2);
30830 }
30831 {
30832 PyThreadState* __tstate = wxPyBeginAllowThreads();
30833 result = (bool)(arg1)->Close(arg2);
30834 wxPyEndAllowThreads(__tstate);
30835 if (PyErr_Occurred()) SWIG_fail;
30836 }
30837 {
30838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30839 }
30840 return resultobj;
30841 fail:
30842 return NULL;
30843 }
30844
30845
30846 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30847 PyObject *resultobj = 0;
30848 wxWindow *arg1 = (wxWindow *) 0 ;
30849 bool result;
30850 void *argp1 = 0 ;
30851 int res1 = 0 ;
30852 PyObject *swig_obj[1] ;
30853
30854 if (!args) SWIG_fail;
30855 swig_obj[0] = args;
30856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30857 if (!SWIG_IsOK(res1)) {
30858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30859 }
30860 arg1 = reinterpret_cast< wxWindow * >(argp1);
30861 {
30862 PyThreadState* __tstate = wxPyBeginAllowThreads();
30863 result = (bool)(arg1)->Destroy();
30864 wxPyEndAllowThreads(__tstate);
30865 if (PyErr_Occurred()) SWIG_fail;
30866 }
30867 {
30868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30869 }
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30877 PyObject *resultobj = 0;
30878 wxWindow *arg1 = (wxWindow *) 0 ;
30879 bool result;
30880 void *argp1 = 0 ;
30881 int res1 = 0 ;
30882 PyObject *swig_obj[1] ;
30883
30884 if (!args) SWIG_fail;
30885 swig_obj[0] = args;
30886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30887 if (!SWIG_IsOK(res1)) {
30888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30889 }
30890 arg1 = reinterpret_cast< wxWindow * >(argp1);
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 result = (bool)(arg1)->DestroyChildren();
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 {
30898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30899 }
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30907 PyObject *resultobj = 0;
30908 wxWindow *arg1 = (wxWindow *) 0 ;
30909 bool result;
30910 void *argp1 = 0 ;
30911 int res1 = 0 ;
30912 PyObject *swig_obj[1] ;
30913
30914 if (!args) SWIG_fail;
30915 swig_obj[0] = args;
30916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30917 if (!SWIG_IsOK(res1)) {
30918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30919 }
30920 arg1 = reinterpret_cast< wxWindow * >(argp1);
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30924 wxPyEndAllowThreads(__tstate);
30925 if (PyErr_Occurred()) SWIG_fail;
30926 }
30927 {
30928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30929 }
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj = 0;
30938 wxWindow *arg1 = (wxWindow *) 0 ;
30939 wxString *arg2 = 0 ;
30940 void *argp1 = 0 ;
30941 int res1 = 0 ;
30942 bool temp2 = false ;
30943 PyObject * obj0 = 0 ;
30944 PyObject * obj1 = 0 ;
30945 char * kwnames[] = {
30946 (char *) "self",(char *) "label", NULL
30947 };
30948
30949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30951 if (!SWIG_IsOK(res1)) {
30952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30953 }
30954 arg1 = reinterpret_cast< wxWindow * >(argp1);
30955 {
30956 arg2 = wxString_in_helper(obj1);
30957 if (arg2 == NULL) SWIG_fail;
30958 temp2 = true;
30959 }
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 (arg1)->SetLabel((wxString const &)*arg2);
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 resultobj = SWIG_Py_Void();
30967 {
30968 if (temp2)
30969 delete arg2;
30970 }
30971 return resultobj;
30972 fail:
30973 {
30974 if (temp2)
30975 delete arg2;
30976 }
30977 return NULL;
30978 }
30979
30980
30981 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30982 PyObject *resultobj = 0;
30983 wxWindow *arg1 = (wxWindow *) 0 ;
30984 wxString result;
30985 void *argp1 = 0 ;
30986 int res1 = 0 ;
30987 PyObject *swig_obj[1] ;
30988
30989 if (!args) SWIG_fail;
30990 swig_obj[0] = args;
30991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30992 if (!SWIG_IsOK(res1)) {
30993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30994 }
30995 arg1 = reinterpret_cast< wxWindow * >(argp1);
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = ((wxWindow const *)arg1)->GetLabel();
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 {
31003 #if wxUSE_UNICODE
31004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31005 #else
31006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31007 #endif
31008 }
31009 return resultobj;
31010 fail:
31011 return NULL;
31012 }
31013
31014
31015 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31016 PyObject *resultobj = 0;
31017 wxWindow *arg1 = (wxWindow *) 0 ;
31018 wxString *arg2 = 0 ;
31019 void *argp1 = 0 ;
31020 int res1 = 0 ;
31021 bool temp2 = false ;
31022 PyObject * obj0 = 0 ;
31023 PyObject * obj1 = 0 ;
31024 char * kwnames[] = {
31025 (char *) "self",(char *) "name", NULL
31026 };
31027
31028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31030 if (!SWIG_IsOK(res1)) {
31031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31032 }
31033 arg1 = reinterpret_cast< wxWindow * >(argp1);
31034 {
31035 arg2 = wxString_in_helper(obj1);
31036 if (arg2 == NULL) SWIG_fail;
31037 temp2 = true;
31038 }
31039 {
31040 PyThreadState* __tstate = wxPyBeginAllowThreads();
31041 (arg1)->SetName((wxString const &)*arg2);
31042 wxPyEndAllowThreads(__tstate);
31043 if (PyErr_Occurred()) SWIG_fail;
31044 }
31045 resultobj = SWIG_Py_Void();
31046 {
31047 if (temp2)
31048 delete arg2;
31049 }
31050 return resultobj;
31051 fail:
31052 {
31053 if (temp2)
31054 delete arg2;
31055 }
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31061 PyObject *resultobj = 0;
31062 wxWindow *arg1 = (wxWindow *) 0 ;
31063 wxString result;
31064 void *argp1 = 0 ;
31065 int res1 = 0 ;
31066 PyObject *swig_obj[1] ;
31067
31068 if (!args) SWIG_fail;
31069 swig_obj[0] = args;
31070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31071 if (!SWIG_IsOK(res1)) {
31072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31073 }
31074 arg1 = reinterpret_cast< wxWindow * >(argp1);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 result = ((wxWindow const *)arg1)->GetName();
31078 wxPyEndAllowThreads(__tstate);
31079 if (PyErr_Occurred()) SWIG_fail;
31080 }
31081 {
31082 #if wxUSE_UNICODE
31083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31084 #else
31085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31086 #endif
31087 }
31088 return resultobj;
31089 fail:
31090 return NULL;
31091 }
31092
31093
31094 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31095 PyObject *resultobj = 0;
31096 wxWindow *arg1 = (wxWindow *) 0 ;
31097 wxWindowVariant arg2 ;
31098 void *argp1 = 0 ;
31099 int res1 = 0 ;
31100 int val2 ;
31101 int ecode2 = 0 ;
31102 PyObject * obj0 = 0 ;
31103 PyObject * obj1 = 0 ;
31104 char * kwnames[] = {
31105 (char *) "self",(char *) "variant", NULL
31106 };
31107
31108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31110 if (!SWIG_IsOK(res1)) {
31111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31112 }
31113 arg1 = reinterpret_cast< wxWindow * >(argp1);
31114 ecode2 = SWIG_AsVal_int(obj1, &val2);
31115 if (!SWIG_IsOK(ecode2)) {
31116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31117 }
31118 arg2 = static_cast< wxWindowVariant >(val2);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 (arg1)->SetWindowVariant(arg2);
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_Py_Void();
31126 return resultobj;
31127 fail:
31128 return NULL;
31129 }
31130
31131
31132 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31133 PyObject *resultobj = 0;
31134 wxWindow *arg1 = (wxWindow *) 0 ;
31135 wxWindowVariant result;
31136 void *argp1 = 0 ;
31137 int res1 = 0 ;
31138 PyObject *swig_obj[1] ;
31139
31140 if (!args) SWIG_fail;
31141 swig_obj[0] = args;
31142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31143 if (!SWIG_IsOK(res1)) {
31144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31145 }
31146 arg1 = reinterpret_cast< wxWindow * >(argp1);
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_From_int(static_cast< int >(result));
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31161 PyObject *resultobj = 0;
31162 wxWindow *arg1 = (wxWindow *) 0 ;
31163 int arg2 ;
31164 void *argp1 = 0 ;
31165 int res1 = 0 ;
31166 int val2 ;
31167 int ecode2 = 0 ;
31168 PyObject * obj0 = 0 ;
31169 PyObject * obj1 = 0 ;
31170 char * kwnames[] = {
31171 (char *) "self",(char *) "winid", NULL
31172 };
31173
31174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31176 if (!SWIG_IsOK(res1)) {
31177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31178 }
31179 arg1 = reinterpret_cast< wxWindow * >(argp1);
31180 ecode2 = SWIG_AsVal_int(obj1, &val2);
31181 if (!SWIG_IsOK(ecode2)) {
31182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31183 }
31184 arg2 = static_cast< int >(val2);
31185 {
31186 PyThreadState* __tstate = wxPyBeginAllowThreads();
31187 (arg1)->SetId(arg2);
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 resultobj = SWIG_Py_Void();
31192 return resultobj;
31193 fail:
31194 return NULL;
31195 }
31196
31197
31198 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31199 PyObject *resultobj = 0;
31200 wxWindow *arg1 = (wxWindow *) 0 ;
31201 int result;
31202 void *argp1 = 0 ;
31203 int res1 = 0 ;
31204 PyObject *swig_obj[1] ;
31205
31206 if (!args) SWIG_fail;
31207 swig_obj[0] = args;
31208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31209 if (!SWIG_IsOK(res1)) {
31210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31211 }
31212 arg1 = reinterpret_cast< wxWindow * >(argp1);
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 result = (int)((wxWindow const *)arg1)->GetId();
31216 wxPyEndAllowThreads(__tstate);
31217 if (PyErr_Occurred()) SWIG_fail;
31218 }
31219 resultobj = SWIG_From_int(static_cast< int >(result));
31220 return resultobj;
31221 fail:
31222 return NULL;
31223 }
31224
31225
31226 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31227 PyObject *resultobj = 0;
31228 int result;
31229
31230 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31231 {
31232 PyThreadState* __tstate = wxPyBeginAllowThreads();
31233 result = (int)wxWindow::NewControlId();
31234 wxPyEndAllowThreads(__tstate);
31235 if (PyErr_Occurred()) SWIG_fail;
31236 }
31237 resultobj = SWIG_From_int(static_cast< int >(result));
31238 return resultobj;
31239 fail:
31240 return NULL;
31241 }
31242
31243
31244 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31245 PyObject *resultobj = 0;
31246 int arg1 ;
31247 int result;
31248 int val1 ;
31249 int ecode1 = 0 ;
31250 PyObject * obj0 = 0 ;
31251 char * kwnames[] = {
31252 (char *) "winid", NULL
31253 };
31254
31255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31256 ecode1 = SWIG_AsVal_int(obj0, &val1);
31257 if (!SWIG_IsOK(ecode1)) {
31258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31259 }
31260 arg1 = static_cast< int >(val1);
31261 {
31262 PyThreadState* __tstate = wxPyBeginAllowThreads();
31263 result = (int)wxWindow::NextControlId(arg1);
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 resultobj = SWIG_From_int(static_cast< int >(result));
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj = 0;
31276 int arg1 ;
31277 int result;
31278 int val1 ;
31279 int ecode1 = 0 ;
31280 PyObject * obj0 = 0 ;
31281 char * kwnames[] = {
31282 (char *) "winid", NULL
31283 };
31284
31285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31286 ecode1 = SWIG_AsVal_int(obj0, &val1);
31287 if (!SWIG_IsOK(ecode1)) {
31288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31289 }
31290 arg1 = static_cast< int >(val1);
31291 {
31292 PyThreadState* __tstate = wxPyBeginAllowThreads();
31293 result = (int)wxWindow::PrevControlId(arg1);
31294 wxPyEndAllowThreads(__tstate);
31295 if (PyErr_Occurred()) SWIG_fail;
31296 }
31297 resultobj = SWIG_From_int(static_cast< int >(result));
31298 return resultobj;
31299 fail:
31300 return NULL;
31301 }
31302
31303
31304 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31305 PyObject *resultobj = 0;
31306 wxWindow *arg1 = (wxWindow *) 0 ;
31307 wxLayoutDirection result;
31308 void *argp1 = 0 ;
31309 int res1 = 0 ;
31310 PyObject *swig_obj[1] ;
31311
31312 if (!args) SWIG_fail;
31313 swig_obj[0] = args;
31314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31315 if (!SWIG_IsOK(res1)) {
31316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31317 }
31318 arg1 = reinterpret_cast< wxWindow * >(argp1);
31319 {
31320 PyThreadState* __tstate = wxPyBeginAllowThreads();
31321 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31322 wxPyEndAllowThreads(__tstate);
31323 if (PyErr_Occurred()) SWIG_fail;
31324 }
31325 resultobj = SWIG_From_int(static_cast< int >(result));
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj = 0;
31334 wxWindow *arg1 = (wxWindow *) 0 ;
31335 wxLayoutDirection arg2 ;
31336 void *argp1 = 0 ;
31337 int res1 = 0 ;
31338 int val2 ;
31339 int ecode2 = 0 ;
31340 PyObject * obj0 = 0 ;
31341 PyObject * obj1 = 0 ;
31342 char * kwnames[] = {
31343 (char *) "self",(char *) "dir", NULL
31344 };
31345
31346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31348 if (!SWIG_IsOK(res1)) {
31349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31350 }
31351 arg1 = reinterpret_cast< wxWindow * >(argp1);
31352 ecode2 = SWIG_AsVal_int(obj1, &val2);
31353 if (!SWIG_IsOK(ecode2)) {
31354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31355 }
31356 arg2 = static_cast< wxLayoutDirection >(val2);
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 (arg1)->SetLayoutDirection(arg2);
31360 wxPyEndAllowThreads(__tstate);
31361 if (PyErr_Occurred()) SWIG_fail;
31362 }
31363 resultobj = SWIG_Py_Void();
31364 return resultobj;
31365 fail:
31366 return NULL;
31367 }
31368
31369
31370 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31371 PyObject *resultobj = 0;
31372 wxWindow *arg1 = (wxWindow *) 0 ;
31373 int arg2 ;
31374 int arg3 ;
31375 int arg4 ;
31376 int result;
31377 void *argp1 = 0 ;
31378 int res1 = 0 ;
31379 int val2 ;
31380 int ecode2 = 0 ;
31381 int val3 ;
31382 int ecode3 = 0 ;
31383 int val4 ;
31384 int ecode4 = 0 ;
31385 PyObject * obj0 = 0 ;
31386 PyObject * obj1 = 0 ;
31387 PyObject * obj2 = 0 ;
31388 PyObject * obj3 = 0 ;
31389 char * kwnames[] = {
31390 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31391 };
31392
31393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31395 if (!SWIG_IsOK(res1)) {
31396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31397 }
31398 arg1 = reinterpret_cast< wxWindow * >(argp1);
31399 ecode2 = SWIG_AsVal_int(obj1, &val2);
31400 if (!SWIG_IsOK(ecode2)) {
31401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31402 }
31403 arg2 = static_cast< int >(val2);
31404 ecode3 = SWIG_AsVal_int(obj2, &val3);
31405 if (!SWIG_IsOK(ecode3)) {
31406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31407 }
31408 arg3 = static_cast< int >(val3);
31409 ecode4 = SWIG_AsVal_int(obj3, &val4);
31410 if (!SWIG_IsOK(ecode4)) {
31411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31412 }
31413 arg4 = static_cast< int >(val4);
31414 {
31415 PyThreadState* __tstate = wxPyBeginAllowThreads();
31416 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31417 wxPyEndAllowThreads(__tstate);
31418 if (PyErr_Occurred()) SWIG_fail;
31419 }
31420 resultobj = SWIG_From_int(static_cast< int >(result));
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31428 PyObject *resultobj = 0;
31429 wxWindow *arg1 = (wxWindow *) 0 ;
31430 wxSize *arg2 = 0 ;
31431 void *argp1 = 0 ;
31432 int res1 = 0 ;
31433 wxSize temp2 ;
31434 PyObject * obj0 = 0 ;
31435 PyObject * obj1 = 0 ;
31436 char * kwnames[] = {
31437 (char *) "self",(char *) "size", NULL
31438 };
31439
31440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31442 if (!SWIG_IsOK(res1)) {
31443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31444 }
31445 arg1 = reinterpret_cast< wxWindow * >(argp1);
31446 {
31447 arg2 = &temp2;
31448 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31449 }
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 (arg1)->SetSize((wxSize const &)*arg2);
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_Py_Void();
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31464 PyObject *resultobj = 0;
31465 wxWindow *arg1 = (wxWindow *) 0 ;
31466 int arg2 ;
31467 int arg3 ;
31468 int arg4 ;
31469 int arg5 ;
31470 int arg6 = (int) wxSIZE_AUTO ;
31471 void *argp1 = 0 ;
31472 int res1 = 0 ;
31473 int val2 ;
31474 int ecode2 = 0 ;
31475 int val3 ;
31476 int ecode3 = 0 ;
31477 int val4 ;
31478 int ecode4 = 0 ;
31479 int val5 ;
31480 int ecode5 = 0 ;
31481 int val6 ;
31482 int ecode6 = 0 ;
31483 PyObject * obj0 = 0 ;
31484 PyObject * obj1 = 0 ;
31485 PyObject * obj2 = 0 ;
31486 PyObject * obj3 = 0 ;
31487 PyObject * obj4 = 0 ;
31488 PyObject * obj5 = 0 ;
31489 char * kwnames[] = {
31490 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31491 };
31492
31493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31495 if (!SWIG_IsOK(res1)) {
31496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31497 }
31498 arg1 = reinterpret_cast< wxWindow * >(argp1);
31499 ecode2 = SWIG_AsVal_int(obj1, &val2);
31500 if (!SWIG_IsOK(ecode2)) {
31501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31502 }
31503 arg2 = static_cast< int >(val2);
31504 ecode3 = SWIG_AsVal_int(obj2, &val3);
31505 if (!SWIG_IsOK(ecode3)) {
31506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31507 }
31508 arg3 = static_cast< int >(val3);
31509 ecode4 = SWIG_AsVal_int(obj3, &val4);
31510 if (!SWIG_IsOK(ecode4)) {
31511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31512 }
31513 arg4 = static_cast< int >(val4);
31514 ecode5 = SWIG_AsVal_int(obj4, &val5);
31515 if (!SWIG_IsOK(ecode5)) {
31516 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31517 }
31518 arg5 = static_cast< int >(val5);
31519 if (obj5) {
31520 ecode6 = SWIG_AsVal_int(obj5, &val6);
31521 if (!SWIG_IsOK(ecode6)) {
31522 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31523 }
31524 arg6 = static_cast< int >(val6);
31525 }
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 resultobj = SWIG_Py_Void();
31533 return resultobj;
31534 fail:
31535 return NULL;
31536 }
31537
31538
31539 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31540 PyObject *resultobj = 0;
31541 wxWindow *arg1 = (wxWindow *) 0 ;
31542 wxRect *arg2 = 0 ;
31543 int arg3 = (int) wxSIZE_AUTO ;
31544 void *argp1 = 0 ;
31545 int res1 = 0 ;
31546 wxRect temp2 ;
31547 int val3 ;
31548 int ecode3 = 0 ;
31549 PyObject * obj0 = 0 ;
31550 PyObject * obj1 = 0 ;
31551 PyObject * obj2 = 0 ;
31552 char * kwnames[] = {
31553 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31554 };
31555
31556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31558 if (!SWIG_IsOK(res1)) {
31559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31560 }
31561 arg1 = reinterpret_cast< wxWindow * >(argp1);
31562 {
31563 arg2 = &temp2;
31564 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31565 }
31566 if (obj2) {
31567 ecode3 = SWIG_AsVal_int(obj2, &val3);
31568 if (!SWIG_IsOK(ecode3)) {
31569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31570 }
31571 arg3 = static_cast< int >(val3);
31572 }
31573 {
31574 PyThreadState* __tstate = wxPyBeginAllowThreads();
31575 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31576 wxPyEndAllowThreads(__tstate);
31577 if (PyErr_Occurred()) SWIG_fail;
31578 }
31579 resultobj = SWIG_Py_Void();
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31587 PyObject *resultobj = 0;
31588 wxWindow *arg1 = (wxWindow *) 0 ;
31589 int arg2 ;
31590 int arg3 ;
31591 void *argp1 = 0 ;
31592 int res1 = 0 ;
31593 int val2 ;
31594 int ecode2 = 0 ;
31595 int val3 ;
31596 int ecode3 = 0 ;
31597 PyObject * obj0 = 0 ;
31598 PyObject * obj1 = 0 ;
31599 PyObject * obj2 = 0 ;
31600 char * kwnames[] = {
31601 (char *) "self",(char *) "width",(char *) "height", NULL
31602 };
31603
31604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31606 if (!SWIG_IsOK(res1)) {
31607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31608 }
31609 arg1 = reinterpret_cast< wxWindow * >(argp1);
31610 ecode2 = SWIG_AsVal_int(obj1, &val2);
31611 if (!SWIG_IsOK(ecode2)) {
31612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31613 }
31614 arg2 = static_cast< int >(val2);
31615 ecode3 = SWIG_AsVal_int(obj2, &val3);
31616 if (!SWIG_IsOK(ecode3)) {
31617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31618 }
31619 arg3 = static_cast< int >(val3);
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 (arg1)->SetSize(arg2,arg3);
31623 wxPyEndAllowThreads(__tstate);
31624 if (PyErr_Occurred()) SWIG_fail;
31625 }
31626 resultobj = SWIG_Py_Void();
31627 return resultobj;
31628 fail:
31629 return NULL;
31630 }
31631
31632
31633 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31634 PyObject *resultobj = 0;
31635 wxWindow *arg1 = (wxWindow *) 0 ;
31636 wxPoint *arg2 = 0 ;
31637 int arg3 = (int) wxSIZE_USE_EXISTING ;
31638 void *argp1 = 0 ;
31639 int res1 = 0 ;
31640 wxPoint temp2 ;
31641 int val3 ;
31642 int ecode3 = 0 ;
31643 PyObject * obj0 = 0 ;
31644 PyObject * obj1 = 0 ;
31645 PyObject * obj2 = 0 ;
31646 char * kwnames[] = {
31647 (char *) "self",(char *) "pt",(char *) "flags", NULL
31648 };
31649
31650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31652 if (!SWIG_IsOK(res1)) {
31653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31654 }
31655 arg1 = reinterpret_cast< wxWindow * >(argp1);
31656 {
31657 arg2 = &temp2;
31658 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31659 }
31660 if (obj2) {
31661 ecode3 = SWIG_AsVal_int(obj2, &val3);
31662 if (!SWIG_IsOK(ecode3)) {
31663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31664 }
31665 arg3 = static_cast< int >(val3);
31666 }
31667 {
31668 PyThreadState* __tstate = wxPyBeginAllowThreads();
31669 (arg1)->Move((wxPoint const &)*arg2,arg3);
31670 wxPyEndAllowThreads(__tstate);
31671 if (PyErr_Occurred()) SWIG_fail;
31672 }
31673 resultobj = SWIG_Py_Void();
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31681 PyObject *resultobj = 0;
31682 wxWindow *arg1 = (wxWindow *) 0 ;
31683 int arg2 ;
31684 int arg3 ;
31685 int arg4 = (int) wxSIZE_USE_EXISTING ;
31686 void *argp1 = 0 ;
31687 int res1 = 0 ;
31688 int val2 ;
31689 int ecode2 = 0 ;
31690 int val3 ;
31691 int ecode3 = 0 ;
31692 int val4 ;
31693 int ecode4 = 0 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 PyObject * obj2 = 0 ;
31697 PyObject * obj3 = 0 ;
31698 char * kwnames[] = {
31699 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31700 };
31701
31702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31704 if (!SWIG_IsOK(res1)) {
31705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31706 }
31707 arg1 = reinterpret_cast< wxWindow * >(argp1);
31708 ecode2 = SWIG_AsVal_int(obj1, &val2);
31709 if (!SWIG_IsOK(ecode2)) {
31710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31711 }
31712 arg2 = static_cast< int >(val2);
31713 ecode3 = SWIG_AsVal_int(obj2, &val3);
31714 if (!SWIG_IsOK(ecode3)) {
31715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31716 }
31717 arg3 = static_cast< int >(val3);
31718 if (obj3) {
31719 ecode4 = SWIG_AsVal_int(obj3, &val4);
31720 if (!SWIG_IsOK(ecode4)) {
31721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31722 }
31723 arg4 = static_cast< int >(val4);
31724 }
31725 {
31726 PyThreadState* __tstate = wxPyBeginAllowThreads();
31727 (arg1)->Move(arg2,arg3,arg4);
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 resultobj = SWIG_Py_Void();
31732 return resultobj;
31733 fail:
31734 return NULL;
31735 }
31736
31737
31738 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31739 PyObject *resultobj = 0;
31740 wxWindow *arg1 = (wxWindow *) 0 ;
31741 wxSize const &arg2_defvalue = wxDefaultSize ;
31742 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31743 void *argp1 = 0 ;
31744 int res1 = 0 ;
31745 wxSize temp2 ;
31746 PyObject * obj0 = 0 ;
31747 PyObject * obj1 = 0 ;
31748 char * kwnames[] = {
31749 (char *) "self",(char *) "size", NULL
31750 };
31751
31752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31754 if (!SWIG_IsOK(res1)) {
31755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31756 }
31757 arg1 = reinterpret_cast< wxWindow * >(argp1);
31758 if (obj1) {
31759 {
31760 arg2 = &temp2;
31761 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31762 }
31763 }
31764 {
31765 PyThreadState* __tstate = wxPyBeginAllowThreads();
31766 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 resultobj = SWIG_Py_Void();
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31778 PyObject *resultobj = 0;
31779 wxWindow *arg1 = (wxWindow *) 0 ;
31780 void *argp1 = 0 ;
31781 int res1 = 0 ;
31782 PyObject *swig_obj[1] ;
31783
31784 if (!args) SWIG_fail;
31785 swig_obj[0] = args;
31786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31787 if (!SWIG_IsOK(res1)) {
31788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31789 }
31790 arg1 = reinterpret_cast< wxWindow * >(argp1);
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 (arg1)->Raise();
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 resultobj = SWIG_Py_Void();
31798 return resultobj;
31799 fail:
31800 return NULL;
31801 }
31802
31803
31804 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31805 PyObject *resultobj = 0;
31806 wxWindow *arg1 = (wxWindow *) 0 ;
31807 void *argp1 = 0 ;
31808 int res1 = 0 ;
31809 PyObject *swig_obj[1] ;
31810
31811 if (!args) SWIG_fail;
31812 swig_obj[0] = args;
31813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31814 if (!SWIG_IsOK(res1)) {
31815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31816 }
31817 arg1 = reinterpret_cast< wxWindow * >(argp1);
31818 {
31819 PyThreadState* __tstate = wxPyBeginAllowThreads();
31820 (arg1)->Lower();
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 resultobj = SWIG_Py_Void();
31825 return resultobj;
31826 fail:
31827 return NULL;
31828 }
31829
31830
31831 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31832 PyObject *resultobj = 0;
31833 wxWindow *arg1 = (wxWindow *) 0 ;
31834 wxSize *arg2 = 0 ;
31835 void *argp1 = 0 ;
31836 int res1 = 0 ;
31837 wxSize temp2 ;
31838 PyObject * obj0 = 0 ;
31839 PyObject * obj1 = 0 ;
31840 char * kwnames[] = {
31841 (char *) "self",(char *) "size", NULL
31842 };
31843
31844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31846 if (!SWIG_IsOK(res1)) {
31847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31848 }
31849 arg1 = reinterpret_cast< wxWindow * >(argp1);
31850 {
31851 arg2 = &temp2;
31852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31853 }
31854 {
31855 PyThreadState* __tstate = wxPyBeginAllowThreads();
31856 (arg1)->SetClientSize((wxSize const &)*arg2);
31857 wxPyEndAllowThreads(__tstate);
31858 if (PyErr_Occurred()) SWIG_fail;
31859 }
31860 resultobj = SWIG_Py_Void();
31861 return resultobj;
31862 fail:
31863 return NULL;
31864 }
31865
31866
31867 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31868 PyObject *resultobj = 0;
31869 wxWindow *arg1 = (wxWindow *) 0 ;
31870 int arg2 ;
31871 int arg3 ;
31872 void *argp1 = 0 ;
31873 int res1 = 0 ;
31874 int val2 ;
31875 int ecode2 = 0 ;
31876 int val3 ;
31877 int ecode3 = 0 ;
31878 PyObject * obj0 = 0 ;
31879 PyObject * obj1 = 0 ;
31880 PyObject * obj2 = 0 ;
31881 char * kwnames[] = {
31882 (char *) "self",(char *) "width",(char *) "height", NULL
31883 };
31884
31885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31887 if (!SWIG_IsOK(res1)) {
31888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31889 }
31890 arg1 = reinterpret_cast< wxWindow * >(argp1);
31891 ecode2 = SWIG_AsVal_int(obj1, &val2);
31892 if (!SWIG_IsOK(ecode2)) {
31893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31894 }
31895 arg2 = static_cast< int >(val2);
31896 ecode3 = SWIG_AsVal_int(obj2, &val3);
31897 if (!SWIG_IsOK(ecode3)) {
31898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31899 }
31900 arg3 = static_cast< int >(val3);
31901 {
31902 PyThreadState* __tstate = wxPyBeginAllowThreads();
31903 (arg1)->SetClientSize(arg2,arg3);
31904 wxPyEndAllowThreads(__tstate);
31905 if (PyErr_Occurred()) SWIG_fail;
31906 }
31907 resultobj = SWIG_Py_Void();
31908 return resultobj;
31909 fail:
31910 return NULL;
31911 }
31912
31913
31914 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31915 PyObject *resultobj = 0;
31916 wxWindow *arg1 = (wxWindow *) 0 ;
31917 wxRect *arg2 = 0 ;
31918 void *argp1 = 0 ;
31919 int res1 = 0 ;
31920 wxRect temp2 ;
31921 PyObject * obj0 = 0 ;
31922 PyObject * obj1 = 0 ;
31923 char * kwnames[] = {
31924 (char *) "self",(char *) "rect", NULL
31925 };
31926
31927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31931 }
31932 arg1 = reinterpret_cast< wxWindow * >(argp1);
31933 {
31934 arg2 = &temp2;
31935 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31936 }
31937 {
31938 PyThreadState* __tstate = wxPyBeginAllowThreads();
31939 (arg1)->SetClientSize((wxRect const &)*arg2);
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 resultobj = SWIG_Py_Void();
31944 return resultobj;
31945 fail:
31946 return NULL;
31947 }
31948
31949
31950 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31951 PyObject *resultobj = 0;
31952 wxWindow *arg1 = (wxWindow *) 0 ;
31953 wxPoint result;
31954 void *argp1 = 0 ;
31955 int res1 = 0 ;
31956 PyObject *swig_obj[1] ;
31957
31958 if (!args) SWIG_fail;
31959 swig_obj[0] = args;
31960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31961 if (!SWIG_IsOK(res1)) {
31962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31963 }
31964 arg1 = reinterpret_cast< wxWindow * >(argp1);
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 result = ((wxWindow const *)arg1)->GetPosition();
31968 wxPyEndAllowThreads(__tstate);
31969 if (PyErr_Occurred()) SWIG_fail;
31970 }
31971 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31979 PyObject *resultobj = 0;
31980 wxWindow *arg1 = (wxWindow *) 0 ;
31981 int *arg2 = (int *) 0 ;
31982 int *arg3 = (int *) 0 ;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 int temp2 ;
31986 int res2 = SWIG_TMPOBJ ;
31987 int temp3 ;
31988 int res3 = SWIG_TMPOBJ ;
31989 PyObject *swig_obj[1] ;
31990
31991 arg2 = &temp2;
31992 arg3 = &temp3;
31993 if (!args) SWIG_fail;
31994 swig_obj[0] = args;
31995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31996 if (!SWIG_IsOK(res1)) {
31997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31998 }
31999 arg1 = reinterpret_cast< wxWindow * >(argp1);
32000 {
32001 PyThreadState* __tstate = wxPyBeginAllowThreads();
32002 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 resultobj = SWIG_Py_Void();
32007 if (SWIG_IsTmpObj(res2)) {
32008 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32009 } else {
32010 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32012 }
32013 if (SWIG_IsTmpObj(res3)) {
32014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32015 } else {
32016 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32018 }
32019 return resultobj;
32020 fail:
32021 return NULL;
32022 }
32023
32024
32025 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32026 PyObject *resultobj = 0;
32027 wxWindow *arg1 = (wxWindow *) 0 ;
32028 wxPoint result;
32029 void *argp1 = 0 ;
32030 int res1 = 0 ;
32031 PyObject *swig_obj[1] ;
32032
32033 if (!args) SWIG_fail;
32034 swig_obj[0] = args;
32035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32036 if (!SWIG_IsOK(res1)) {
32037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32038 }
32039 arg1 = reinterpret_cast< wxWindow * >(argp1);
32040 {
32041 PyThreadState* __tstate = wxPyBeginAllowThreads();
32042 result = ((wxWindow const *)arg1)->GetScreenPosition();
32043 wxPyEndAllowThreads(__tstate);
32044 if (PyErr_Occurred()) SWIG_fail;
32045 }
32046 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32047 return resultobj;
32048 fail:
32049 return NULL;
32050 }
32051
32052
32053 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32054 PyObject *resultobj = 0;
32055 wxWindow *arg1 = (wxWindow *) 0 ;
32056 int *arg2 = (int *) 0 ;
32057 int *arg3 = (int *) 0 ;
32058 void *argp1 = 0 ;
32059 int res1 = 0 ;
32060 int temp2 ;
32061 int res2 = SWIG_TMPOBJ ;
32062 int temp3 ;
32063 int res3 = SWIG_TMPOBJ ;
32064 PyObject *swig_obj[1] ;
32065
32066 arg2 = &temp2;
32067 arg3 = &temp3;
32068 if (!args) SWIG_fail;
32069 swig_obj[0] = args;
32070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32071 if (!SWIG_IsOK(res1)) {
32072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32073 }
32074 arg1 = reinterpret_cast< wxWindow * >(argp1);
32075 {
32076 PyThreadState* __tstate = wxPyBeginAllowThreads();
32077 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_Py_Void();
32082 if (SWIG_IsTmpObj(res2)) {
32083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32084 } else {
32085 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32087 }
32088 if (SWIG_IsTmpObj(res3)) {
32089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32090 } else {
32091 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32101 PyObject *resultobj = 0;
32102 wxWindow *arg1 = (wxWindow *) 0 ;
32103 wxRect result;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 PyObject *swig_obj[1] ;
32107
32108 if (!args) SWIG_fail;
32109 swig_obj[0] = args;
32110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32113 }
32114 arg1 = reinterpret_cast< wxWindow * >(argp1);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = ((wxWindow const *)arg1)->GetScreenRect();
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32129 PyObject *resultobj = 0;
32130 wxWindow *arg1 = (wxWindow *) 0 ;
32131 wxSize result;
32132 void *argp1 = 0 ;
32133 int res1 = 0 ;
32134 PyObject *swig_obj[1] ;
32135
32136 if (!args) SWIG_fail;
32137 swig_obj[0] = args;
32138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32139 if (!SWIG_IsOK(res1)) {
32140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32141 }
32142 arg1 = reinterpret_cast< wxWindow * >(argp1);
32143 {
32144 PyThreadState* __tstate = wxPyBeginAllowThreads();
32145 result = ((wxWindow const *)arg1)->GetSize();
32146 wxPyEndAllowThreads(__tstate);
32147 if (PyErr_Occurred()) SWIG_fail;
32148 }
32149 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32150 return resultobj;
32151 fail:
32152 return NULL;
32153 }
32154
32155
32156 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32157 PyObject *resultobj = 0;
32158 wxWindow *arg1 = (wxWindow *) 0 ;
32159 int *arg2 = (int *) 0 ;
32160 int *arg3 = (int *) 0 ;
32161 void *argp1 = 0 ;
32162 int res1 = 0 ;
32163 int temp2 ;
32164 int res2 = SWIG_TMPOBJ ;
32165 int temp3 ;
32166 int res3 = SWIG_TMPOBJ ;
32167 PyObject *swig_obj[1] ;
32168
32169 arg2 = &temp2;
32170 arg3 = &temp3;
32171 if (!args) SWIG_fail;
32172 swig_obj[0] = args;
32173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32174 if (!SWIG_IsOK(res1)) {
32175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32176 }
32177 arg1 = reinterpret_cast< wxWindow * >(argp1);
32178 {
32179 PyThreadState* __tstate = wxPyBeginAllowThreads();
32180 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 resultobj = SWIG_Py_Void();
32185 if (SWIG_IsTmpObj(res2)) {
32186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32187 } else {
32188 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32190 }
32191 if (SWIG_IsTmpObj(res3)) {
32192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32193 } else {
32194 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32196 }
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32204 PyObject *resultobj = 0;
32205 wxWindow *arg1 = (wxWindow *) 0 ;
32206 wxRect result;
32207 void *argp1 = 0 ;
32208 int res1 = 0 ;
32209 PyObject *swig_obj[1] ;
32210
32211 if (!args) SWIG_fail;
32212 swig_obj[0] = args;
32213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32216 }
32217 arg1 = reinterpret_cast< wxWindow * >(argp1);
32218 {
32219 PyThreadState* __tstate = wxPyBeginAllowThreads();
32220 result = ((wxWindow const *)arg1)->GetRect();
32221 wxPyEndAllowThreads(__tstate);
32222 if (PyErr_Occurred()) SWIG_fail;
32223 }
32224 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32232 PyObject *resultobj = 0;
32233 wxWindow *arg1 = (wxWindow *) 0 ;
32234 wxSize result;
32235 void *argp1 = 0 ;
32236 int res1 = 0 ;
32237 PyObject *swig_obj[1] ;
32238
32239 if (!args) SWIG_fail;
32240 swig_obj[0] = args;
32241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32244 }
32245 arg1 = reinterpret_cast< wxWindow * >(argp1);
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = ((wxWindow const *)arg1)->GetClientSize();
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32253 return resultobj;
32254 fail:
32255 return NULL;
32256 }
32257
32258
32259 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32260 PyObject *resultobj = 0;
32261 wxWindow *arg1 = (wxWindow *) 0 ;
32262 int *arg2 = (int *) 0 ;
32263 int *arg3 = (int *) 0 ;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 int temp2 ;
32267 int res2 = SWIG_TMPOBJ ;
32268 int temp3 ;
32269 int res3 = SWIG_TMPOBJ ;
32270 PyObject *swig_obj[1] ;
32271
32272 arg2 = &temp2;
32273 arg3 = &temp3;
32274 if (!args) SWIG_fail;
32275 swig_obj[0] = args;
32276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32279 }
32280 arg1 = reinterpret_cast< wxWindow * >(argp1);
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32284 wxPyEndAllowThreads(__tstate);
32285 if (PyErr_Occurred()) SWIG_fail;
32286 }
32287 resultobj = SWIG_Py_Void();
32288 if (SWIG_IsTmpObj(res2)) {
32289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32290 } else {
32291 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32293 }
32294 if (SWIG_IsTmpObj(res3)) {
32295 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32296 } else {
32297 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32298 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32299 }
32300 return resultobj;
32301 fail:
32302 return NULL;
32303 }
32304
32305
32306 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32307 PyObject *resultobj = 0;
32308 wxWindow *arg1 = (wxWindow *) 0 ;
32309 wxPoint result;
32310 void *argp1 = 0 ;
32311 int res1 = 0 ;
32312 PyObject *swig_obj[1] ;
32313
32314 if (!args) SWIG_fail;
32315 swig_obj[0] = args;
32316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32317 if (!SWIG_IsOK(res1)) {
32318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32319 }
32320 arg1 = reinterpret_cast< wxWindow * >(argp1);
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32328 return resultobj;
32329 fail:
32330 return NULL;
32331 }
32332
32333
32334 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32335 PyObject *resultobj = 0;
32336 wxWindow *arg1 = (wxWindow *) 0 ;
32337 wxRect result;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 PyObject *swig_obj[1] ;
32341
32342 if (!args) SWIG_fail;
32343 swig_obj[0] = args;
32344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32345 if (!SWIG_IsOK(res1)) {
32346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32347 }
32348 arg1 = reinterpret_cast< wxWindow * >(argp1);
32349 {
32350 PyThreadState* __tstate = wxPyBeginAllowThreads();
32351 result = ((wxWindow const *)arg1)->GetClientRect();
32352 wxPyEndAllowThreads(__tstate);
32353 if (PyErr_Occurred()) SWIG_fail;
32354 }
32355 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32356 return resultobj;
32357 fail:
32358 return NULL;
32359 }
32360
32361
32362 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32363 PyObject *resultobj = 0;
32364 wxWindow *arg1 = (wxWindow *) 0 ;
32365 wxSize result;
32366 void *argp1 = 0 ;
32367 int res1 = 0 ;
32368 PyObject *swig_obj[1] ;
32369
32370 if (!args) SWIG_fail;
32371 swig_obj[0] = args;
32372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32373 if (!SWIG_IsOK(res1)) {
32374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32375 }
32376 arg1 = reinterpret_cast< wxWindow * >(argp1);
32377 {
32378 PyThreadState* __tstate = wxPyBeginAllowThreads();
32379 result = ((wxWindow const *)arg1)->GetBestSize();
32380 wxPyEndAllowThreads(__tstate);
32381 if (PyErr_Occurred()) SWIG_fail;
32382 }
32383 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32384 return resultobj;
32385 fail:
32386 return NULL;
32387 }
32388
32389
32390 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32391 PyObject *resultobj = 0;
32392 wxWindow *arg1 = (wxWindow *) 0 ;
32393 int *arg2 = (int *) 0 ;
32394 int *arg3 = (int *) 0 ;
32395 void *argp1 = 0 ;
32396 int res1 = 0 ;
32397 int temp2 ;
32398 int res2 = SWIG_TMPOBJ ;
32399 int temp3 ;
32400 int res3 = SWIG_TMPOBJ ;
32401 PyObject *swig_obj[1] ;
32402
32403 arg2 = &temp2;
32404 arg3 = &temp3;
32405 if (!args) SWIG_fail;
32406 swig_obj[0] = args;
32407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32408 if (!SWIG_IsOK(res1)) {
32409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32410 }
32411 arg1 = reinterpret_cast< wxWindow * >(argp1);
32412 {
32413 PyThreadState* __tstate = wxPyBeginAllowThreads();
32414 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32415 wxPyEndAllowThreads(__tstate);
32416 if (PyErr_Occurred()) SWIG_fail;
32417 }
32418 resultobj = SWIG_Py_Void();
32419 if (SWIG_IsTmpObj(res2)) {
32420 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32421 } else {
32422 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32424 }
32425 if (SWIG_IsTmpObj(res3)) {
32426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32427 } else {
32428 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32430 }
32431 return resultobj;
32432 fail:
32433 return NULL;
32434 }
32435
32436
32437 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32438 PyObject *resultobj = 0;
32439 wxWindow *arg1 = (wxWindow *) 0 ;
32440 void *argp1 = 0 ;
32441 int res1 = 0 ;
32442 PyObject *swig_obj[1] ;
32443
32444 if (!args) SWIG_fail;
32445 swig_obj[0] = args;
32446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32447 if (!SWIG_IsOK(res1)) {
32448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32449 }
32450 arg1 = reinterpret_cast< wxWindow * >(argp1);
32451 {
32452 PyThreadState* __tstate = wxPyBeginAllowThreads();
32453 (arg1)->InvalidateBestSize();
32454 wxPyEndAllowThreads(__tstate);
32455 if (PyErr_Occurred()) SWIG_fail;
32456 }
32457 resultobj = SWIG_Py_Void();
32458 return resultobj;
32459 fail:
32460 return NULL;
32461 }
32462
32463
32464 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32465 PyObject *resultobj = 0;
32466 wxWindow *arg1 = (wxWindow *) 0 ;
32467 wxSize *arg2 = 0 ;
32468 void *argp1 = 0 ;
32469 int res1 = 0 ;
32470 wxSize temp2 ;
32471 PyObject * obj0 = 0 ;
32472 PyObject * obj1 = 0 ;
32473 char * kwnames[] = {
32474 (char *) "self",(char *) "size", NULL
32475 };
32476
32477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32479 if (!SWIG_IsOK(res1)) {
32480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32481 }
32482 arg1 = reinterpret_cast< wxWindow * >(argp1);
32483 {
32484 arg2 = &temp2;
32485 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32486 }
32487 {
32488 PyThreadState* __tstate = wxPyBeginAllowThreads();
32489 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 resultobj = SWIG_Py_Void();
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 wxSize result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32522 return resultobj;
32523 fail:
32524 return NULL;
32525 }
32526
32527
32528 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32529 PyObject *resultobj = 0;
32530 wxWindow *arg1 = (wxWindow *) 0 ;
32531 wxSize result;
32532 void *argp1 = 0 ;
32533 int res1 = 0 ;
32534 PyObject *swig_obj[1] ;
32535
32536 if (!args) SWIG_fail;
32537 swig_obj[0] = args;
32538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32539 if (!SWIG_IsOK(res1)) {
32540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32541 }
32542 arg1 = reinterpret_cast< wxWindow * >(argp1);
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32546 wxPyEndAllowThreads(__tstate);
32547 if (PyErr_Occurred()) SWIG_fail;
32548 }
32549 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32557 PyObject *resultobj = 0;
32558 wxWindow *arg1 = (wxWindow *) 0 ;
32559 int arg2 = (int) wxBOTH ;
32560 void *argp1 = 0 ;
32561 int res1 = 0 ;
32562 int val2 ;
32563 int ecode2 = 0 ;
32564 PyObject * obj0 = 0 ;
32565 PyObject * obj1 = 0 ;
32566 char * kwnames[] = {
32567 (char *) "self",(char *) "direction", NULL
32568 };
32569
32570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32572 if (!SWIG_IsOK(res1)) {
32573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32574 }
32575 arg1 = reinterpret_cast< wxWindow * >(argp1);
32576 if (obj1) {
32577 ecode2 = SWIG_AsVal_int(obj1, &val2);
32578 if (!SWIG_IsOK(ecode2)) {
32579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32580 }
32581 arg2 = static_cast< int >(val2);
32582 }
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 (arg1)->Center(arg2);
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 resultobj = SWIG_Py_Void();
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32597 PyObject *resultobj = 0;
32598 wxWindow *arg1 = (wxWindow *) 0 ;
32599 int arg2 = (int) wxBOTH ;
32600 void *argp1 = 0 ;
32601 int res1 = 0 ;
32602 int val2 ;
32603 int ecode2 = 0 ;
32604 PyObject * obj0 = 0 ;
32605 PyObject * obj1 = 0 ;
32606 char * kwnames[] = {
32607 (char *) "self",(char *) "dir", NULL
32608 };
32609
32610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32612 if (!SWIG_IsOK(res1)) {
32613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32614 }
32615 arg1 = reinterpret_cast< wxWindow * >(argp1);
32616 if (obj1) {
32617 ecode2 = SWIG_AsVal_int(obj1, &val2);
32618 if (!SWIG_IsOK(ecode2)) {
32619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32620 }
32621 arg2 = static_cast< int >(val2);
32622 }
32623 {
32624 PyThreadState* __tstate = wxPyBeginAllowThreads();
32625 (arg1)->CenterOnParent(arg2);
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 PyObject *resultobj = 0;
32638 wxWindow *arg1 = (wxWindow *) 0 ;
32639 void *argp1 = 0 ;
32640 int res1 = 0 ;
32641 PyObject *swig_obj[1] ;
32642
32643 if (!args) SWIG_fail;
32644 swig_obj[0] = args;
32645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32646 if (!SWIG_IsOK(res1)) {
32647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32648 }
32649 arg1 = reinterpret_cast< wxWindow * >(argp1);
32650 {
32651 PyThreadState* __tstate = wxPyBeginAllowThreads();
32652 (arg1)->Fit();
32653 wxPyEndAllowThreads(__tstate);
32654 if (PyErr_Occurred()) SWIG_fail;
32655 }
32656 resultobj = SWIG_Py_Void();
32657 return resultobj;
32658 fail:
32659 return NULL;
32660 }
32661
32662
32663 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32664 PyObject *resultobj = 0;
32665 wxWindow *arg1 = (wxWindow *) 0 ;
32666 void *argp1 = 0 ;
32667 int res1 = 0 ;
32668 PyObject *swig_obj[1] ;
32669
32670 if (!args) SWIG_fail;
32671 swig_obj[0] = args;
32672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32673 if (!SWIG_IsOK(res1)) {
32674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32675 }
32676 arg1 = reinterpret_cast< wxWindow * >(argp1);
32677 {
32678 PyThreadState* __tstate = wxPyBeginAllowThreads();
32679 (arg1)->FitInside();
32680 wxPyEndAllowThreads(__tstate);
32681 if (PyErr_Occurred()) SWIG_fail;
32682 }
32683 resultobj = SWIG_Py_Void();
32684 return resultobj;
32685 fail:
32686 return NULL;
32687 }
32688
32689
32690 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32691 PyObject *resultobj = 0;
32692 wxWindow *arg1 = (wxWindow *) 0 ;
32693 int arg2 ;
32694 int arg3 ;
32695 int arg4 = (int) -1 ;
32696 int arg5 = (int) -1 ;
32697 int arg6 = (int) -1 ;
32698 int arg7 = (int) -1 ;
32699 void *argp1 = 0 ;
32700 int res1 = 0 ;
32701 int val2 ;
32702 int ecode2 = 0 ;
32703 int val3 ;
32704 int ecode3 = 0 ;
32705 int val4 ;
32706 int ecode4 = 0 ;
32707 int val5 ;
32708 int ecode5 = 0 ;
32709 int val6 ;
32710 int ecode6 = 0 ;
32711 int val7 ;
32712 int ecode7 = 0 ;
32713 PyObject * obj0 = 0 ;
32714 PyObject * obj1 = 0 ;
32715 PyObject * obj2 = 0 ;
32716 PyObject * obj3 = 0 ;
32717 PyObject * obj4 = 0 ;
32718 PyObject * obj5 = 0 ;
32719 PyObject * obj6 = 0 ;
32720 char * kwnames[] = {
32721 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32722 };
32723
32724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32726 if (!SWIG_IsOK(res1)) {
32727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32728 }
32729 arg1 = reinterpret_cast< wxWindow * >(argp1);
32730 ecode2 = SWIG_AsVal_int(obj1, &val2);
32731 if (!SWIG_IsOK(ecode2)) {
32732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32733 }
32734 arg2 = static_cast< int >(val2);
32735 ecode3 = SWIG_AsVal_int(obj2, &val3);
32736 if (!SWIG_IsOK(ecode3)) {
32737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32738 }
32739 arg3 = static_cast< int >(val3);
32740 if (obj3) {
32741 ecode4 = SWIG_AsVal_int(obj3, &val4);
32742 if (!SWIG_IsOK(ecode4)) {
32743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32744 }
32745 arg4 = static_cast< int >(val4);
32746 }
32747 if (obj4) {
32748 ecode5 = SWIG_AsVal_int(obj4, &val5);
32749 if (!SWIG_IsOK(ecode5)) {
32750 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32751 }
32752 arg5 = static_cast< int >(val5);
32753 }
32754 if (obj5) {
32755 ecode6 = SWIG_AsVal_int(obj5, &val6);
32756 if (!SWIG_IsOK(ecode6)) {
32757 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32758 }
32759 arg6 = static_cast< int >(val6);
32760 }
32761 if (obj6) {
32762 ecode7 = SWIG_AsVal_int(obj6, &val7);
32763 if (!SWIG_IsOK(ecode7)) {
32764 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32765 }
32766 arg7 = static_cast< int >(val7);
32767 }
32768 {
32769 PyThreadState* __tstate = wxPyBeginAllowThreads();
32770 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32771 wxPyEndAllowThreads(__tstate);
32772 if (PyErr_Occurred()) SWIG_fail;
32773 }
32774 resultobj = SWIG_Py_Void();
32775 return resultobj;
32776 fail:
32777 return NULL;
32778 }
32779
32780
32781 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32782 PyObject *resultobj = 0;
32783 wxWindow *arg1 = (wxWindow *) 0 ;
32784 wxSize *arg2 = 0 ;
32785 wxSize const &arg3_defvalue = wxDefaultSize ;
32786 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32787 wxSize const &arg4_defvalue = wxDefaultSize ;
32788 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32789 void *argp1 = 0 ;
32790 int res1 = 0 ;
32791 wxSize temp2 ;
32792 wxSize temp3 ;
32793 wxSize temp4 ;
32794 PyObject * obj0 = 0 ;
32795 PyObject * obj1 = 0 ;
32796 PyObject * obj2 = 0 ;
32797 PyObject * obj3 = 0 ;
32798 char * kwnames[] = {
32799 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32800 };
32801
32802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32804 if (!SWIG_IsOK(res1)) {
32805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32806 }
32807 arg1 = reinterpret_cast< wxWindow * >(argp1);
32808 {
32809 arg2 = &temp2;
32810 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32811 }
32812 if (obj2) {
32813 {
32814 arg3 = &temp3;
32815 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32816 }
32817 }
32818 if (obj3) {
32819 {
32820 arg4 = &temp4;
32821 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32822 }
32823 }
32824 {
32825 PyThreadState* __tstate = wxPyBeginAllowThreads();
32826 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32827 wxPyEndAllowThreads(__tstate);
32828 if (PyErr_Occurred()) SWIG_fail;
32829 }
32830 resultobj = SWIG_Py_Void();
32831 return resultobj;
32832 fail:
32833 return NULL;
32834 }
32835
32836
32837 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32838 PyObject *resultobj = 0;
32839 wxWindow *arg1 = (wxWindow *) 0 ;
32840 int arg2 ;
32841 int arg3 ;
32842 int arg4 = (int) -1 ;
32843 int arg5 = (int) -1 ;
32844 void *argp1 = 0 ;
32845 int res1 = 0 ;
32846 int val2 ;
32847 int ecode2 = 0 ;
32848 int val3 ;
32849 int ecode3 = 0 ;
32850 int val4 ;
32851 int ecode4 = 0 ;
32852 int val5 ;
32853 int ecode5 = 0 ;
32854 PyObject * obj0 = 0 ;
32855 PyObject * obj1 = 0 ;
32856 PyObject * obj2 = 0 ;
32857 PyObject * obj3 = 0 ;
32858 PyObject * obj4 = 0 ;
32859 char * kwnames[] = {
32860 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32861 };
32862
32863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32865 if (!SWIG_IsOK(res1)) {
32866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32867 }
32868 arg1 = reinterpret_cast< wxWindow * >(argp1);
32869 ecode2 = SWIG_AsVal_int(obj1, &val2);
32870 if (!SWIG_IsOK(ecode2)) {
32871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32872 }
32873 arg2 = static_cast< int >(val2);
32874 ecode3 = SWIG_AsVal_int(obj2, &val3);
32875 if (!SWIG_IsOK(ecode3)) {
32876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32877 }
32878 arg3 = static_cast< int >(val3);
32879 if (obj3) {
32880 ecode4 = SWIG_AsVal_int(obj3, &val4);
32881 if (!SWIG_IsOK(ecode4)) {
32882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32883 }
32884 arg4 = static_cast< int >(val4);
32885 }
32886 if (obj4) {
32887 ecode5 = SWIG_AsVal_int(obj4, &val5);
32888 if (!SWIG_IsOK(ecode5)) {
32889 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32890 }
32891 arg5 = static_cast< int >(val5);
32892 }
32893 {
32894 PyThreadState* __tstate = wxPyBeginAllowThreads();
32895 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32896 wxPyEndAllowThreads(__tstate);
32897 if (PyErr_Occurred()) SWIG_fail;
32898 }
32899 resultobj = SWIG_Py_Void();
32900 return resultobj;
32901 fail:
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32907 PyObject *resultobj = 0;
32908 wxWindow *arg1 = (wxWindow *) 0 ;
32909 wxSize *arg2 = 0 ;
32910 wxSize const &arg3_defvalue = wxDefaultSize ;
32911 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32912 void *argp1 = 0 ;
32913 int res1 = 0 ;
32914 wxSize temp2 ;
32915 wxSize temp3 ;
32916 PyObject * obj0 = 0 ;
32917 PyObject * obj1 = 0 ;
32918 PyObject * obj2 = 0 ;
32919 char * kwnames[] = {
32920 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32921 };
32922
32923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32925 if (!SWIG_IsOK(res1)) {
32926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32927 }
32928 arg1 = reinterpret_cast< wxWindow * >(argp1);
32929 {
32930 arg2 = &temp2;
32931 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32932 }
32933 if (obj2) {
32934 {
32935 arg3 = &temp3;
32936 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32937 }
32938 }
32939 {
32940 PyThreadState* __tstate = wxPyBeginAllowThreads();
32941 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32942 wxPyEndAllowThreads(__tstate);
32943 if (PyErr_Occurred()) SWIG_fail;
32944 }
32945 resultobj = SWIG_Py_Void();
32946 return resultobj;
32947 fail:
32948 return NULL;
32949 }
32950
32951
32952 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32953 PyObject *resultobj = 0;
32954 wxWindow *arg1 = (wxWindow *) 0 ;
32955 wxSize result;
32956 void *argp1 = 0 ;
32957 int res1 = 0 ;
32958 PyObject *swig_obj[1] ;
32959
32960 if (!args) SWIG_fail;
32961 swig_obj[0] = args;
32962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32963 if (!SWIG_IsOK(res1)) {
32964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32965 }
32966 arg1 = reinterpret_cast< wxWindow * >(argp1);
32967 {
32968 PyThreadState* __tstate = wxPyBeginAllowThreads();
32969 result = ((wxWindow const *)arg1)->GetMaxSize();
32970 wxPyEndAllowThreads(__tstate);
32971 if (PyErr_Occurred()) SWIG_fail;
32972 }
32973 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32974 return resultobj;
32975 fail:
32976 return NULL;
32977 }
32978
32979
32980 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32981 PyObject *resultobj = 0;
32982 wxWindow *arg1 = (wxWindow *) 0 ;
32983 wxSize result;
32984 void *argp1 = 0 ;
32985 int res1 = 0 ;
32986 PyObject *swig_obj[1] ;
32987
32988 if (!args) SWIG_fail;
32989 swig_obj[0] = args;
32990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32991 if (!SWIG_IsOK(res1)) {
32992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32993 }
32994 arg1 = reinterpret_cast< wxWindow * >(argp1);
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = ((wxWindow const *)arg1)->GetMinSize();
32998 wxPyEndAllowThreads(__tstate);
32999 if (PyErr_Occurred()) SWIG_fail;
33000 }
33001 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33002 return resultobj;
33003 fail:
33004 return NULL;
33005 }
33006
33007
33008 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33009 PyObject *resultobj = 0;
33010 wxWindow *arg1 = (wxWindow *) 0 ;
33011 wxSize *arg2 = 0 ;
33012 void *argp1 = 0 ;
33013 int res1 = 0 ;
33014 wxSize temp2 ;
33015 PyObject * obj0 = 0 ;
33016 PyObject * obj1 = 0 ;
33017 char * kwnames[] = {
33018 (char *) "self",(char *) "minSize", NULL
33019 };
33020
33021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33023 if (!SWIG_IsOK(res1)) {
33024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33025 }
33026 arg1 = reinterpret_cast< wxWindow * >(argp1);
33027 {
33028 arg2 = &temp2;
33029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33030 }
33031 {
33032 PyThreadState* __tstate = wxPyBeginAllowThreads();
33033 (arg1)->SetMinSize((wxSize const &)*arg2);
33034 wxPyEndAllowThreads(__tstate);
33035 if (PyErr_Occurred()) SWIG_fail;
33036 }
33037 resultobj = SWIG_Py_Void();
33038 return resultobj;
33039 fail:
33040 return NULL;
33041 }
33042
33043
33044 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33045 PyObject *resultobj = 0;
33046 wxWindow *arg1 = (wxWindow *) 0 ;
33047 wxSize *arg2 = 0 ;
33048 void *argp1 = 0 ;
33049 int res1 = 0 ;
33050 wxSize temp2 ;
33051 PyObject * obj0 = 0 ;
33052 PyObject * obj1 = 0 ;
33053 char * kwnames[] = {
33054 (char *) "self",(char *) "maxSize", NULL
33055 };
33056
33057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33059 if (!SWIG_IsOK(res1)) {
33060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33061 }
33062 arg1 = reinterpret_cast< wxWindow * >(argp1);
33063 {
33064 arg2 = &temp2;
33065 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33066 }
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 (arg1)->SetMaxSize((wxSize const &)*arg2);
33070 wxPyEndAllowThreads(__tstate);
33071 if (PyErr_Occurred()) SWIG_fail;
33072 }
33073 resultobj = SWIG_Py_Void();
33074 return resultobj;
33075 fail:
33076 return NULL;
33077 }
33078
33079
33080 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33081 PyObject *resultobj = 0;
33082 wxWindow *arg1 = (wxWindow *) 0 ;
33083 int result;
33084 void *argp1 = 0 ;
33085 int res1 = 0 ;
33086 PyObject *swig_obj[1] ;
33087
33088 if (!args) SWIG_fail;
33089 swig_obj[0] = args;
33090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33091 if (!SWIG_IsOK(res1)) {
33092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33093 }
33094 arg1 = reinterpret_cast< wxWindow * >(argp1);
33095 {
33096 PyThreadState* __tstate = wxPyBeginAllowThreads();
33097 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33098 wxPyEndAllowThreads(__tstate);
33099 if (PyErr_Occurred()) SWIG_fail;
33100 }
33101 resultobj = SWIG_From_int(static_cast< int >(result));
33102 return resultobj;
33103 fail:
33104 return NULL;
33105 }
33106
33107
33108 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33109 PyObject *resultobj = 0;
33110 wxWindow *arg1 = (wxWindow *) 0 ;
33111 int result;
33112 void *argp1 = 0 ;
33113 int res1 = 0 ;
33114 PyObject *swig_obj[1] ;
33115
33116 if (!args) SWIG_fail;
33117 swig_obj[0] = args;
33118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33119 if (!SWIG_IsOK(res1)) {
33120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33121 }
33122 arg1 = reinterpret_cast< wxWindow * >(argp1);
33123 {
33124 PyThreadState* __tstate = wxPyBeginAllowThreads();
33125 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33126 wxPyEndAllowThreads(__tstate);
33127 if (PyErr_Occurred()) SWIG_fail;
33128 }
33129 resultobj = SWIG_From_int(static_cast< int >(result));
33130 return resultobj;
33131 fail:
33132 return NULL;
33133 }
33134
33135
33136 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33137 PyObject *resultobj = 0;
33138 wxWindow *arg1 = (wxWindow *) 0 ;
33139 int 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_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33149 }
33150 arg1 = reinterpret_cast< wxWindow * >(argp1);
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33154 wxPyEndAllowThreads(__tstate);
33155 if (PyErr_Occurred()) SWIG_fail;
33156 }
33157 resultobj = SWIG_From_int(static_cast< int >(result));
33158 return resultobj;
33159 fail:
33160 return NULL;
33161 }
33162
33163
33164 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33165 PyObject *resultobj = 0;
33166 wxWindow *arg1 = (wxWindow *) 0 ;
33167 int result;
33168 void *argp1 = 0 ;
33169 int res1 = 0 ;
33170 PyObject *swig_obj[1] ;
33171
33172 if (!args) SWIG_fail;
33173 swig_obj[0] = args;
33174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33175 if (!SWIG_IsOK(res1)) {
33176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33177 }
33178 arg1 = reinterpret_cast< wxWindow * >(argp1);
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33182 wxPyEndAllowThreads(__tstate);
33183 if (PyErr_Occurred()) SWIG_fail;
33184 }
33185 resultobj = SWIG_From_int(static_cast< int >(result));
33186 return resultobj;
33187 fail:
33188 return NULL;
33189 }
33190
33191
33192 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33193 PyObject *resultobj = 0;
33194 wxWindow *arg1 = (wxWindow *) 0 ;
33195 wxSize *arg2 = 0 ;
33196 void *argp1 = 0 ;
33197 int res1 = 0 ;
33198 wxSize temp2 ;
33199 PyObject * obj0 = 0 ;
33200 PyObject * obj1 = 0 ;
33201 char * kwnames[] = {
33202 (char *) "self",(char *) "size", NULL
33203 };
33204
33205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33207 if (!SWIG_IsOK(res1)) {
33208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33209 }
33210 arg1 = reinterpret_cast< wxWindow * >(argp1);
33211 {
33212 arg2 = &temp2;
33213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33214 }
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 resultobj = SWIG_Py_Void();
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33229 PyObject *resultobj = 0;
33230 wxWindow *arg1 = (wxWindow *) 0 ;
33231 int arg2 ;
33232 int arg3 ;
33233 void *argp1 = 0 ;
33234 int res1 = 0 ;
33235 int val2 ;
33236 int ecode2 = 0 ;
33237 int val3 ;
33238 int ecode3 = 0 ;
33239 PyObject * obj0 = 0 ;
33240 PyObject * obj1 = 0 ;
33241 PyObject * obj2 = 0 ;
33242 char * kwnames[] = {
33243 (char *) "self",(char *) "w",(char *) "h", NULL
33244 };
33245
33246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33248 if (!SWIG_IsOK(res1)) {
33249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33250 }
33251 arg1 = reinterpret_cast< wxWindow * >(argp1);
33252 ecode2 = SWIG_AsVal_int(obj1, &val2);
33253 if (!SWIG_IsOK(ecode2)) {
33254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33255 }
33256 arg2 = static_cast< int >(val2);
33257 ecode3 = SWIG_AsVal_int(obj2, &val3);
33258 if (!SWIG_IsOK(ecode3)) {
33259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33260 }
33261 arg3 = static_cast< int >(val3);
33262 {
33263 PyThreadState* __tstate = wxPyBeginAllowThreads();
33264 (arg1)->SetVirtualSize(arg2,arg3);
33265 wxPyEndAllowThreads(__tstate);
33266 if (PyErr_Occurred()) SWIG_fail;
33267 }
33268 resultobj = SWIG_Py_Void();
33269 return resultobj;
33270 fail:
33271 return NULL;
33272 }
33273
33274
33275 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33276 PyObject *resultobj = 0;
33277 wxWindow *arg1 = (wxWindow *) 0 ;
33278 wxSize result;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 PyObject *swig_obj[1] ;
33282
33283 if (!args) SWIG_fail;
33284 swig_obj[0] = args;
33285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33286 if (!SWIG_IsOK(res1)) {
33287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33288 }
33289 arg1 = reinterpret_cast< wxWindow * >(argp1);
33290 {
33291 PyThreadState* __tstate = wxPyBeginAllowThreads();
33292 result = ((wxWindow const *)arg1)->GetVirtualSize();
33293 wxPyEndAllowThreads(__tstate);
33294 if (PyErr_Occurred()) SWIG_fail;
33295 }
33296 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33304 PyObject *resultobj = 0;
33305 wxWindow *arg1 = (wxWindow *) 0 ;
33306 int *arg2 = (int *) 0 ;
33307 int *arg3 = (int *) 0 ;
33308 void *argp1 = 0 ;
33309 int res1 = 0 ;
33310 int temp2 ;
33311 int res2 = SWIG_TMPOBJ ;
33312 int temp3 ;
33313 int res3 = SWIG_TMPOBJ ;
33314 PyObject *swig_obj[1] ;
33315
33316 arg2 = &temp2;
33317 arg3 = &temp3;
33318 if (!args) SWIG_fail;
33319 swig_obj[0] = args;
33320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33321 if (!SWIG_IsOK(res1)) {
33322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33323 }
33324 arg1 = reinterpret_cast< wxWindow * >(argp1);
33325 {
33326 PyThreadState* __tstate = wxPyBeginAllowThreads();
33327 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 resultobj = SWIG_Py_Void();
33332 if (SWIG_IsTmpObj(res2)) {
33333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33334 } else {
33335 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33337 }
33338 if (SWIG_IsTmpObj(res3)) {
33339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33340 } else {
33341 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33343 }
33344 return resultobj;
33345 fail:
33346 return NULL;
33347 }
33348
33349
33350 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33351 PyObject *resultobj = 0;
33352 wxWindow *arg1 = (wxWindow *) 0 ;
33353 wxSize result;
33354 void *argp1 = 0 ;
33355 int res1 = 0 ;
33356 PyObject *swig_obj[1] ;
33357
33358 if (!args) SWIG_fail;
33359 swig_obj[0] = args;
33360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33361 if (!SWIG_IsOK(res1)) {
33362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33363 }
33364 arg1 = reinterpret_cast< wxWindow * >(argp1);
33365 {
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj = 0;
33380 wxWindow *arg1 = (wxWindow *) 0 ;
33381 bool arg2 = (bool) true ;
33382 bool result;
33383 void *argp1 = 0 ;
33384 int res1 = 0 ;
33385 bool val2 ;
33386 int ecode2 = 0 ;
33387 PyObject * obj0 = 0 ;
33388 PyObject * obj1 = 0 ;
33389 char * kwnames[] = {
33390 (char *) "self",(char *) "show", NULL
33391 };
33392
33393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33395 if (!SWIG_IsOK(res1)) {
33396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33397 }
33398 arg1 = reinterpret_cast< wxWindow * >(argp1);
33399 if (obj1) {
33400 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33401 if (!SWIG_IsOK(ecode2)) {
33402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33403 }
33404 arg2 = static_cast< bool >(val2);
33405 }
33406 {
33407 PyThreadState* __tstate = wxPyBeginAllowThreads();
33408 result = (bool)(arg1)->Show(arg2);
33409 wxPyEndAllowThreads(__tstate);
33410 if (PyErr_Occurred()) SWIG_fail;
33411 }
33412 {
33413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33414 }
33415 return resultobj;
33416 fail:
33417 return NULL;
33418 }
33419
33420
33421 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33422 PyObject *resultobj = 0;
33423 wxWindow *arg1 = (wxWindow *) 0 ;
33424 bool result;
33425 void *argp1 = 0 ;
33426 int res1 = 0 ;
33427 PyObject *swig_obj[1] ;
33428
33429 if (!args) SWIG_fail;
33430 swig_obj[0] = args;
33431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33432 if (!SWIG_IsOK(res1)) {
33433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33434 }
33435 arg1 = reinterpret_cast< wxWindow * >(argp1);
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (bool)(arg1)->Hide();
33439 wxPyEndAllowThreads(__tstate);
33440 if (PyErr_Occurred()) SWIG_fail;
33441 }
33442 {
33443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33444 }
33445 return resultobj;
33446 fail:
33447 return NULL;
33448 }
33449
33450
33451 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33452 PyObject *resultobj = 0;
33453 wxWindow *arg1 = (wxWindow *) 0 ;
33454 bool arg2 = (bool) true ;
33455 bool result;
33456 void *argp1 = 0 ;
33457 int res1 = 0 ;
33458 bool val2 ;
33459 int ecode2 = 0 ;
33460 PyObject * obj0 = 0 ;
33461 PyObject * obj1 = 0 ;
33462 char * kwnames[] = {
33463 (char *) "self",(char *) "enable", NULL
33464 };
33465
33466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33468 if (!SWIG_IsOK(res1)) {
33469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33470 }
33471 arg1 = reinterpret_cast< wxWindow * >(argp1);
33472 if (obj1) {
33473 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33474 if (!SWIG_IsOK(ecode2)) {
33475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33476 }
33477 arg2 = static_cast< bool >(val2);
33478 }
33479 {
33480 PyThreadState* __tstate = wxPyBeginAllowThreads();
33481 result = (bool)(arg1)->Enable(arg2);
33482 wxPyEndAllowThreads(__tstate);
33483 if (PyErr_Occurred()) SWIG_fail;
33484 }
33485 {
33486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33487 }
33488 return resultobj;
33489 fail:
33490 return NULL;
33491 }
33492
33493
33494 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33495 PyObject *resultobj = 0;
33496 wxWindow *arg1 = (wxWindow *) 0 ;
33497 bool result;
33498 void *argp1 = 0 ;
33499 int res1 = 0 ;
33500 PyObject *swig_obj[1] ;
33501
33502 if (!args) SWIG_fail;
33503 swig_obj[0] = args;
33504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33505 if (!SWIG_IsOK(res1)) {
33506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33507 }
33508 arg1 = reinterpret_cast< wxWindow * >(argp1);
33509 {
33510 PyThreadState* __tstate = wxPyBeginAllowThreads();
33511 result = (bool)(arg1)->Disable();
33512 wxPyEndAllowThreads(__tstate);
33513 if (PyErr_Occurred()) SWIG_fail;
33514 }
33515 {
33516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33517 }
33518 return resultobj;
33519 fail:
33520 return NULL;
33521 }
33522
33523
33524 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33525 PyObject *resultobj = 0;
33526 wxWindow *arg1 = (wxWindow *) 0 ;
33527 bool result;
33528 void *argp1 = 0 ;
33529 int res1 = 0 ;
33530 PyObject *swig_obj[1] ;
33531
33532 if (!args) SWIG_fail;
33533 swig_obj[0] = args;
33534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33535 if (!SWIG_IsOK(res1)) {
33536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33537 }
33538 arg1 = reinterpret_cast< wxWindow * >(argp1);
33539 {
33540 PyThreadState* __tstate = wxPyBeginAllowThreads();
33541 result = (bool)((wxWindow const *)arg1)->IsShown();
33542 wxPyEndAllowThreads(__tstate);
33543 if (PyErr_Occurred()) SWIG_fail;
33544 }
33545 {
33546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33547 }
33548 return resultobj;
33549 fail:
33550 return NULL;
33551 }
33552
33553
33554 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33555 PyObject *resultobj = 0;
33556 wxWindow *arg1 = (wxWindow *) 0 ;
33557 bool result;
33558 void *argp1 = 0 ;
33559 int res1 = 0 ;
33560 PyObject *swig_obj[1] ;
33561
33562 if (!args) SWIG_fail;
33563 swig_obj[0] = args;
33564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33565 if (!SWIG_IsOK(res1)) {
33566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33567 }
33568 arg1 = reinterpret_cast< wxWindow * >(argp1);
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33577 }
33578 return resultobj;
33579 fail:
33580 return NULL;
33581 }
33582
33583
33584 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 PyObject *resultobj = 0;
33586 wxWindow *arg1 = (wxWindow *) 0 ;
33587 bool result;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 PyObject *swig_obj[1] ;
33591
33592 if (!args) SWIG_fail;
33593 swig_obj[0] = args;
33594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33597 }
33598 arg1 = reinterpret_cast< wxWindow * >(argp1);
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 {
33606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33607 }
33608 return resultobj;
33609 fail:
33610 return NULL;
33611 }
33612
33613
33614 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33615 PyObject *resultobj = 0;
33616 wxWindow *arg1 = (wxWindow *) 0 ;
33617 long arg2 ;
33618 void *argp1 = 0 ;
33619 int res1 = 0 ;
33620 long val2 ;
33621 int ecode2 = 0 ;
33622 PyObject * obj0 = 0 ;
33623 PyObject * obj1 = 0 ;
33624 char * kwnames[] = {
33625 (char *) "self",(char *) "style", NULL
33626 };
33627
33628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33630 if (!SWIG_IsOK(res1)) {
33631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33632 }
33633 arg1 = reinterpret_cast< wxWindow * >(argp1);
33634 ecode2 = SWIG_AsVal_long(obj1, &val2);
33635 if (!SWIG_IsOK(ecode2)) {
33636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33637 }
33638 arg2 = static_cast< long >(val2);
33639 {
33640 PyThreadState* __tstate = wxPyBeginAllowThreads();
33641 (arg1)->SetWindowStyleFlag(arg2);
33642 wxPyEndAllowThreads(__tstate);
33643 if (PyErr_Occurred()) SWIG_fail;
33644 }
33645 resultobj = SWIG_Py_Void();
33646 return resultobj;
33647 fail:
33648 return NULL;
33649 }
33650
33651
33652 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33653 PyObject *resultobj = 0;
33654 wxWindow *arg1 = (wxWindow *) 0 ;
33655 long result;
33656 void *argp1 = 0 ;
33657 int res1 = 0 ;
33658 PyObject *swig_obj[1] ;
33659
33660 if (!args) SWIG_fail;
33661 swig_obj[0] = args;
33662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33663 if (!SWIG_IsOK(res1)) {
33664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33665 }
33666 arg1 = reinterpret_cast< wxWindow * >(argp1);
33667 {
33668 PyThreadState* __tstate = wxPyBeginAllowThreads();
33669 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33670 wxPyEndAllowThreads(__tstate);
33671 if (PyErr_Occurred()) SWIG_fail;
33672 }
33673 resultobj = SWIG_From_long(static_cast< long >(result));
33674 return resultobj;
33675 fail:
33676 return NULL;
33677 }
33678
33679
33680 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33681 PyObject *resultobj = 0;
33682 wxWindow *arg1 = (wxWindow *) 0 ;
33683 int arg2 ;
33684 bool result;
33685 void *argp1 = 0 ;
33686 int res1 = 0 ;
33687 int val2 ;
33688 int ecode2 = 0 ;
33689 PyObject * obj0 = 0 ;
33690 PyObject * obj1 = 0 ;
33691 char * kwnames[] = {
33692 (char *) "self",(char *) "flag", NULL
33693 };
33694
33695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33697 if (!SWIG_IsOK(res1)) {
33698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33699 }
33700 arg1 = reinterpret_cast< wxWindow * >(argp1);
33701 ecode2 = SWIG_AsVal_int(obj1, &val2);
33702 if (!SWIG_IsOK(ecode2)) {
33703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33704 }
33705 arg2 = static_cast< int >(val2);
33706 {
33707 PyThreadState* __tstate = wxPyBeginAllowThreads();
33708 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33709 wxPyEndAllowThreads(__tstate);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 }
33712 {
33713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33714 }
33715 return resultobj;
33716 fail:
33717 return NULL;
33718 }
33719
33720
33721 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33722 PyObject *resultobj = 0;
33723 wxWindow *arg1 = (wxWindow *) 0 ;
33724 bool result;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 PyObject *swig_obj[1] ;
33728
33729 if (!args) SWIG_fail;
33730 swig_obj[0] = args;
33731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33732 if (!SWIG_IsOK(res1)) {
33733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33734 }
33735 arg1 = reinterpret_cast< wxWindow * >(argp1);
33736 {
33737 PyThreadState* __tstate = wxPyBeginAllowThreads();
33738 result = (bool)((wxWindow const *)arg1)->IsRetained();
33739 wxPyEndAllowThreads(__tstate);
33740 if (PyErr_Occurred()) SWIG_fail;
33741 }
33742 {
33743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33744 }
33745 return resultobj;
33746 fail:
33747 return NULL;
33748 }
33749
33750
33751 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33752 PyObject *resultobj = 0;
33753 wxWindow *arg1 = (wxWindow *) 0 ;
33754 long arg2 ;
33755 void *argp1 = 0 ;
33756 int res1 = 0 ;
33757 long val2 ;
33758 int ecode2 = 0 ;
33759 PyObject * obj0 = 0 ;
33760 PyObject * obj1 = 0 ;
33761 char * kwnames[] = {
33762 (char *) "self",(char *) "exStyle", NULL
33763 };
33764
33765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33767 if (!SWIG_IsOK(res1)) {
33768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33769 }
33770 arg1 = reinterpret_cast< wxWindow * >(argp1);
33771 ecode2 = SWIG_AsVal_long(obj1, &val2);
33772 if (!SWIG_IsOK(ecode2)) {
33773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33774 }
33775 arg2 = static_cast< long >(val2);
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 (arg1)->SetExtraStyle(arg2);
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_Py_Void();
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33790 PyObject *resultobj = 0;
33791 wxWindow *arg1 = (wxWindow *) 0 ;
33792 long result;
33793 void *argp1 = 0 ;
33794 int res1 = 0 ;
33795 PyObject *swig_obj[1] ;
33796
33797 if (!args) SWIG_fail;
33798 swig_obj[0] = args;
33799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33800 if (!SWIG_IsOK(res1)) {
33801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33802 }
33803 arg1 = reinterpret_cast< wxWindow * >(argp1);
33804 {
33805 PyThreadState* __tstate = wxPyBeginAllowThreads();
33806 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33807 wxPyEndAllowThreads(__tstate);
33808 if (PyErr_Occurred()) SWIG_fail;
33809 }
33810 resultobj = SWIG_From_long(static_cast< long >(result));
33811 return resultobj;
33812 fail:
33813 return NULL;
33814 }
33815
33816
33817 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33818 PyObject *resultobj = 0;
33819 wxWindow *arg1 = (wxWindow *) 0 ;
33820 bool arg2 = (bool) true ;
33821 void *argp1 = 0 ;
33822 int res1 = 0 ;
33823 bool val2 ;
33824 int ecode2 = 0 ;
33825 PyObject * obj0 = 0 ;
33826 PyObject * obj1 = 0 ;
33827 char * kwnames[] = {
33828 (char *) "self",(char *) "modal", NULL
33829 };
33830
33831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33833 if (!SWIG_IsOK(res1)) {
33834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33835 }
33836 arg1 = reinterpret_cast< wxWindow * >(argp1);
33837 if (obj1) {
33838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33839 if (!SWIG_IsOK(ecode2)) {
33840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33841 }
33842 arg2 = static_cast< bool >(val2);
33843 }
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 (arg1)->MakeModal(arg2);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_Py_Void();
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 bool arg2 ;
33861 void *argp1 = 0 ;
33862 int res1 = 0 ;
33863 bool val2 ;
33864 int ecode2 = 0 ;
33865 PyObject * obj0 = 0 ;
33866 PyObject * obj1 = 0 ;
33867 char * kwnames[] = {
33868 (char *) "self",(char *) "enableTheme", NULL
33869 };
33870
33871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33873 if (!SWIG_IsOK(res1)) {
33874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33875 }
33876 arg1 = reinterpret_cast< wxWindow * >(argp1);
33877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33878 if (!SWIG_IsOK(ecode2)) {
33879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33880 }
33881 arg2 = static_cast< bool >(val2);
33882 {
33883 PyThreadState* __tstate = wxPyBeginAllowThreads();
33884 (arg1)->SetThemeEnabled(arg2);
33885 wxPyEndAllowThreads(__tstate);
33886 if (PyErr_Occurred()) SWIG_fail;
33887 }
33888 resultobj = SWIG_Py_Void();
33889 return resultobj;
33890 fail:
33891 return NULL;
33892 }
33893
33894
33895 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33896 PyObject *resultobj = 0;
33897 wxWindow *arg1 = (wxWindow *) 0 ;
33898 bool result;
33899 void *argp1 = 0 ;
33900 int res1 = 0 ;
33901 PyObject *swig_obj[1] ;
33902
33903 if (!args) SWIG_fail;
33904 swig_obj[0] = args;
33905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33906 if (!SWIG_IsOK(res1)) {
33907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33908 }
33909 arg1 = reinterpret_cast< wxWindow * >(argp1);
33910 {
33911 PyThreadState* __tstate = wxPyBeginAllowThreads();
33912 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33913 wxPyEndAllowThreads(__tstate);
33914 if (PyErr_Occurred()) SWIG_fail;
33915 }
33916 {
33917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33918 }
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33926 PyObject *resultobj = 0;
33927 wxWindow *arg1 = (wxWindow *) 0 ;
33928 void *argp1 = 0 ;
33929 int res1 = 0 ;
33930 PyObject *swig_obj[1] ;
33931
33932 if (!args) SWIG_fail;
33933 swig_obj[0] = args;
33934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33935 if (!SWIG_IsOK(res1)) {
33936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33937 }
33938 arg1 = reinterpret_cast< wxWindow * >(argp1);
33939 {
33940 PyThreadState* __tstate = wxPyBeginAllowThreads();
33941 (arg1)->SetFocus();
33942 wxPyEndAllowThreads(__tstate);
33943 if (PyErr_Occurred()) SWIG_fail;
33944 }
33945 resultobj = SWIG_Py_Void();
33946 return resultobj;
33947 fail:
33948 return NULL;
33949 }
33950
33951
33952 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33953 PyObject *resultobj = 0;
33954 wxWindow *arg1 = (wxWindow *) 0 ;
33955 void *argp1 = 0 ;
33956 int res1 = 0 ;
33957 PyObject *swig_obj[1] ;
33958
33959 if (!args) SWIG_fail;
33960 swig_obj[0] = args;
33961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33962 if (!SWIG_IsOK(res1)) {
33963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33964 }
33965 arg1 = reinterpret_cast< wxWindow * >(argp1);
33966 {
33967 PyThreadState* __tstate = wxPyBeginAllowThreads();
33968 (arg1)->SetFocusFromKbd();
33969 wxPyEndAllowThreads(__tstate);
33970 if (PyErr_Occurred()) SWIG_fail;
33971 }
33972 resultobj = SWIG_Py_Void();
33973 return resultobj;
33974 fail:
33975 return NULL;
33976 }
33977
33978
33979 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33980 PyObject *resultobj = 0;
33981 wxWindow *result = 0 ;
33982
33983 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33984 {
33985 if (!wxPyCheckForApp()) SWIG_fail;
33986 PyThreadState* __tstate = wxPyBeginAllowThreads();
33987 result = (wxWindow *)wxWindow::FindFocus();
33988 wxPyEndAllowThreads(__tstate);
33989 if (PyErr_Occurred()) SWIG_fail;
33990 }
33991 {
33992 resultobj = wxPyMake_wxObject(result, 0);
33993 }
33994 return resultobj;
33995 fail:
33996 return NULL;
33997 }
33998
33999
34000 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34001 PyObject *resultobj = 0;
34002 wxWindow *arg1 = (wxWindow *) 0 ;
34003 bool result;
34004 void *argp1 = 0 ;
34005 int res1 = 0 ;
34006 PyObject *swig_obj[1] ;
34007
34008 if (!args) SWIG_fail;
34009 swig_obj[0] = args;
34010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34013 }
34014 arg1 = reinterpret_cast< wxWindow * >(argp1);
34015 {
34016 PyThreadState* __tstate = wxPyBeginAllowThreads();
34017 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34018 wxPyEndAllowThreads(__tstate);
34019 if (PyErr_Occurred()) SWIG_fail;
34020 }
34021 {
34022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34023 }
34024 return resultobj;
34025 fail:
34026 return NULL;
34027 }
34028
34029
34030 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34031 PyObject *resultobj = 0;
34032 wxWindow *arg1 = (wxWindow *) 0 ;
34033 bool result;
34034 void *argp1 = 0 ;
34035 int res1 = 0 ;
34036 PyObject *swig_obj[1] ;
34037
34038 if (!args) SWIG_fail;
34039 swig_obj[0] = args;
34040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34041 if (!SWIG_IsOK(res1)) {
34042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34043 }
34044 arg1 = reinterpret_cast< wxWindow * >(argp1);
34045 {
34046 PyThreadState* __tstate = wxPyBeginAllowThreads();
34047 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34048 wxPyEndAllowThreads(__tstate);
34049 if (PyErr_Occurred()) SWIG_fail;
34050 }
34051 {
34052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34053 }
34054 return resultobj;
34055 fail:
34056 return NULL;
34057 }
34058
34059
34060 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34061 PyObject *resultobj = 0;
34062 wxWindow *arg1 = (wxWindow *) 0 ;
34063 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34064 bool result;
34065 void *argp1 = 0 ;
34066 int res1 = 0 ;
34067 int val2 ;
34068 int ecode2 = 0 ;
34069 PyObject * obj0 = 0 ;
34070 PyObject * obj1 = 0 ;
34071 char * kwnames[] = {
34072 (char *) "self",(char *) "flags", NULL
34073 };
34074
34075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34077 if (!SWIG_IsOK(res1)) {
34078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34079 }
34080 arg1 = reinterpret_cast< wxWindow * >(argp1);
34081 if (obj1) {
34082 ecode2 = SWIG_AsVal_int(obj1, &val2);
34083 if (!SWIG_IsOK(ecode2)) {
34084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34085 }
34086 arg2 = static_cast< int >(val2);
34087 }
34088 {
34089 PyThreadState* __tstate = wxPyBeginAllowThreads();
34090 result = (bool)(arg1)->Navigate(arg2);
34091 wxPyEndAllowThreads(__tstate);
34092 if (PyErr_Occurred()) SWIG_fail;
34093 }
34094 {
34095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34096 }
34097 return resultobj;
34098 fail:
34099 return NULL;
34100 }
34101
34102
34103 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34104 PyObject *resultobj = 0;
34105 wxWindow *arg1 = (wxWindow *) 0 ;
34106 wxWindow *arg2 = (wxWindow *) 0 ;
34107 void *argp1 = 0 ;
34108 int res1 = 0 ;
34109 void *argp2 = 0 ;
34110 int res2 = 0 ;
34111 PyObject * obj0 = 0 ;
34112 PyObject * obj1 = 0 ;
34113 char * kwnames[] = {
34114 (char *) "self",(char *) "win", NULL
34115 };
34116
34117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34119 if (!SWIG_IsOK(res1)) {
34120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34121 }
34122 arg1 = reinterpret_cast< wxWindow * >(argp1);
34123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34124 if (!SWIG_IsOK(res2)) {
34125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34126 }
34127 arg2 = reinterpret_cast< wxWindow * >(argp2);
34128 {
34129 PyThreadState* __tstate = wxPyBeginAllowThreads();
34130 (arg1)->MoveAfterInTabOrder(arg2);
34131 wxPyEndAllowThreads(__tstate);
34132 if (PyErr_Occurred()) SWIG_fail;
34133 }
34134 resultobj = SWIG_Py_Void();
34135 return resultobj;
34136 fail:
34137 return NULL;
34138 }
34139
34140
34141 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34142 PyObject *resultobj = 0;
34143 wxWindow *arg1 = (wxWindow *) 0 ;
34144 wxWindow *arg2 = (wxWindow *) 0 ;
34145 void *argp1 = 0 ;
34146 int res1 = 0 ;
34147 void *argp2 = 0 ;
34148 int res2 = 0 ;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 char * kwnames[] = {
34152 (char *) "self",(char *) "win", NULL
34153 };
34154
34155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34157 if (!SWIG_IsOK(res1)) {
34158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34159 }
34160 arg1 = reinterpret_cast< wxWindow * >(argp1);
34161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34162 if (!SWIG_IsOK(res2)) {
34163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34164 }
34165 arg2 = reinterpret_cast< wxWindow * >(argp2);
34166 {
34167 PyThreadState* __tstate = wxPyBeginAllowThreads();
34168 (arg1)->MoveBeforeInTabOrder(arg2);
34169 wxPyEndAllowThreads(__tstate);
34170 if (PyErr_Occurred()) SWIG_fail;
34171 }
34172 resultobj = SWIG_Py_Void();
34173 return resultobj;
34174 fail:
34175 return NULL;
34176 }
34177
34178
34179 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34180 PyObject *resultobj = 0;
34181 wxWindow *arg1 = (wxWindow *) 0 ;
34182 PyObject *result = 0 ;
34183 void *argp1 = 0 ;
34184 int res1 = 0 ;
34185 PyObject *swig_obj[1] ;
34186
34187 if (!args) SWIG_fail;
34188 swig_obj[0] = args;
34189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34190 if (!SWIG_IsOK(res1)) {
34191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34192 }
34193 arg1 = reinterpret_cast< wxWindow * >(argp1);
34194 {
34195 PyThreadState* __tstate = wxPyBeginAllowThreads();
34196 result = (PyObject *)wxWindow_GetChildren(arg1);
34197 wxPyEndAllowThreads(__tstate);
34198 if (PyErr_Occurred()) SWIG_fail;
34199 }
34200 resultobj = result;
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34208 PyObject *resultobj = 0;
34209 wxWindow *arg1 = (wxWindow *) 0 ;
34210 wxWindow *result = 0 ;
34211 void *argp1 = 0 ;
34212 int res1 = 0 ;
34213 PyObject *swig_obj[1] ;
34214
34215 if (!args) SWIG_fail;
34216 swig_obj[0] = args;
34217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34218 if (!SWIG_IsOK(res1)) {
34219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34220 }
34221 arg1 = reinterpret_cast< wxWindow * >(argp1);
34222 {
34223 PyThreadState* __tstate = wxPyBeginAllowThreads();
34224 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34225 wxPyEndAllowThreads(__tstate);
34226 if (PyErr_Occurred()) SWIG_fail;
34227 }
34228 {
34229 resultobj = wxPyMake_wxObject(result, 0);
34230 }
34231 return resultobj;
34232 fail:
34233 return NULL;
34234 }
34235
34236
34237 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34238 PyObject *resultobj = 0;
34239 wxWindow *arg1 = (wxWindow *) 0 ;
34240 wxWindow *result = 0 ;
34241 void *argp1 = 0 ;
34242 int res1 = 0 ;
34243 PyObject *swig_obj[1] ;
34244
34245 if (!args) SWIG_fail;
34246 swig_obj[0] = args;
34247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34250 }
34251 arg1 = reinterpret_cast< wxWindow * >(argp1);
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34255 wxPyEndAllowThreads(__tstate);
34256 if (PyErr_Occurred()) SWIG_fail;
34257 }
34258 {
34259 resultobj = wxPyMake_wxObject(result, 0);
34260 }
34261 return resultobj;
34262 fail:
34263 return NULL;
34264 }
34265
34266
34267 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34268 PyObject *resultobj = 0;
34269 wxWindow *arg1 = (wxWindow *) 0 ;
34270 bool result;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 PyObject *swig_obj[1] ;
34274
34275 if (!args) SWIG_fail;
34276 swig_obj[0] = args;
34277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34278 if (!SWIG_IsOK(res1)) {
34279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34280 }
34281 arg1 = reinterpret_cast< wxWindow * >(argp1);
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 {
34289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34290 }
34291 return resultobj;
34292 fail:
34293 return NULL;
34294 }
34295
34296
34297 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34298 PyObject *resultobj = 0;
34299 wxWindow *arg1 = (wxWindow *) 0 ;
34300 wxWindow *arg2 = (wxWindow *) 0 ;
34301 bool result;
34302 void *argp1 = 0 ;
34303 int res1 = 0 ;
34304 void *argp2 = 0 ;
34305 int res2 = 0 ;
34306 PyObject * obj0 = 0 ;
34307 PyObject * obj1 = 0 ;
34308 char * kwnames[] = {
34309 (char *) "self",(char *) "newParent", NULL
34310 };
34311
34312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34314 if (!SWIG_IsOK(res1)) {
34315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34316 }
34317 arg1 = reinterpret_cast< wxWindow * >(argp1);
34318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34319 if (!SWIG_IsOK(res2)) {
34320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34321 }
34322 arg2 = reinterpret_cast< wxWindow * >(argp2);
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 result = (bool)(arg1)->Reparent(arg2);
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 {
34330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34331 }
34332 return resultobj;
34333 fail:
34334 return NULL;
34335 }
34336
34337
34338 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34339 PyObject *resultobj = 0;
34340 wxWindow *arg1 = (wxWindow *) 0 ;
34341 wxWindow *arg2 = (wxWindow *) 0 ;
34342 void *argp1 = 0 ;
34343 int res1 = 0 ;
34344 void *argp2 = 0 ;
34345 int res2 = 0 ;
34346 PyObject * obj0 = 0 ;
34347 PyObject * obj1 = 0 ;
34348 char * kwnames[] = {
34349 (char *) "self",(char *) "child", NULL
34350 };
34351
34352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34354 if (!SWIG_IsOK(res1)) {
34355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34356 }
34357 arg1 = reinterpret_cast< wxWindow * >(argp1);
34358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34359 if (!SWIG_IsOK(res2)) {
34360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34361 }
34362 arg2 = reinterpret_cast< wxWindow * >(argp2);
34363 {
34364 PyThreadState* __tstate = wxPyBeginAllowThreads();
34365 (arg1)->AddChild(arg2);
34366 wxPyEndAllowThreads(__tstate);
34367 if (PyErr_Occurred()) SWIG_fail;
34368 }
34369 resultobj = SWIG_Py_Void();
34370 return resultobj;
34371 fail:
34372 return NULL;
34373 }
34374
34375
34376 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34377 PyObject *resultobj = 0;
34378 wxWindow *arg1 = (wxWindow *) 0 ;
34379 wxWindow *arg2 = (wxWindow *) 0 ;
34380 void *argp1 = 0 ;
34381 int res1 = 0 ;
34382 void *argp2 = 0 ;
34383 int res2 = 0 ;
34384 PyObject * obj0 = 0 ;
34385 PyObject * obj1 = 0 ;
34386 char * kwnames[] = {
34387 (char *) "self",(char *) "child", NULL
34388 };
34389
34390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34392 if (!SWIG_IsOK(res1)) {
34393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34394 }
34395 arg1 = reinterpret_cast< wxWindow * >(argp1);
34396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res2)) {
34398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34399 }
34400 arg2 = reinterpret_cast< wxWindow * >(argp2);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 (arg1)->RemoveChild(arg2);
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_Py_Void();
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 bool arg2 ;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 bool val2 ;
34421 int ecode2 = 0 ;
34422 PyObject * obj0 = 0 ;
34423 PyObject * obj1 = 0 ;
34424 char * kwnames[] = {
34425 (char *) "self",(char *) "on", NULL
34426 };
34427
34428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34430 if (!SWIG_IsOK(res1)) {
34431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34432 }
34433 arg1 = reinterpret_cast< wxWindow * >(argp1);
34434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34435 if (!SWIG_IsOK(ecode2)) {
34436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34437 }
34438 arg2 = static_cast< bool >(val2);
34439 {
34440 PyThreadState* __tstate = wxPyBeginAllowThreads();
34441 (arg1)->SetDoubleBuffered(arg2);
34442 wxPyEndAllowThreads(__tstate);
34443 if (PyErr_Occurred()) SWIG_fail;
34444 }
34445 resultobj = SWIG_Py_Void();
34446 return resultobj;
34447 fail:
34448 return NULL;
34449 }
34450
34451
34452 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34453 PyObject *resultobj = 0;
34454 wxWindow *arg1 = (wxWindow *) 0 ;
34455 long arg2 ;
34456 wxWindow *result = 0 ;
34457 void *argp1 = 0 ;
34458 int res1 = 0 ;
34459 long val2 ;
34460 int ecode2 = 0 ;
34461 PyObject * obj0 = 0 ;
34462 PyObject * obj1 = 0 ;
34463 char * kwnames[] = {
34464 (char *) "self",(char *) "winid", NULL
34465 };
34466
34467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34469 if (!SWIG_IsOK(res1)) {
34470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34471 }
34472 arg1 = reinterpret_cast< wxWindow * >(argp1);
34473 ecode2 = SWIG_AsVal_long(obj1, &val2);
34474 if (!SWIG_IsOK(ecode2)) {
34475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34476 }
34477 arg2 = static_cast< long >(val2);
34478 {
34479 PyThreadState* __tstate = wxPyBeginAllowThreads();
34480 result = (wxWindow *)(arg1)->FindWindow(arg2);
34481 wxPyEndAllowThreads(__tstate);
34482 if (PyErr_Occurred()) SWIG_fail;
34483 }
34484 {
34485 resultobj = wxPyMake_wxObject(result, 0);
34486 }
34487 return resultobj;
34488 fail:
34489 return NULL;
34490 }
34491
34492
34493 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34494 PyObject *resultobj = 0;
34495 wxWindow *arg1 = (wxWindow *) 0 ;
34496 wxString *arg2 = 0 ;
34497 wxWindow *result = 0 ;
34498 void *argp1 = 0 ;
34499 int res1 = 0 ;
34500 bool temp2 = false ;
34501 PyObject * obj0 = 0 ;
34502 PyObject * obj1 = 0 ;
34503 char * kwnames[] = {
34504 (char *) "self",(char *) "name", NULL
34505 };
34506
34507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34509 if (!SWIG_IsOK(res1)) {
34510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34511 }
34512 arg1 = reinterpret_cast< wxWindow * >(argp1);
34513 {
34514 arg2 = wxString_in_helper(obj1);
34515 if (arg2 == NULL) SWIG_fail;
34516 temp2 = true;
34517 }
34518 {
34519 PyThreadState* __tstate = wxPyBeginAllowThreads();
34520 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34521 wxPyEndAllowThreads(__tstate);
34522 if (PyErr_Occurred()) SWIG_fail;
34523 }
34524 {
34525 resultobj = wxPyMake_wxObject(result, 0);
34526 }
34527 {
34528 if (temp2)
34529 delete arg2;
34530 }
34531 return resultobj;
34532 fail:
34533 {
34534 if (temp2)
34535 delete arg2;
34536 }
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34542 PyObject *resultobj = 0;
34543 wxWindow *arg1 = (wxWindow *) 0 ;
34544 wxEvtHandler *result = 0 ;
34545 void *argp1 = 0 ;
34546 int res1 = 0 ;
34547 PyObject *swig_obj[1] ;
34548
34549 if (!args) SWIG_fail;
34550 swig_obj[0] = args;
34551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34554 }
34555 arg1 = reinterpret_cast< wxWindow * >(argp1);
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 {
34563 resultobj = wxPyMake_wxObject(result, 0);
34564 }
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34572 PyObject *resultobj = 0;
34573 wxWindow *arg1 = (wxWindow *) 0 ;
34574 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34575 void *argp1 = 0 ;
34576 int res1 = 0 ;
34577 void *argp2 = 0 ;
34578 int res2 = 0 ;
34579 PyObject * obj0 = 0 ;
34580 PyObject * obj1 = 0 ;
34581 char * kwnames[] = {
34582 (char *) "self",(char *) "handler", NULL
34583 };
34584
34585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34587 if (!SWIG_IsOK(res1)) {
34588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34589 }
34590 arg1 = reinterpret_cast< wxWindow * >(argp1);
34591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34592 if (!SWIG_IsOK(res2)) {
34593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34594 }
34595 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 (arg1)->SetEventHandler(arg2);
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 resultobj = SWIG_Py_Void();
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 void *argp2 = 0 ;
34616 int res2 = 0 ;
34617 PyObject * obj0 = 0 ;
34618 PyObject * obj1 = 0 ;
34619 char * kwnames[] = {
34620 (char *) "self",(char *) "handler", NULL
34621 };
34622
34623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34625 if (!SWIG_IsOK(res1)) {
34626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34627 }
34628 arg1 = reinterpret_cast< wxWindow * >(argp1);
34629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34630 if (!SWIG_IsOK(res2)) {
34631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34632 }
34633 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34634 {
34635 PyThreadState* __tstate = wxPyBeginAllowThreads();
34636 (arg1)->PushEventHandler(arg2);
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 resultobj = SWIG_Py_Void();
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj = 0;
34649 wxWindow *arg1 = (wxWindow *) 0 ;
34650 bool arg2 = (bool) false ;
34651 wxEvtHandler *result = 0 ;
34652 void *argp1 = 0 ;
34653 int res1 = 0 ;
34654 bool val2 ;
34655 int ecode2 = 0 ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 char * kwnames[] = {
34659 (char *) "self",(char *) "deleteHandler", NULL
34660 };
34661
34662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34664 if (!SWIG_IsOK(res1)) {
34665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34666 }
34667 arg1 = reinterpret_cast< wxWindow * >(argp1);
34668 if (obj1) {
34669 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34670 if (!SWIG_IsOK(ecode2)) {
34671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34672 }
34673 arg2 = static_cast< bool >(val2);
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 {
34682 resultobj = wxPyMake_wxObject(result, 0);
34683 }
34684 return resultobj;
34685 fail:
34686 return NULL;
34687 }
34688
34689
34690 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34691 PyObject *resultobj = 0;
34692 wxWindow *arg1 = (wxWindow *) 0 ;
34693 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34694 bool result;
34695 void *argp1 = 0 ;
34696 int res1 = 0 ;
34697 void *argp2 = 0 ;
34698 int res2 = 0 ;
34699 PyObject * obj0 = 0 ;
34700 PyObject * obj1 = 0 ;
34701 char * kwnames[] = {
34702 (char *) "self",(char *) "handler", NULL
34703 };
34704
34705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34709 }
34710 arg1 = reinterpret_cast< wxWindow * >(argp1);
34711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34712 if (!SWIG_IsOK(res2)) {
34713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34714 }
34715 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34716 {
34717 PyThreadState* __tstate = wxPyBeginAllowThreads();
34718 result = (bool)(arg1)->RemoveEventHandler(arg2);
34719 wxPyEndAllowThreads(__tstate);
34720 if (PyErr_Occurred()) SWIG_fail;
34721 }
34722 {
34723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34724 }
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34732 PyObject *resultobj = 0;
34733 wxWindow *arg1 = (wxWindow *) 0 ;
34734 wxValidator *arg2 = 0 ;
34735 void *argp1 = 0 ;
34736 int res1 = 0 ;
34737 void *argp2 = 0 ;
34738 int res2 = 0 ;
34739 PyObject * obj0 = 0 ;
34740 PyObject * obj1 = 0 ;
34741 char * kwnames[] = {
34742 (char *) "self",(char *) "validator", NULL
34743 };
34744
34745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34747 if (!SWIG_IsOK(res1)) {
34748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34749 }
34750 arg1 = reinterpret_cast< wxWindow * >(argp1);
34751 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34752 if (!SWIG_IsOK(res2)) {
34753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34754 }
34755 if (!argp2) {
34756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34757 }
34758 arg2 = reinterpret_cast< wxValidator * >(argp2);
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 (arg1)->SetValidator((wxValidator const &)*arg2);
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 resultobj = SWIG_Py_Void();
34766 return resultobj;
34767 fail:
34768 return NULL;
34769 }
34770
34771
34772 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34773 PyObject *resultobj = 0;
34774 wxWindow *arg1 = (wxWindow *) 0 ;
34775 wxValidator *result = 0 ;
34776 void *argp1 = 0 ;
34777 int res1 = 0 ;
34778 PyObject *swig_obj[1] ;
34779
34780 if (!args) SWIG_fail;
34781 swig_obj[0] = args;
34782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34783 if (!SWIG_IsOK(res1)) {
34784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34785 }
34786 arg1 = reinterpret_cast< wxWindow * >(argp1);
34787 {
34788 PyThreadState* __tstate = wxPyBeginAllowThreads();
34789 result = (wxValidator *)(arg1)->GetValidator();
34790 wxPyEndAllowThreads(__tstate);
34791 if (PyErr_Occurred()) SWIG_fail;
34792 }
34793 {
34794 resultobj = wxPyMake_wxObject(result, (bool)0);
34795 }
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34803 PyObject *resultobj = 0;
34804 wxWindow *arg1 = (wxWindow *) 0 ;
34805 bool result;
34806 void *argp1 = 0 ;
34807 int res1 = 0 ;
34808 PyObject *swig_obj[1] ;
34809
34810 if (!args) SWIG_fail;
34811 swig_obj[0] = args;
34812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34813 if (!SWIG_IsOK(res1)) {
34814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34815 }
34816 arg1 = reinterpret_cast< wxWindow * >(argp1);
34817 {
34818 PyThreadState* __tstate = wxPyBeginAllowThreads();
34819 result = (bool)(arg1)->Validate();
34820 wxPyEndAllowThreads(__tstate);
34821 if (PyErr_Occurred()) SWIG_fail;
34822 }
34823 {
34824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34825 }
34826 return resultobj;
34827 fail:
34828 return NULL;
34829 }
34830
34831
34832 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34833 PyObject *resultobj = 0;
34834 wxWindow *arg1 = (wxWindow *) 0 ;
34835 bool result;
34836 void *argp1 = 0 ;
34837 int res1 = 0 ;
34838 PyObject *swig_obj[1] ;
34839
34840 if (!args) SWIG_fail;
34841 swig_obj[0] = args;
34842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34843 if (!SWIG_IsOK(res1)) {
34844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34845 }
34846 arg1 = reinterpret_cast< wxWindow * >(argp1);
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 result = (bool)(arg1)->TransferDataToWindow();
34850 wxPyEndAllowThreads(__tstate);
34851 if (PyErr_Occurred()) SWIG_fail;
34852 }
34853 {
34854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34855 }
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34863 PyObject *resultobj = 0;
34864 wxWindow *arg1 = (wxWindow *) 0 ;
34865 bool result;
34866 void *argp1 = 0 ;
34867 int res1 = 0 ;
34868 PyObject *swig_obj[1] ;
34869
34870 if (!args) SWIG_fail;
34871 swig_obj[0] = args;
34872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34873 if (!SWIG_IsOK(res1)) {
34874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34875 }
34876 arg1 = reinterpret_cast< wxWindow * >(argp1);
34877 {
34878 PyThreadState* __tstate = wxPyBeginAllowThreads();
34879 result = (bool)(arg1)->TransferDataFromWindow();
34880 wxPyEndAllowThreads(__tstate);
34881 if (PyErr_Occurred()) SWIG_fail;
34882 }
34883 {
34884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34885 }
34886 return resultobj;
34887 fail:
34888 return NULL;
34889 }
34890
34891
34892 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34893 PyObject *resultobj = 0;
34894 wxWindow *arg1 = (wxWindow *) 0 ;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 PyObject *swig_obj[1] ;
34898
34899 if (!args) SWIG_fail;
34900 swig_obj[0] = args;
34901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34902 if (!SWIG_IsOK(res1)) {
34903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34904 }
34905 arg1 = reinterpret_cast< wxWindow * >(argp1);
34906 {
34907 PyThreadState* __tstate = wxPyBeginAllowThreads();
34908 (arg1)->InitDialog();
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 resultobj = SWIG_Py_Void();
34913 return resultobj;
34914 fail:
34915 return NULL;
34916 }
34917
34918
34919 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34920 PyObject *resultobj = 0;
34921 wxWindow *arg1 = (wxWindow *) 0 ;
34922 wxAcceleratorTable *arg2 = 0 ;
34923 void *argp1 = 0 ;
34924 int res1 = 0 ;
34925 void *argp2 = 0 ;
34926 int res2 = 0 ;
34927 PyObject * obj0 = 0 ;
34928 PyObject * obj1 = 0 ;
34929 char * kwnames[] = {
34930 (char *) "self",(char *) "accel", NULL
34931 };
34932
34933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34937 }
34938 arg1 = reinterpret_cast< wxWindow * >(argp1);
34939 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34940 if (!SWIG_IsOK(res2)) {
34941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34942 }
34943 if (!argp2) {
34944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34945 }
34946 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34947 {
34948 PyThreadState* __tstate = wxPyBeginAllowThreads();
34949 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34950 wxPyEndAllowThreads(__tstate);
34951 if (PyErr_Occurred()) SWIG_fail;
34952 }
34953 resultobj = SWIG_Py_Void();
34954 return resultobj;
34955 fail:
34956 return NULL;
34957 }
34958
34959
34960 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34961 PyObject *resultobj = 0;
34962 wxWindow *arg1 = (wxWindow *) 0 ;
34963 wxAcceleratorTable *result = 0 ;
34964 void *argp1 = 0 ;
34965 int res1 = 0 ;
34966 PyObject *swig_obj[1] ;
34967
34968 if (!args) SWIG_fail;
34969 swig_obj[0] = args;
34970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34971 if (!SWIG_IsOK(res1)) {
34972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34973 }
34974 arg1 = reinterpret_cast< wxWindow * >(argp1);
34975 {
34976 PyThreadState* __tstate = wxPyBeginAllowThreads();
34977 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34978 wxPyEndAllowThreads(__tstate);
34979 if (PyErr_Occurred()) SWIG_fail;
34980 }
34981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34982 return resultobj;
34983 fail:
34984 return NULL;
34985 }
34986
34987
34988 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34989 PyObject *resultobj = 0;
34990 wxWindow *arg1 = (wxWindow *) 0 ;
34991 int arg2 ;
34992 int arg3 ;
34993 int arg4 ;
34994 bool result;
34995 void *argp1 = 0 ;
34996 int res1 = 0 ;
34997 int val2 ;
34998 int ecode2 = 0 ;
34999 int val3 ;
35000 int ecode3 = 0 ;
35001 int val4 ;
35002 int ecode4 = 0 ;
35003 PyObject * obj0 = 0 ;
35004 PyObject * obj1 = 0 ;
35005 PyObject * obj2 = 0 ;
35006 PyObject * obj3 = 0 ;
35007 char * kwnames[] = {
35008 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
35009 };
35010
35011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35013 if (!SWIG_IsOK(res1)) {
35014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35015 }
35016 arg1 = reinterpret_cast< wxWindow * >(argp1);
35017 ecode2 = SWIG_AsVal_int(obj1, &val2);
35018 if (!SWIG_IsOK(ecode2)) {
35019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35020 }
35021 arg2 = static_cast< int >(val2);
35022 ecode3 = SWIG_AsVal_int(obj2, &val3);
35023 if (!SWIG_IsOK(ecode3)) {
35024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35025 }
35026 arg3 = static_cast< int >(val3);
35027 ecode4 = SWIG_AsVal_int(obj3, &val4);
35028 if (!SWIG_IsOK(ecode4)) {
35029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35030 }
35031 arg4 = static_cast< int >(val4);
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35035 wxPyEndAllowThreads(__tstate);
35036 if (PyErr_Occurred()) SWIG_fail;
35037 }
35038 {
35039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35040 }
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35048 PyObject *resultobj = 0;
35049 wxWindow *arg1 = (wxWindow *) 0 ;
35050 int arg2 ;
35051 bool result;
35052 void *argp1 = 0 ;
35053 int res1 = 0 ;
35054 int val2 ;
35055 int ecode2 = 0 ;
35056 PyObject * obj0 = 0 ;
35057 PyObject * obj1 = 0 ;
35058 char * kwnames[] = {
35059 (char *) "self",(char *) "hotkeyId", NULL
35060 };
35061
35062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35064 if (!SWIG_IsOK(res1)) {
35065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35066 }
35067 arg1 = reinterpret_cast< wxWindow * >(argp1);
35068 ecode2 = SWIG_AsVal_int(obj1, &val2);
35069 if (!SWIG_IsOK(ecode2)) {
35070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35071 }
35072 arg2 = static_cast< int >(val2);
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35076 wxPyEndAllowThreads(__tstate);
35077 if (PyErr_Occurred()) SWIG_fail;
35078 }
35079 {
35080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35081 }
35082 return resultobj;
35083 fail:
35084 return NULL;
35085 }
35086
35087
35088 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35089 PyObject *resultobj = 0;
35090 wxWindow *arg1 = (wxWindow *) 0 ;
35091 wxPoint *arg2 = 0 ;
35092 wxPoint result;
35093 void *argp1 = 0 ;
35094 int res1 = 0 ;
35095 wxPoint temp2 ;
35096 PyObject * obj0 = 0 ;
35097 PyObject * obj1 = 0 ;
35098 char * kwnames[] = {
35099 (char *) "self",(char *) "pt", NULL
35100 };
35101
35102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35104 if (!SWIG_IsOK(res1)) {
35105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35106 }
35107 arg1 = reinterpret_cast< wxWindow * >(argp1);
35108 {
35109 arg2 = &temp2;
35110 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35111 }
35112 {
35113 PyThreadState* __tstate = wxPyBeginAllowThreads();
35114 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35115 wxPyEndAllowThreads(__tstate);
35116 if (PyErr_Occurred()) SWIG_fail;
35117 }
35118 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35119 return resultobj;
35120 fail:
35121 return NULL;
35122 }
35123
35124
35125 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35126 PyObject *resultobj = 0;
35127 wxWindow *arg1 = (wxWindow *) 0 ;
35128 wxSize *arg2 = 0 ;
35129 wxSize result;
35130 void *argp1 = 0 ;
35131 int res1 = 0 ;
35132 wxSize temp2 ;
35133 PyObject * obj0 = 0 ;
35134 PyObject * obj1 = 0 ;
35135 char * kwnames[] = {
35136 (char *) "self",(char *) "sz", NULL
35137 };
35138
35139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35141 if (!SWIG_IsOK(res1)) {
35142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35143 }
35144 arg1 = reinterpret_cast< wxWindow * >(argp1);
35145 {
35146 arg2 = &temp2;
35147 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35148 }
35149 {
35150 PyThreadState* __tstate = wxPyBeginAllowThreads();
35151 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35156 return resultobj;
35157 fail:
35158 return NULL;
35159 }
35160
35161
35162 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj = 0;
35164 wxWindow *arg1 = (wxWindow *) 0 ;
35165 wxPoint *arg2 = 0 ;
35166 wxPoint result;
35167 void *argp1 = 0 ;
35168 int res1 = 0 ;
35169 wxPoint temp2 ;
35170 PyObject * obj0 = 0 ;
35171 PyObject * obj1 = 0 ;
35172 char * kwnames[] = {
35173 (char *) "self",(char *) "pt", NULL
35174 };
35175
35176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35178 if (!SWIG_IsOK(res1)) {
35179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35180 }
35181 arg1 = reinterpret_cast< wxWindow * >(argp1);
35182 {
35183 arg2 = &temp2;
35184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35185 }
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxSize *arg2 = 0 ;
35203 wxSize result;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 wxSize temp2 ;
35207 PyObject * obj0 = 0 ;
35208 PyObject * obj1 = 0 ;
35209 char * kwnames[] = {
35210 (char *) "self",(char *) "sz", NULL
35211 };
35212
35213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35215 if (!SWIG_IsOK(res1)) {
35216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35217 }
35218 arg1 = reinterpret_cast< wxWindow * >(argp1);
35219 {
35220 arg2 = &temp2;
35221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35222 }
35223 {
35224 PyThreadState* __tstate = wxPyBeginAllowThreads();
35225 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35226 wxPyEndAllowThreads(__tstate);
35227 if (PyErr_Occurred()) SWIG_fail;
35228 }
35229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35230 return resultobj;
35231 fail:
35232 return NULL;
35233 }
35234
35235
35236 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35237 PyObject *resultobj = 0;
35238 wxWindow *arg1 = (wxWindow *) 0 ;
35239 wxPoint *arg2 = 0 ;
35240 wxPoint result;
35241 void *argp1 = 0 ;
35242 int res1 = 0 ;
35243 wxPoint temp2 ;
35244 PyObject * obj0 = 0 ;
35245 PyObject * obj1 = 0 ;
35246 char * kwnames[] = {
35247 (char *) "self",(char *) "pt", NULL
35248 };
35249
35250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35252 if (!SWIG_IsOK(res1)) {
35253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35254 }
35255 arg1 = reinterpret_cast< wxWindow * >(argp1);
35256 {
35257 arg2 = &temp2;
35258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35259 }
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35267 return resultobj;
35268 fail:
35269 return NULL;
35270 }
35271
35272
35273 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35274 PyObject *resultobj = 0;
35275 wxWindow *arg1 = (wxWindow *) 0 ;
35276 wxSize *arg2 = 0 ;
35277 wxSize result;
35278 void *argp1 = 0 ;
35279 int res1 = 0 ;
35280 wxSize temp2 ;
35281 PyObject * obj0 = 0 ;
35282 PyObject * obj1 = 0 ;
35283 char * kwnames[] = {
35284 (char *) "self",(char *) "sz", NULL
35285 };
35286
35287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35289 if (!SWIG_IsOK(res1)) {
35290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35291 }
35292 arg1 = reinterpret_cast< wxWindow * >(argp1);
35293 {
35294 arg2 = &temp2;
35295 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35296 }
35297 {
35298 PyThreadState* __tstate = wxPyBeginAllowThreads();
35299 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35300 wxPyEndAllowThreads(__tstate);
35301 if (PyErr_Occurred()) SWIG_fail;
35302 }
35303 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35304 return resultobj;
35305 fail:
35306 return NULL;
35307 }
35308
35309
35310 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35311 PyObject *resultobj = 0;
35312 wxWindow *arg1 = (wxWindow *) 0 ;
35313 int arg2 ;
35314 int arg3 ;
35315 void *argp1 = 0 ;
35316 int res1 = 0 ;
35317 int val2 ;
35318 int ecode2 = 0 ;
35319 int val3 ;
35320 int ecode3 = 0 ;
35321 PyObject * obj0 = 0 ;
35322 PyObject * obj1 = 0 ;
35323 PyObject * obj2 = 0 ;
35324 char * kwnames[] = {
35325 (char *) "self",(char *) "x",(char *) "y", NULL
35326 };
35327
35328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35330 if (!SWIG_IsOK(res1)) {
35331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35332 }
35333 arg1 = reinterpret_cast< wxWindow * >(argp1);
35334 ecode2 = SWIG_AsVal_int(obj1, &val2);
35335 if (!SWIG_IsOK(ecode2)) {
35336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35337 }
35338 arg2 = static_cast< int >(val2);
35339 ecode3 = SWIG_AsVal_int(obj2, &val3);
35340 if (!SWIG_IsOK(ecode3)) {
35341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35342 }
35343 arg3 = static_cast< int >(val3);
35344 {
35345 PyThreadState* __tstate = wxPyBeginAllowThreads();
35346 (arg1)->WarpPointer(arg2,arg3);
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 resultobj = SWIG_Py_Void();
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35358 PyObject *resultobj = 0;
35359 wxWindow *arg1 = (wxWindow *) 0 ;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 (arg1)->CaptureMouse();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_Py_Void();
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 void *argp1 = 0 ;
35388 int res1 = 0 ;
35389 PyObject *swig_obj[1] ;
35390
35391 if (!args) SWIG_fail;
35392 swig_obj[0] = args;
35393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35394 if (!SWIG_IsOK(res1)) {
35395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35396 }
35397 arg1 = reinterpret_cast< wxWindow * >(argp1);
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 (arg1)->ReleaseMouse();
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 resultobj = SWIG_Py_Void();
35405 return resultobj;
35406 fail:
35407 return NULL;
35408 }
35409
35410
35411 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35412 PyObject *resultobj = 0;
35413 wxWindow *result = 0 ;
35414
35415 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35416 {
35417 if (!wxPyCheckForApp()) SWIG_fail;
35418 PyThreadState* __tstate = wxPyBeginAllowThreads();
35419 result = (wxWindow *)wxWindow::GetCapture();
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 {
35424 resultobj = wxPyMake_wxObject(result, 0);
35425 }
35426 return resultobj;
35427 fail:
35428 return NULL;
35429 }
35430
35431
35432 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35433 PyObject *resultobj = 0;
35434 wxWindow *arg1 = (wxWindow *) 0 ;
35435 bool result;
35436 void *argp1 = 0 ;
35437 int res1 = 0 ;
35438 PyObject *swig_obj[1] ;
35439
35440 if (!args) SWIG_fail;
35441 swig_obj[0] = args;
35442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35445 }
35446 arg1 = reinterpret_cast< wxWindow * >(argp1);
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 result = (bool)((wxWindow const *)arg1)->HasCapture();
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 {
35454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35455 }
35456 return resultobj;
35457 fail:
35458 return NULL;
35459 }
35460
35461
35462 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35463 PyObject *resultobj = 0;
35464 wxWindow *arg1 = (wxWindow *) 0 ;
35465 bool arg2 = (bool) true ;
35466 wxRect *arg3 = (wxRect *) NULL ;
35467 void *argp1 = 0 ;
35468 int res1 = 0 ;
35469 bool val2 ;
35470 int ecode2 = 0 ;
35471 void *argp3 = 0 ;
35472 int res3 = 0 ;
35473 PyObject * obj0 = 0 ;
35474 PyObject * obj1 = 0 ;
35475 PyObject * obj2 = 0 ;
35476 char * kwnames[] = {
35477 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35478 };
35479
35480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35484 }
35485 arg1 = reinterpret_cast< wxWindow * >(argp1);
35486 if (obj1) {
35487 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35488 if (!SWIG_IsOK(ecode2)) {
35489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35490 }
35491 arg2 = static_cast< bool >(val2);
35492 }
35493 if (obj2) {
35494 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35495 if (!SWIG_IsOK(res3)) {
35496 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35497 }
35498 arg3 = reinterpret_cast< wxRect * >(argp3);
35499 }
35500 {
35501 PyThreadState* __tstate = wxPyBeginAllowThreads();
35502 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35503 wxPyEndAllowThreads(__tstate);
35504 if (PyErr_Occurred()) SWIG_fail;
35505 }
35506 resultobj = SWIG_Py_Void();
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35514 PyObject *resultobj = 0;
35515 wxWindow *arg1 = (wxWindow *) 0 ;
35516 wxRect *arg2 = 0 ;
35517 bool arg3 = (bool) true ;
35518 void *argp1 = 0 ;
35519 int res1 = 0 ;
35520 wxRect temp2 ;
35521 bool val3 ;
35522 int ecode3 = 0 ;
35523 PyObject * obj0 = 0 ;
35524 PyObject * obj1 = 0 ;
35525 PyObject * obj2 = 0 ;
35526 char * kwnames[] = {
35527 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35528 };
35529
35530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35532 if (!SWIG_IsOK(res1)) {
35533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35534 }
35535 arg1 = reinterpret_cast< wxWindow * >(argp1);
35536 {
35537 arg2 = &temp2;
35538 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35539 }
35540 if (obj2) {
35541 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35542 if (!SWIG_IsOK(ecode3)) {
35543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35544 }
35545 arg3 = static_cast< bool >(val3);
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35550 wxPyEndAllowThreads(__tstate);
35551 if (PyErr_Occurred()) SWIG_fail;
35552 }
35553 resultobj = SWIG_Py_Void();
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35561 PyObject *resultobj = 0;
35562 wxWindow *arg1 = (wxWindow *) 0 ;
35563 void *argp1 = 0 ;
35564 int res1 = 0 ;
35565 PyObject *swig_obj[1] ;
35566
35567 if (!args) SWIG_fail;
35568 swig_obj[0] = args;
35569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35570 if (!SWIG_IsOK(res1)) {
35571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35572 }
35573 arg1 = reinterpret_cast< wxWindow * >(argp1);
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->Update();
35577 wxPyEndAllowThreads(__tstate);
35578 if (PyErr_Occurred()) SWIG_fail;
35579 }
35580 resultobj = SWIG_Py_Void();
35581 return resultobj;
35582 fail:
35583 return NULL;
35584 }
35585
35586
35587 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35588 PyObject *resultobj = 0;
35589 wxWindow *arg1 = (wxWindow *) 0 ;
35590 void *argp1 = 0 ;
35591 int res1 = 0 ;
35592 PyObject *swig_obj[1] ;
35593
35594 if (!args) SWIG_fail;
35595 swig_obj[0] = args;
35596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35597 if (!SWIG_IsOK(res1)) {
35598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35599 }
35600 arg1 = reinterpret_cast< wxWindow * >(argp1);
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 (arg1)->ClearBackground();
35604 wxPyEndAllowThreads(__tstate);
35605 if (PyErr_Occurred()) SWIG_fail;
35606 }
35607 resultobj = SWIG_Py_Void();
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35615 PyObject *resultobj = 0;
35616 wxWindow *arg1 = (wxWindow *) 0 ;
35617 void *argp1 = 0 ;
35618 int res1 = 0 ;
35619 PyObject *swig_obj[1] ;
35620
35621 if (!args) SWIG_fail;
35622 swig_obj[0] = args;
35623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35624 if (!SWIG_IsOK(res1)) {
35625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35626 }
35627 arg1 = reinterpret_cast< wxWindow * >(argp1);
35628 {
35629 PyThreadState* __tstate = wxPyBeginAllowThreads();
35630 (arg1)->Freeze();
35631 wxPyEndAllowThreads(__tstate);
35632 if (PyErr_Occurred()) SWIG_fail;
35633 }
35634 resultobj = SWIG_Py_Void();
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35642 PyObject *resultobj = 0;
35643 wxWindow *arg1 = (wxWindow *) 0 ;
35644 bool result;
35645 void *argp1 = 0 ;
35646 int res1 = 0 ;
35647 PyObject *swig_obj[1] ;
35648
35649 if (!args) SWIG_fail;
35650 swig_obj[0] = args;
35651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35652 if (!SWIG_IsOK(res1)) {
35653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35654 }
35655 arg1 = reinterpret_cast< wxWindow * >(argp1);
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35659 wxPyEndAllowThreads(__tstate);
35660 if (PyErr_Occurred()) SWIG_fail;
35661 }
35662 {
35663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35664 }
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35672 PyObject *resultobj = 0;
35673 wxWindow *arg1 = (wxWindow *) 0 ;
35674 void *argp1 = 0 ;
35675 int res1 = 0 ;
35676 PyObject *swig_obj[1] ;
35677
35678 if (!args) SWIG_fail;
35679 swig_obj[0] = args;
35680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35681 if (!SWIG_IsOK(res1)) {
35682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35683 }
35684 arg1 = reinterpret_cast< wxWindow * >(argp1);
35685 {
35686 PyThreadState* __tstate = wxPyBeginAllowThreads();
35687 (arg1)->Thaw();
35688 wxPyEndAllowThreads(__tstate);
35689 if (PyErr_Occurred()) SWIG_fail;
35690 }
35691 resultobj = SWIG_Py_Void();
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35699 PyObject *resultobj = 0;
35700 wxWindow *arg1 = (wxWindow *) 0 ;
35701 wxDC *arg2 = 0 ;
35702 void *argp1 = 0 ;
35703 int res1 = 0 ;
35704 void *argp2 = 0 ;
35705 int res2 = 0 ;
35706 PyObject * obj0 = 0 ;
35707 PyObject * obj1 = 0 ;
35708 char * kwnames[] = {
35709 (char *) "self",(char *) "dc", NULL
35710 };
35711
35712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35714 if (!SWIG_IsOK(res1)) {
35715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35716 }
35717 arg1 = reinterpret_cast< wxWindow * >(argp1);
35718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35719 if (!SWIG_IsOK(res2)) {
35720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35721 }
35722 if (!argp2) {
35723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35724 }
35725 arg2 = reinterpret_cast< wxDC * >(argp2);
35726 {
35727 PyThreadState* __tstate = wxPyBeginAllowThreads();
35728 (arg1)->PrepareDC(*arg2);
35729 wxPyEndAllowThreads(__tstate);
35730 if (PyErr_Occurred()) SWIG_fail;
35731 }
35732 resultobj = SWIG_Py_Void();
35733 return resultobj;
35734 fail:
35735 return NULL;
35736 }
35737
35738
35739 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35740 PyObject *resultobj = 0;
35741 wxWindow *arg1 = (wxWindow *) 0 ;
35742 bool result;
35743 void *argp1 = 0 ;
35744 int res1 = 0 ;
35745 PyObject *swig_obj[1] ;
35746
35747 if (!args) SWIG_fail;
35748 swig_obj[0] = args;
35749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35750 if (!SWIG_IsOK(res1)) {
35751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35752 }
35753 arg1 = reinterpret_cast< wxWindow * >(argp1);
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *resultobj = 0;
35771 wxWindow *arg1 = (wxWindow *) 0 ;
35772 wxRegion *result = 0 ;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 PyObject *swig_obj[1] ;
35776
35777 if (!args) SWIG_fail;
35778 swig_obj[0] = args;
35779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35782 }
35783 arg1 = reinterpret_cast< wxWindow * >(argp1);
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 {
35787 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35788 result = (wxRegion *) &_result_ref;
35789 }
35790 wxPyEndAllowThreads(__tstate);
35791 if (PyErr_Occurred()) SWIG_fail;
35792 }
35793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 wxRect result;
35804 void *argp1 = 0 ;
35805 int res1 = 0 ;
35806 PyObject *swig_obj[1] ;
35807
35808 if (!args) SWIG_fail;
35809 swig_obj[0] = args;
35810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35811 if (!SWIG_IsOK(res1)) {
35812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35813 }
35814 arg1 = reinterpret_cast< wxWindow * >(argp1);
35815 {
35816 PyThreadState* __tstate = wxPyBeginAllowThreads();
35817 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35822 return resultobj;
35823 fail:
35824 return NULL;
35825 }
35826
35827
35828 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35829 PyObject *resultobj = 0;
35830 wxWindow *arg1 = (wxWindow *) 0 ;
35831 int arg2 ;
35832 int arg3 ;
35833 int arg4 = (int) 1 ;
35834 int arg5 = (int) 1 ;
35835 bool result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 int val2 ;
35839 int ecode2 = 0 ;
35840 int val3 ;
35841 int ecode3 = 0 ;
35842 int val4 ;
35843 int ecode4 = 0 ;
35844 int val5 ;
35845 int ecode5 = 0 ;
35846 PyObject * obj0 = 0 ;
35847 PyObject * obj1 = 0 ;
35848 PyObject * obj2 = 0 ;
35849 PyObject * obj3 = 0 ;
35850 PyObject * obj4 = 0 ;
35851 char * kwnames[] = {
35852 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35853 };
35854
35855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxWindow * >(argp1);
35861 ecode2 = SWIG_AsVal_int(obj1, &val2);
35862 if (!SWIG_IsOK(ecode2)) {
35863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35864 }
35865 arg2 = static_cast< int >(val2);
35866 ecode3 = SWIG_AsVal_int(obj2, &val3);
35867 if (!SWIG_IsOK(ecode3)) {
35868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35869 }
35870 arg3 = static_cast< int >(val3);
35871 if (obj3) {
35872 ecode4 = SWIG_AsVal_int(obj3, &val4);
35873 if (!SWIG_IsOK(ecode4)) {
35874 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35875 }
35876 arg4 = static_cast< int >(val4);
35877 }
35878 if (obj4) {
35879 ecode5 = SWIG_AsVal_int(obj4, &val5);
35880 if (!SWIG_IsOK(ecode5)) {
35881 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35882 }
35883 arg5 = static_cast< int >(val5);
35884 }
35885 {
35886 PyThreadState* __tstate = wxPyBeginAllowThreads();
35887 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 {
35892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35893 }
35894 return resultobj;
35895 fail:
35896 return NULL;
35897 }
35898
35899
35900 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35901 PyObject *resultobj = 0;
35902 wxWindow *arg1 = (wxWindow *) 0 ;
35903 wxPoint *arg2 = 0 ;
35904 bool result;
35905 void *argp1 = 0 ;
35906 int res1 = 0 ;
35907 wxPoint temp2 ;
35908 PyObject * obj0 = 0 ;
35909 PyObject * obj1 = 0 ;
35910 char * kwnames[] = {
35911 (char *) "self",(char *) "pt", NULL
35912 };
35913
35914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35916 if (!SWIG_IsOK(res1)) {
35917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35918 }
35919 arg1 = reinterpret_cast< wxWindow * >(argp1);
35920 {
35921 arg2 = &temp2;
35922 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35923 }
35924 {
35925 PyThreadState* __tstate = wxPyBeginAllowThreads();
35926 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35927 wxPyEndAllowThreads(__tstate);
35928 if (PyErr_Occurred()) SWIG_fail;
35929 }
35930 {
35931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35932 }
35933 return resultobj;
35934 fail:
35935 return NULL;
35936 }
35937
35938
35939 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35940 PyObject *resultobj = 0;
35941 wxWindow *arg1 = (wxWindow *) 0 ;
35942 wxRect *arg2 = 0 ;
35943 bool result;
35944 void *argp1 = 0 ;
35945 int res1 = 0 ;
35946 wxRect temp2 ;
35947 PyObject * obj0 = 0 ;
35948 PyObject * obj1 = 0 ;
35949 char * kwnames[] = {
35950 (char *) "self",(char *) "rect", NULL
35951 };
35952
35953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35955 if (!SWIG_IsOK(res1)) {
35956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35957 }
35958 arg1 = reinterpret_cast< wxWindow * >(argp1);
35959 {
35960 arg2 = &temp2;
35961 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35962 }
35963 {
35964 PyThreadState* __tstate = wxPyBeginAllowThreads();
35965 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35966 wxPyEndAllowThreads(__tstate);
35967 if (PyErr_Occurred()) SWIG_fail;
35968 }
35969 {
35970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35971 }
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 SwigValueWrapper<wxVisualAttributes > result;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 PyObject *swig_obj[1] ;
35985
35986 if (!args) SWIG_fail;
35987 swig_obj[0] = args;
35988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35989 if (!SWIG_IsOK(res1)) {
35990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35991 }
35992 arg1 = reinterpret_cast< wxWindow * >(argp1);
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35996 wxPyEndAllowThreads(__tstate);
35997 if (PyErr_Occurred()) SWIG_fail;
35998 }
35999 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36000 return resultobj;
36001 fail:
36002 return NULL;
36003 }
36004
36005
36006 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36007 PyObject *resultobj = 0;
36008 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36009 SwigValueWrapper<wxVisualAttributes > result;
36010 int val1 ;
36011 int ecode1 = 0 ;
36012 PyObject * obj0 = 0 ;
36013 char * kwnames[] = {
36014 (char *) "variant", NULL
36015 };
36016
36017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36018 if (obj0) {
36019 ecode1 = SWIG_AsVal_int(obj0, &val1);
36020 if (!SWIG_IsOK(ecode1)) {
36021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36022 }
36023 arg1 = static_cast< wxWindowVariant >(val1);
36024 }
36025 {
36026 if (!wxPyCheckForApp()) SWIG_fail;
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = wxWindow::GetClassDefaultAttributes(arg1);
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36033 return resultobj;
36034 fail:
36035 return NULL;
36036 }
36037
36038
36039 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36040 PyObject *resultobj = 0;
36041 wxWindow *arg1 = (wxWindow *) 0 ;
36042 wxColour *arg2 = 0 ;
36043 bool result;
36044 void *argp1 = 0 ;
36045 int res1 = 0 ;
36046 wxColour temp2 ;
36047 PyObject * obj0 = 0 ;
36048 PyObject * obj1 = 0 ;
36049 char * kwnames[] = {
36050 (char *) "self",(char *) "colour", NULL
36051 };
36052
36053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36055 if (!SWIG_IsOK(res1)) {
36056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36057 }
36058 arg1 = reinterpret_cast< wxWindow * >(argp1);
36059 {
36060 arg2 = &temp2;
36061 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36062 }
36063 {
36064 PyThreadState* __tstate = wxPyBeginAllowThreads();
36065 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36066 wxPyEndAllowThreads(__tstate);
36067 if (PyErr_Occurred()) SWIG_fail;
36068 }
36069 {
36070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36071 }
36072 return resultobj;
36073 fail:
36074 return NULL;
36075 }
36076
36077
36078 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36079 PyObject *resultobj = 0;
36080 wxWindow *arg1 = (wxWindow *) 0 ;
36081 wxColour *arg2 = 0 ;
36082 void *argp1 = 0 ;
36083 int res1 = 0 ;
36084 wxColour temp2 ;
36085 PyObject * obj0 = 0 ;
36086 PyObject * obj1 = 0 ;
36087 char * kwnames[] = {
36088 (char *) "self",(char *) "colour", NULL
36089 };
36090
36091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36093 if (!SWIG_IsOK(res1)) {
36094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36095 }
36096 arg1 = reinterpret_cast< wxWindow * >(argp1);
36097 {
36098 arg2 = &temp2;
36099 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36100 }
36101 {
36102 PyThreadState* __tstate = wxPyBeginAllowThreads();
36103 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36104 wxPyEndAllowThreads(__tstate);
36105 if (PyErr_Occurred()) SWIG_fail;
36106 }
36107 resultobj = SWIG_Py_Void();
36108 return resultobj;
36109 fail:
36110 return NULL;
36111 }
36112
36113
36114 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36115 PyObject *resultobj = 0;
36116 wxWindow *arg1 = (wxWindow *) 0 ;
36117 wxColour *arg2 = 0 ;
36118 bool result;
36119 void *argp1 = 0 ;
36120 int res1 = 0 ;
36121 wxColour temp2 ;
36122 PyObject * obj0 = 0 ;
36123 PyObject * obj1 = 0 ;
36124 char * kwnames[] = {
36125 (char *) "self",(char *) "colour", NULL
36126 };
36127
36128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36130 if (!SWIG_IsOK(res1)) {
36131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36132 }
36133 arg1 = reinterpret_cast< wxWindow * >(argp1);
36134 {
36135 arg2 = &temp2;
36136 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36137 }
36138 {
36139 PyThreadState* __tstate = wxPyBeginAllowThreads();
36140 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36141 wxPyEndAllowThreads(__tstate);
36142 if (PyErr_Occurred()) SWIG_fail;
36143 }
36144 {
36145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36146 }
36147 return resultobj;
36148 fail:
36149 return NULL;
36150 }
36151
36152
36153 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36154 PyObject *resultobj = 0;
36155 wxWindow *arg1 = (wxWindow *) 0 ;
36156 wxColour *arg2 = 0 ;
36157 void *argp1 = 0 ;
36158 int res1 = 0 ;
36159 wxColour temp2 ;
36160 PyObject * obj0 = 0 ;
36161 PyObject * obj1 = 0 ;
36162 char * kwnames[] = {
36163 (char *) "self",(char *) "colour", NULL
36164 };
36165
36166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36168 if (!SWIG_IsOK(res1)) {
36169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36170 }
36171 arg1 = reinterpret_cast< wxWindow * >(argp1);
36172 {
36173 arg2 = &temp2;
36174 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36175 }
36176 {
36177 PyThreadState* __tstate = wxPyBeginAllowThreads();
36178 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36179 wxPyEndAllowThreads(__tstate);
36180 if (PyErr_Occurred()) SWIG_fail;
36181 }
36182 resultobj = SWIG_Py_Void();
36183 return resultobj;
36184 fail:
36185 return NULL;
36186 }
36187
36188
36189 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36190 PyObject *resultobj = 0;
36191 wxWindow *arg1 = (wxWindow *) 0 ;
36192 wxColour result;
36193 void *argp1 = 0 ;
36194 int res1 = 0 ;
36195 PyObject *swig_obj[1] ;
36196
36197 if (!args) SWIG_fail;
36198 swig_obj[0] = args;
36199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36200 if (!SWIG_IsOK(res1)) {
36201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36202 }
36203 arg1 = reinterpret_cast< wxWindow * >(argp1);
36204 {
36205 PyThreadState* __tstate = wxPyBeginAllowThreads();
36206 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36218 PyObject *resultobj = 0;
36219 wxWindow *arg1 = (wxWindow *) 0 ;
36220 wxColour result;
36221 void *argp1 = 0 ;
36222 int res1 = 0 ;
36223 PyObject *swig_obj[1] ;
36224
36225 if (!args) SWIG_fail;
36226 swig_obj[0] = args;
36227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36228 if (!SWIG_IsOK(res1)) {
36229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36230 }
36231 arg1 = reinterpret_cast< wxWindow * >(argp1);
36232 {
36233 PyThreadState* __tstate = wxPyBeginAllowThreads();
36234 result = ((wxWindow const *)arg1)->GetForegroundColour();
36235 wxPyEndAllowThreads(__tstate);
36236 if (PyErr_Occurred()) SWIG_fail;
36237 }
36238 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36239 return resultobj;
36240 fail:
36241 return NULL;
36242 }
36243
36244
36245 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36246 PyObject *resultobj = 0;
36247 wxWindow *arg1 = (wxWindow *) 0 ;
36248 bool result;
36249 void *argp1 = 0 ;
36250 int res1 = 0 ;
36251 PyObject *swig_obj[1] ;
36252
36253 if (!args) SWIG_fail;
36254 swig_obj[0] = args;
36255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36256 if (!SWIG_IsOK(res1)) {
36257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36258 }
36259 arg1 = reinterpret_cast< wxWindow * >(argp1);
36260 {
36261 PyThreadState* __tstate = wxPyBeginAllowThreads();
36262 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36263 wxPyEndAllowThreads(__tstate);
36264 if (PyErr_Occurred()) SWIG_fail;
36265 }
36266 {
36267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36268 }
36269 return resultobj;
36270 fail:
36271 return NULL;
36272 }
36273
36274
36275 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36276 PyObject *resultobj = 0;
36277 wxWindow *arg1 = (wxWindow *) 0 ;
36278 bool result;
36279 void *argp1 = 0 ;
36280 int res1 = 0 ;
36281 PyObject *swig_obj[1] ;
36282
36283 if (!args) SWIG_fail;
36284 swig_obj[0] = args;
36285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36286 if (!SWIG_IsOK(res1)) {
36287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36288 }
36289 arg1 = reinterpret_cast< wxWindow * >(argp1);
36290 {
36291 PyThreadState* __tstate = wxPyBeginAllowThreads();
36292 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36293 wxPyEndAllowThreads(__tstate);
36294 if (PyErr_Occurred()) SWIG_fail;
36295 }
36296 {
36297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36298 }
36299 return resultobj;
36300 fail:
36301 return NULL;
36302 }
36303
36304
36305 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36306 PyObject *resultobj = 0;
36307 wxWindow *arg1 = (wxWindow *) 0 ;
36308 wxBackgroundStyle arg2 ;
36309 bool result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 int val2 ;
36313 int ecode2 = 0 ;
36314 PyObject * obj0 = 0 ;
36315 PyObject * obj1 = 0 ;
36316 char * kwnames[] = {
36317 (char *) "self",(char *) "style", NULL
36318 };
36319
36320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36322 if (!SWIG_IsOK(res1)) {
36323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36324 }
36325 arg1 = reinterpret_cast< wxWindow * >(argp1);
36326 ecode2 = SWIG_AsVal_int(obj1, &val2);
36327 if (!SWIG_IsOK(ecode2)) {
36328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36329 }
36330 arg2 = static_cast< wxBackgroundStyle >(val2);
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36334 wxPyEndAllowThreads(__tstate);
36335 if (PyErr_Occurred()) SWIG_fail;
36336 }
36337 {
36338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36339 }
36340 return resultobj;
36341 fail:
36342 return NULL;
36343 }
36344
36345
36346 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36347 PyObject *resultobj = 0;
36348 wxWindow *arg1 = (wxWindow *) 0 ;
36349 wxBackgroundStyle result;
36350 void *argp1 = 0 ;
36351 int res1 = 0 ;
36352 PyObject *swig_obj[1] ;
36353
36354 if (!args) SWIG_fail;
36355 swig_obj[0] = args;
36356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 resultobj = SWIG_From_int(static_cast< int >(result));
36368 return resultobj;
36369 fail:
36370 return NULL;
36371 }
36372
36373
36374 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36375 PyObject *resultobj = 0;
36376 wxWindow *arg1 = (wxWindow *) 0 ;
36377 bool result;
36378 void *argp1 = 0 ;
36379 int res1 = 0 ;
36380 PyObject *swig_obj[1] ;
36381
36382 if (!args) SWIG_fail;
36383 swig_obj[0] = args;
36384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36385 if (!SWIG_IsOK(res1)) {
36386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36387 }
36388 arg1 = reinterpret_cast< wxWindow * >(argp1);
36389 {
36390 PyThreadState* __tstate = wxPyBeginAllowThreads();
36391 result = (bool)(arg1)->HasTransparentBackground();
36392 wxPyEndAllowThreads(__tstate);
36393 if (PyErr_Occurred()) SWIG_fail;
36394 }
36395 {
36396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36397 }
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 wxCursor *arg2 = 0 ;
36408 bool result;
36409 void *argp1 = 0 ;
36410 int res1 = 0 ;
36411 void *argp2 = 0 ;
36412 int res2 = 0 ;
36413 PyObject * obj0 = 0 ;
36414 PyObject * obj1 = 0 ;
36415 char * kwnames[] = {
36416 (char *) "self",(char *) "cursor", NULL
36417 };
36418
36419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36421 if (!SWIG_IsOK(res1)) {
36422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36423 }
36424 arg1 = reinterpret_cast< wxWindow * >(argp1);
36425 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36426 if (!SWIG_IsOK(res2)) {
36427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36428 }
36429 if (!argp2) {
36430 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36431 }
36432 arg2 = reinterpret_cast< wxCursor * >(argp2);
36433 {
36434 PyThreadState* __tstate = wxPyBeginAllowThreads();
36435 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36436 wxPyEndAllowThreads(__tstate);
36437 if (PyErr_Occurred()) SWIG_fail;
36438 }
36439 {
36440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36441 }
36442 return resultobj;
36443 fail:
36444 return NULL;
36445 }
36446
36447
36448 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36449 PyObject *resultobj = 0;
36450 wxWindow *arg1 = (wxWindow *) 0 ;
36451 wxCursor result;
36452 void *argp1 = 0 ;
36453 int res1 = 0 ;
36454 PyObject *swig_obj[1] ;
36455
36456 if (!args) SWIG_fail;
36457 swig_obj[0] = args;
36458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36459 if (!SWIG_IsOK(res1)) {
36460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36461 }
36462 arg1 = reinterpret_cast< wxWindow * >(argp1);
36463 {
36464 PyThreadState* __tstate = wxPyBeginAllowThreads();
36465 result = (arg1)->GetCursor();
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36470 return resultobj;
36471 fail:
36472 return NULL;
36473 }
36474
36475
36476 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36477 PyObject *resultobj = 0;
36478 wxWindow *arg1 = (wxWindow *) 0 ;
36479 wxFont *arg2 = 0 ;
36480 bool result;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 void *argp2 = 0 ;
36484 int res2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "font", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36495 }
36496 arg1 = reinterpret_cast< wxWindow * >(argp1);
36497 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36498 if (!SWIG_IsOK(res2)) {
36499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36500 }
36501 if (!argp2) {
36502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36503 }
36504 arg2 = reinterpret_cast< wxFont * >(argp2);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 {
36512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36513 }
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj = 0;
36522 wxWindow *arg1 = (wxWindow *) 0 ;
36523 wxFont *arg2 = 0 ;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 void *argp2 = 0 ;
36527 int res2 = 0 ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "font", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36541 if (!SWIG_IsOK(res2)) {
36542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36543 }
36544 if (!argp2) {
36545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36546 }
36547 arg2 = reinterpret_cast< wxFont * >(argp2);
36548 {
36549 PyThreadState* __tstate = wxPyBeginAllowThreads();
36550 (arg1)->SetOwnFont((wxFont const &)*arg2);
36551 wxPyEndAllowThreads(__tstate);
36552 if (PyErr_Occurred()) SWIG_fail;
36553 }
36554 resultobj = SWIG_Py_Void();
36555 return resultobj;
36556 fail:
36557 return NULL;
36558 }
36559
36560
36561 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36562 PyObject *resultobj = 0;
36563 wxWindow *arg1 = (wxWindow *) 0 ;
36564 wxFont result;
36565 void *argp1 = 0 ;
36566 int res1 = 0 ;
36567 PyObject *swig_obj[1] ;
36568
36569 if (!args) SWIG_fail;
36570 swig_obj[0] = args;
36571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36572 if (!SWIG_IsOK(res1)) {
36573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36574 }
36575 arg1 = reinterpret_cast< wxWindow * >(argp1);
36576 {
36577 PyThreadState* __tstate = wxPyBeginAllowThreads();
36578 result = (arg1)->GetFont();
36579 wxPyEndAllowThreads(__tstate);
36580 if (PyErr_Occurred()) SWIG_fail;
36581 }
36582 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36583 return resultobj;
36584 fail:
36585 return NULL;
36586 }
36587
36588
36589 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36590 PyObject *resultobj = 0;
36591 wxWindow *arg1 = (wxWindow *) 0 ;
36592 wxCaret *arg2 = (wxCaret *) 0 ;
36593 void *argp1 = 0 ;
36594 int res1 = 0 ;
36595 int res2 = 0 ;
36596 PyObject * obj0 = 0 ;
36597 PyObject * obj1 = 0 ;
36598 char * kwnames[] = {
36599 (char *) "self",(char *) "caret", NULL
36600 };
36601
36602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36604 if (!SWIG_IsOK(res1)) {
36605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36606 }
36607 arg1 = reinterpret_cast< wxWindow * >(argp1);
36608 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36609 if (!SWIG_IsOK(res2)) {
36610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36611 }
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 (arg1)->SetCaret(arg2);
36615 wxPyEndAllowThreads(__tstate);
36616 if (PyErr_Occurred()) SWIG_fail;
36617 }
36618 resultobj = SWIG_Py_Void();
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36626 PyObject *resultobj = 0;
36627 wxWindow *arg1 = (wxWindow *) 0 ;
36628 wxCaret *result = 0 ;
36629 void *argp1 = 0 ;
36630 int res1 = 0 ;
36631 PyObject *swig_obj[1] ;
36632
36633 if (!args) SWIG_fail;
36634 swig_obj[0] = args;
36635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36636 if (!SWIG_IsOK(res1)) {
36637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36638 }
36639 arg1 = reinterpret_cast< wxWindow * >(argp1);
36640 {
36641 PyThreadState* __tstate = wxPyBeginAllowThreads();
36642 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36643 wxPyEndAllowThreads(__tstate);
36644 if (PyErr_Occurred()) SWIG_fail;
36645 }
36646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36647 return resultobj;
36648 fail:
36649 return NULL;
36650 }
36651
36652
36653 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36654 PyObject *resultobj = 0;
36655 wxWindow *arg1 = (wxWindow *) 0 ;
36656 int result;
36657 void *argp1 = 0 ;
36658 int res1 = 0 ;
36659 PyObject *swig_obj[1] ;
36660
36661 if (!args) SWIG_fail;
36662 swig_obj[0] = args;
36663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36664 if (!SWIG_IsOK(res1)) {
36665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36666 }
36667 arg1 = reinterpret_cast< wxWindow * >(argp1);
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 resultobj = SWIG_From_int(static_cast< int >(result));
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36682 PyObject *resultobj = 0;
36683 wxWindow *arg1 = (wxWindow *) 0 ;
36684 int result;
36685 void *argp1 = 0 ;
36686 int res1 = 0 ;
36687 PyObject *swig_obj[1] ;
36688
36689 if (!args) SWIG_fail;
36690 swig_obj[0] = args;
36691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36692 if (!SWIG_IsOK(res1)) {
36693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36694 }
36695 arg1 = reinterpret_cast< wxWindow * >(argp1);
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 resultobj = SWIG_From_int(static_cast< int >(result));
36703 return resultobj;
36704 fail:
36705 return NULL;
36706 }
36707
36708
36709 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36710 PyObject *resultobj = 0;
36711 wxWindow *arg1 = (wxWindow *) 0 ;
36712 wxString *arg2 = 0 ;
36713 int *arg3 = (int *) 0 ;
36714 int *arg4 = (int *) 0 ;
36715 void *argp1 = 0 ;
36716 int res1 = 0 ;
36717 bool temp2 = false ;
36718 int temp3 ;
36719 int res3 = SWIG_TMPOBJ ;
36720 int temp4 ;
36721 int res4 = SWIG_TMPOBJ ;
36722 PyObject * obj0 = 0 ;
36723 PyObject * obj1 = 0 ;
36724 char * kwnames[] = {
36725 (char *) "self",(char *) "string", NULL
36726 };
36727
36728 arg3 = &temp3;
36729 arg4 = &temp4;
36730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36732 if (!SWIG_IsOK(res1)) {
36733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36734 }
36735 arg1 = reinterpret_cast< wxWindow * >(argp1);
36736 {
36737 arg2 = wxString_in_helper(obj1);
36738 if (arg2 == NULL) SWIG_fail;
36739 temp2 = true;
36740 }
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 resultobj = SWIG_Py_Void();
36748 if (SWIG_IsTmpObj(res3)) {
36749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36750 } else {
36751 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36753 }
36754 if (SWIG_IsTmpObj(res4)) {
36755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36756 } else {
36757 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36759 }
36760 {
36761 if (temp2)
36762 delete arg2;
36763 }
36764 return resultobj;
36765 fail:
36766 {
36767 if (temp2)
36768 delete arg2;
36769 }
36770 return NULL;
36771 }
36772
36773
36774 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36775 PyObject *resultobj = 0;
36776 wxWindow *arg1 = (wxWindow *) 0 ;
36777 wxString *arg2 = 0 ;
36778 int *arg3 = (int *) 0 ;
36779 int *arg4 = (int *) 0 ;
36780 int *arg5 = (int *) 0 ;
36781 int *arg6 = (int *) 0 ;
36782 wxFont *arg7 = (wxFont *) NULL ;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 bool temp2 = false ;
36786 int temp3 ;
36787 int res3 = SWIG_TMPOBJ ;
36788 int temp4 ;
36789 int res4 = SWIG_TMPOBJ ;
36790 int temp5 ;
36791 int res5 = SWIG_TMPOBJ ;
36792 int temp6 ;
36793 int res6 = SWIG_TMPOBJ ;
36794 void *argp7 = 0 ;
36795 int res7 = 0 ;
36796 PyObject * obj0 = 0 ;
36797 PyObject * obj1 = 0 ;
36798 PyObject * obj2 = 0 ;
36799 char * kwnames[] = {
36800 (char *) "self",(char *) "string",(char *) "font", NULL
36801 };
36802
36803 arg3 = &temp3;
36804 arg4 = &temp4;
36805 arg5 = &temp5;
36806 arg6 = &temp6;
36807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36809 if (!SWIG_IsOK(res1)) {
36810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36811 }
36812 arg1 = reinterpret_cast< wxWindow * >(argp1);
36813 {
36814 arg2 = wxString_in_helper(obj1);
36815 if (arg2 == NULL) SWIG_fail;
36816 temp2 = true;
36817 }
36818 if (obj2) {
36819 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36820 if (!SWIG_IsOK(res7)) {
36821 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36822 }
36823 arg7 = reinterpret_cast< wxFont * >(argp7);
36824 }
36825 {
36826 PyThreadState* __tstate = wxPyBeginAllowThreads();
36827 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36828 wxPyEndAllowThreads(__tstate);
36829 if (PyErr_Occurred()) SWIG_fail;
36830 }
36831 resultobj = SWIG_Py_Void();
36832 if (SWIG_IsTmpObj(res3)) {
36833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36834 } else {
36835 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36837 }
36838 if (SWIG_IsTmpObj(res4)) {
36839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36840 } else {
36841 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36843 }
36844 if (SWIG_IsTmpObj(res5)) {
36845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36846 } else {
36847 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36849 }
36850 if (SWIG_IsTmpObj(res6)) {
36851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36852 } else {
36853 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36855 }
36856 {
36857 if (temp2)
36858 delete arg2;
36859 }
36860 return resultobj;
36861 fail:
36862 {
36863 if (temp2)
36864 delete arg2;
36865 }
36866 return NULL;
36867 }
36868
36869
36870 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36871 PyObject *resultobj = 0;
36872 wxWindow *arg1 = (wxWindow *) 0 ;
36873 int *arg2 = (int *) 0 ;
36874 int *arg3 = (int *) 0 ;
36875 void *argp1 = 0 ;
36876 int res1 = 0 ;
36877 int temp2 ;
36878 int res2 = 0 ;
36879 int temp3 ;
36880 int res3 = 0 ;
36881 PyObject * obj0 = 0 ;
36882 PyObject * obj1 = 0 ;
36883 PyObject * obj2 = 0 ;
36884 char * kwnames[] = {
36885 (char *) "self",(char *) "x",(char *) "y", NULL
36886 };
36887
36888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36890 if (!SWIG_IsOK(res1)) {
36891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36892 }
36893 arg1 = reinterpret_cast< wxWindow * >(argp1);
36894 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36895 int val;
36896 int ecode = SWIG_AsVal_int(obj1, &val);
36897 if (!SWIG_IsOK(ecode)) {
36898 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36899 }
36900 temp2 = static_cast< int >(val);
36901 arg2 = &temp2;
36902 res2 = SWIG_AddTmpMask(ecode);
36903 }
36904 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36905 int val;
36906 int ecode = SWIG_AsVal_int(obj2, &val);
36907 if (!SWIG_IsOK(ecode)) {
36908 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36909 }
36910 temp3 = static_cast< int >(val);
36911 arg3 = &temp3;
36912 res3 = SWIG_AddTmpMask(ecode);
36913 }
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 resultobj = SWIG_Py_Void();
36921 if (SWIG_IsTmpObj(res2)) {
36922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36923 } else {
36924 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36926 }
36927 if (SWIG_IsTmpObj(res3)) {
36928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36929 } else {
36930 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36932 }
36933 return resultobj;
36934 fail:
36935 return NULL;
36936 }
36937
36938
36939 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36940 PyObject *resultobj = 0;
36941 wxWindow *arg1 = (wxWindow *) 0 ;
36942 int *arg2 = (int *) 0 ;
36943 int *arg3 = (int *) 0 ;
36944 void *argp1 = 0 ;
36945 int res1 = 0 ;
36946 int temp2 ;
36947 int res2 = 0 ;
36948 int temp3 ;
36949 int res3 = 0 ;
36950 PyObject * obj0 = 0 ;
36951 PyObject * obj1 = 0 ;
36952 PyObject * obj2 = 0 ;
36953 char * kwnames[] = {
36954 (char *) "self",(char *) "x",(char *) "y", NULL
36955 };
36956
36957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36959 if (!SWIG_IsOK(res1)) {
36960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36961 }
36962 arg1 = reinterpret_cast< wxWindow * >(argp1);
36963 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36964 int val;
36965 int ecode = SWIG_AsVal_int(obj1, &val);
36966 if (!SWIG_IsOK(ecode)) {
36967 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36968 }
36969 temp2 = static_cast< int >(val);
36970 arg2 = &temp2;
36971 res2 = SWIG_AddTmpMask(ecode);
36972 }
36973 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36974 int val;
36975 int ecode = SWIG_AsVal_int(obj2, &val);
36976 if (!SWIG_IsOK(ecode)) {
36977 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36978 }
36979 temp3 = static_cast< int >(val);
36980 arg3 = &temp3;
36981 res3 = SWIG_AddTmpMask(ecode);
36982 }
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36986 wxPyEndAllowThreads(__tstate);
36987 if (PyErr_Occurred()) SWIG_fail;
36988 }
36989 resultobj = SWIG_Py_Void();
36990 if (SWIG_IsTmpObj(res2)) {
36991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36992 } else {
36993 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36995 }
36996 if (SWIG_IsTmpObj(res3)) {
36997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36998 } else {
36999 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
37000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
37001 }
37002 return resultobj;
37003 fail:
37004 return NULL;
37005 }
37006
37007
37008 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37009 PyObject *resultobj = 0;
37010 wxWindow *arg1 = (wxWindow *) 0 ;
37011 wxPoint *arg2 = 0 ;
37012 wxPoint result;
37013 void *argp1 = 0 ;
37014 int res1 = 0 ;
37015 wxPoint temp2 ;
37016 PyObject * obj0 = 0 ;
37017 PyObject * obj1 = 0 ;
37018 char * kwnames[] = {
37019 (char *) "self",(char *) "pt", NULL
37020 };
37021
37022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37024 if (!SWIG_IsOK(res1)) {
37025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37026 }
37027 arg1 = reinterpret_cast< wxWindow * >(argp1);
37028 {
37029 arg2 = &temp2;
37030 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37031 }
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37039 return resultobj;
37040 fail:
37041 return NULL;
37042 }
37043
37044
37045 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37046 PyObject *resultobj = 0;
37047 wxWindow *arg1 = (wxWindow *) 0 ;
37048 wxPoint *arg2 = 0 ;
37049 wxPoint result;
37050 void *argp1 = 0 ;
37051 int res1 = 0 ;
37052 wxPoint temp2 ;
37053 PyObject * obj0 = 0 ;
37054 PyObject * obj1 = 0 ;
37055 char * kwnames[] = {
37056 (char *) "self",(char *) "pt", NULL
37057 };
37058
37059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37061 if (!SWIG_IsOK(res1)) {
37062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37063 }
37064 arg1 = reinterpret_cast< wxWindow * >(argp1);
37065 {
37066 arg2 = &temp2;
37067 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37068 }
37069 {
37070 PyThreadState* __tstate = wxPyBeginAllowThreads();
37071 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37083 PyObject *resultobj = 0;
37084 wxWindow *arg1 = (wxWindow *) 0 ;
37085 int arg2 ;
37086 int arg3 ;
37087 wxHitTest result;
37088 void *argp1 = 0 ;
37089 int res1 = 0 ;
37090 int val2 ;
37091 int ecode2 = 0 ;
37092 int val3 ;
37093 int ecode3 = 0 ;
37094 PyObject * obj0 = 0 ;
37095 PyObject * obj1 = 0 ;
37096 PyObject * obj2 = 0 ;
37097 char * kwnames[] = {
37098 (char *) "self",(char *) "x",(char *) "y", NULL
37099 };
37100
37101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37103 if (!SWIG_IsOK(res1)) {
37104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37105 }
37106 arg1 = reinterpret_cast< wxWindow * >(argp1);
37107 ecode2 = SWIG_AsVal_int(obj1, &val2);
37108 if (!SWIG_IsOK(ecode2)) {
37109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37110 }
37111 arg2 = static_cast< int >(val2);
37112 ecode3 = SWIG_AsVal_int(obj2, &val3);
37113 if (!SWIG_IsOK(ecode3)) {
37114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37115 }
37116 arg3 = static_cast< int >(val3);
37117 {
37118 PyThreadState* __tstate = wxPyBeginAllowThreads();
37119 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37120 wxPyEndAllowThreads(__tstate);
37121 if (PyErr_Occurred()) SWIG_fail;
37122 }
37123 resultobj = SWIG_From_int(static_cast< int >(result));
37124 return resultobj;
37125 fail:
37126 return NULL;
37127 }
37128
37129
37130 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37131 PyObject *resultobj = 0;
37132 wxWindow *arg1 = (wxWindow *) 0 ;
37133 wxPoint *arg2 = 0 ;
37134 wxHitTest result;
37135 void *argp1 = 0 ;
37136 int res1 = 0 ;
37137 wxPoint temp2 ;
37138 PyObject * obj0 = 0 ;
37139 PyObject * obj1 = 0 ;
37140 char * kwnames[] = {
37141 (char *) "self",(char *) "pt", NULL
37142 };
37143
37144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37146 if (!SWIG_IsOK(res1)) {
37147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37148 }
37149 arg1 = reinterpret_cast< wxWindow * >(argp1);
37150 {
37151 arg2 = &temp2;
37152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37153 }
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 resultobj = SWIG_From_int(static_cast< int >(result));
37161 return resultobj;
37162 fail:
37163 return NULL;
37164 }
37165
37166
37167 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37168 PyObject *resultobj = 0;
37169 wxWindow *arg1 = (wxWindow *) 0 ;
37170 long arg2 ;
37171 wxBorder result;
37172 void *argp1 = 0 ;
37173 int res1 = 0 ;
37174 long val2 ;
37175 int ecode2 = 0 ;
37176
37177 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37181 }
37182 arg1 = reinterpret_cast< wxWindow * >(argp1);
37183 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37184 if (!SWIG_IsOK(ecode2)) {
37185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37186 }
37187 arg2 = static_cast< long >(val2);
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 resultobj = SWIG_From_int(static_cast< int >(result));
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 wxBorder result;
37205 void *argp1 = 0 ;
37206 int res1 = 0 ;
37207
37208 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37210 if (!SWIG_IsOK(res1)) {
37211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37212 }
37213 arg1 = reinterpret_cast< wxWindow * >(argp1);
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37217 wxPyEndAllowThreads(__tstate);
37218 if (PyErr_Occurred()) SWIG_fail;
37219 }
37220 resultobj = SWIG_From_int(static_cast< int >(result));
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37228 int argc;
37229 PyObject *argv[3];
37230
37231 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37232 --argc;
37233 if (argc == 1) {
37234 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37235 }
37236 if (argc == 2) {
37237 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37238 }
37239
37240 fail:
37241 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 long arg2 = (long) wxUPDATE_UI_NONE ;
37250 void *argp1 = 0 ;
37251 int res1 = 0 ;
37252 long val2 ;
37253 int ecode2 = 0 ;
37254 PyObject * obj0 = 0 ;
37255 PyObject * obj1 = 0 ;
37256 char * kwnames[] = {
37257 (char *) "self",(char *) "flags", NULL
37258 };
37259
37260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37264 }
37265 arg1 = reinterpret_cast< wxWindow * >(argp1);
37266 if (obj1) {
37267 ecode2 = SWIG_AsVal_long(obj1, &val2);
37268 if (!SWIG_IsOK(ecode2)) {
37269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37270 }
37271 arg2 = static_cast< long >(val2);
37272 }
37273 {
37274 PyThreadState* __tstate = wxPyBeginAllowThreads();
37275 (arg1)->UpdateWindowUI(arg2);
37276 wxPyEndAllowThreads(__tstate);
37277 if (PyErr_Occurred()) SWIG_fail;
37278 }
37279 resultobj = SWIG_Py_Void();
37280 return resultobj;
37281 fail:
37282 return NULL;
37283 }
37284
37285
37286 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37287 PyObject *resultobj = 0;
37288 wxWindow *arg1 = (wxWindow *) 0 ;
37289 wxMenu *arg2 = (wxMenu *) 0 ;
37290 int arg3 = (int) -1 ;
37291 int arg4 = (int) -1 ;
37292 bool result;
37293 void *argp1 = 0 ;
37294 int res1 = 0 ;
37295 void *argp2 = 0 ;
37296 int res2 = 0 ;
37297 int val3 ;
37298 int ecode3 = 0 ;
37299 int val4 ;
37300 int ecode4 = 0 ;
37301 PyObject * obj0 = 0 ;
37302 PyObject * obj1 = 0 ;
37303 PyObject * obj2 = 0 ;
37304 PyObject * obj3 = 0 ;
37305 char * kwnames[] = {
37306 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37307 };
37308
37309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37311 if (!SWIG_IsOK(res1)) {
37312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37313 }
37314 arg1 = reinterpret_cast< wxWindow * >(argp1);
37315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37316 if (!SWIG_IsOK(res2)) {
37317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37318 }
37319 arg2 = reinterpret_cast< wxMenu * >(argp2);
37320 if (obj2) {
37321 ecode3 = SWIG_AsVal_int(obj2, &val3);
37322 if (!SWIG_IsOK(ecode3)) {
37323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37324 }
37325 arg3 = static_cast< int >(val3);
37326 }
37327 if (obj3) {
37328 ecode4 = SWIG_AsVal_int(obj3, &val4);
37329 if (!SWIG_IsOK(ecode4)) {
37330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37331 }
37332 arg4 = static_cast< int >(val4);
37333 }
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 {
37341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37342 }
37343 return resultobj;
37344 fail:
37345 return NULL;
37346 }
37347
37348
37349 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37350 PyObject *resultobj = 0;
37351 wxWindow *arg1 = (wxWindow *) 0 ;
37352 wxMenu *arg2 = (wxMenu *) 0 ;
37353 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37354 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37355 bool result;
37356 void *argp1 = 0 ;
37357 int res1 = 0 ;
37358 void *argp2 = 0 ;
37359 int res2 = 0 ;
37360 wxPoint temp3 ;
37361 PyObject * obj0 = 0 ;
37362 PyObject * obj1 = 0 ;
37363 PyObject * obj2 = 0 ;
37364 char * kwnames[] = {
37365 (char *) "self",(char *) "menu",(char *) "pos", NULL
37366 };
37367
37368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37370 if (!SWIG_IsOK(res1)) {
37371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37372 }
37373 arg1 = reinterpret_cast< wxWindow * >(argp1);
37374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37375 if (!SWIG_IsOK(res2)) {
37376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37377 }
37378 arg2 = reinterpret_cast< wxMenu * >(argp2);
37379 if (obj2) {
37380 {
37381 arg3 = &temp3;
37382 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37383 }
37384 }
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 {
37392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37393 }
37394 return resultobj;
37395 fail:
37396 return NULL;
37397 }
37398
37399
37400 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37401 PyObject *resultobj = 0;
37402 wxWindow *arg1 = (wxWindow *) 0 ;
37403 bool result;
37404 void *argp1 = 0 ;
37405 int res1 = 0 ;
37406 PyObject *swig_obj[1] ;
37407
37408 if (!args) SWIG_fail;
37409 swig_obj[0] = args;
37410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37411 if (!SWIG_IsOK(res1)) {
37412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37413 }
37414 arg1 = reinterpret_cast< wxWindow * >(argp1);
37415 {
37416 PyThreadState* __tstate = wxPyBeginAllowThreads();
37417 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 {
37422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37423 }
37424 return resultobj;
37425 fail:
37426 return NULL;
37427 }
37428
37429
37430 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37431 PyObject *resultobj = 0;
37432 wxWindow *arg1 = (wxWindow *) 0 ;
37433 long result;
37434 void *argp1 = 0 ;
37435 int res1 = 0 ;
37436 PyObject *swig_obj[1] ;
37437
37438 if (!args) SWIG_fail;
37439 swig_obj[0] = args;
37440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37441 if (!SWIG_IsOK(res1)) {
37442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37443 }
37444 arg1 = reinterpret_cast< wxWindow * >(argp1);
37445 {
37446 PyThreadState* __tstate = wxPyBeginAllowThreads();
37447 result = (long)wxWindow_GetHandle(arg1);
37448 wxPyEndAllowThreads(__tstate);
37449 if (PyErr_Occurred()) SWIG_fail;
37450 }
37451 resultobj = SWIG_From_long(static_cast< long >(result));
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37459 PyObject *resultobj = 0;
37460 wxWindow *arg1 = (wxWindow *) 0 ;
37461 long arg2 ;
37462 void *argp1 = 0 ;
37463 int res1 = 0 ;
37464 long val2 ;
37465 int ecode2 = 0 ;
37466 PyObject * obj0 = 0 ;
37467 PyObject * obj1 = 0 ;
37468 char * kwnames[] = {
37469 (char *) "self",(char *) "handle", NULL
37470 };
37471
37472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37474 if (!SWIG_IsOK(res1)) {
37475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37476 }
37477 arg1 = reinterpret_cast< wxWindow * >(argp1);
37478 ecode2 = SWIG_AsVal_long(obj1, &val2);
37479 if (!SWIG_IsOK(ecode2)) {
37480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37481 }
37482 arg2 = static_cast< long >(val2);
37483 {
37484 PyThreadState* __tstate = wxPyBeginAllowThreads();
37485 wxWindow_AssociateHandle(arg1,arg2);
37486 wxPyEndAllowThreads(__tstate);
37487 if (PyErr_Occurred()) SWIG_fail;
37488 }
37489 resultobj = SWIG_Py_Void();
37490 return resultobj;
37491 fail:
37492 return NULL;
37493 }
37494
37495
37496 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37497 PyObject *resultobj = 0;
37498 wxWindow *arg1 = (wxWindow *) 0 ;
37499 void *argp1 = 0 ;
37500 int res1 = 0 ;
37501 PyObject *swig_obj[1] ;
37502
37503 if (!args) SWIG_fail;
37504 swig_obj[0] = args;
37505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37506 if (!SWIG_IsOK(res1)) {
37507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37508 }
37509 arg1 = reinterpret_cast< wxWindow * >(argp1);
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 (arg1)->DissociateHandle();
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 resultobj = SWIG_Py_Void();
37517 return resultobj;
37518 fail:
37519 return NULL;
37520 }
37521
37522
37523 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37524 PyObject *resultobj = 0;
37525 wxWindow *arg1 = (wxWindow *) 0 ;
37526 int arg2 ;
37527 bool result;
37528 void *argp1 = 0 ;
37529 int res1 = 0 ;
37530 int val2 ;
37531 int ecode2 = 0 ;
37532 PyObject * obj0 = 0 ;
37533 PyObject * obj1 = 0 ;
37534 char * kwnames[] = {
37535 (char *) "self",(char *) "orient", NULL
37536 };
37537
37538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37540 if (!SWIG_IsOK(res1)) {
37541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37542 }
37543 arg1 = reinterpret_cast< wxWindow * >(argp1);
37544 ecode2 = SWIG_AsVal_int(obj1, &val2);
37545 if (!SWIG_IsOK(ecode2)) {
37546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37547 }
37548 arg2 = static_cast< int >(val2);
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 {
37556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37557 }
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37565 PyObject *resultobj = 0;
37566 wxWindow *arg1 = (wxWindow *) 0 ;
37567 int arg2 ;
37568 int arg3 ;
37569 int arg4 ;
37570 int arg5 ;
37571 bool arg6 = (bool) true ;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 int val2 ;
37575 int ecode2 = 0 ;
37576 int val3 ;
37577 int ecode3 = 0 ;
37578 int val4 ;
37579 int ecode4 = 0 ;
37580 int val5 ;
37581 int ecode5 = 0 ;
37582 bool val6 ;
37583 int ecode6 = 0 ;
37584 PyObject * obj0 = 0 ;
37585 PyObject * obj1 = 0 ;
37586 PyObject * obj2 = 0 ;
37587 PyObject * obj3 = 0 ;
37588 PyObject * obj4 = 0 ;
37589 PyObject * obj5 = 0 ;
37590 char * kwnames[] = {
37591 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37592 };
37593
37594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37596 if (!SWIG_IsOK(res1)) {
37597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37598 }
37599 arg1 = reinterpret_cast< wxWindow * >(argp1);
37600 ecode2 = SWIG_AsVal_int(obj1, &val2);
37601 if (!SWIG_IsOK(ecode2)) {
37602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37603 }
37604 arg2 = static_cast< int >(val2);
37605 ecode3 = SWIG_AsVal_int(obj2, &val3);
37606 if (!SWIG_IsOK(ecode3)) {
37607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37608 }
37609 arg3 = static_cast< int >(val3);
37610 ecode4 = SWIG_AsVal_int(obj3, &val4);
37611 if (!SWIG_IsOK(ecode4)) {
37612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37613 }
37614 arg4 = static_cast< int >(val4);
37615 ecode5 = SWIG_AsVal_int(obj4, &val5);
37616 if (!SWIG_IsOK(ecode5)) {
37617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37618 }
37619 arg5 = static_cast< int >(val5);
37620 if (obj5) {
37621 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37622 if (!SWIG_IsOK(ecode6)) {
37623 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37624 }
37625 arg6 = static_cast< bool >(val6);
37626 }
37627 {
37628 PyThreadState* __tstate = wxPyBeginAllowThreads();
37629 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37630 wxPyEndAllowThreads(__tstate);
37631 if (PyErr_Occurred()) SWIG_fail;
37632 }
37633 resultobj = SWIG_Py_Void();
37634 return resultobj;
37635 fail:
37636 return NULL;
37637 }
37638
37639
37640 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37641 PyObject *resultobj = 0;
37642 wxWindow *arg1 = (wxWindow *) 0 ;
37643 int arg2 ;
37644 int arg3 ;
37645 bool arg4 = (bool) true ;
37646 void *argp1 = 0 ;
37647 int res1 = 0 ;
37648 int val2 ;
37649 int ecode2 = 0 ;
37650 int val3 ;
37651 int ecode3 = 0 ;
37652 bool val4 ;
37653 int ecode4 = 0 ;
37654 PyObject * obj0 = 0 ;
37655 PyObject * obj1 = 0 ;
37656 PyObject * obj2 = 0 ;
37657 PyObject * obj3 = 0 ;
37658 char * kwnames[] = {
37659 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37660 };
37661
37662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37664 if (!SWIG_IsOK(res1)) {
37665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37666 }
37667 arg1 = reinterpret_cast< wxWindow * >(argp1);
37668 ecode2 = SWIG_AsVal_int(obj1, &val2);
37669 if (!SWIG_IsOK(ecode2)) {
37670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37671 }
37672 arg2 = static_cast< int >(val2);
37673 ecode3 = SWIG_AsVal_int(obj2, &val3);
37674 if (!SWIG_IsOK(ecode3)) {
37675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37676 }
37677 arg3 = static_cast< int >(val3);
37678 if (obj3) {
37679 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37680 if (!SWIG_IsOK(ecode4)) {
37681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37682 }
37683 arg4 = static_cast< bool >(val4);
37684 }
37685 {
37686 PyThreadState* __tstate = wxPyBeginAllowThreads();
37687 (arg1)->SetScrollPos(arg2,arg3,arg4);
37688 wxPyEndAllowThreads(__tstate);
37689 if (PyErr_Occurred()) SWIG_fail;
37690 }
37691 resultobj = SWIG_Py_Void();
37692 return resultobj;
37693 fail:
37694 return NULL;
37695 }
37696
37697
37698 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37699 PyObject *resultobj = 0;
37700 wxWindow *arg1 = (wxWindow *) 0 ;
37701 int arg2 ;
37702 int result;
37703 void *argp1 = 0 ;
37704 int res1 = 0 ;
37705 int val2 ;
37706 int ecode2 = 0 ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 char * kwnames[] = {
37710 (char *) "self",(char *) "orientation", NULL
37711 };
37712
37713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37715 if (!SWIG_IsOK(res1)) {
37716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37717 }
37718 arg1 = reinterpret_cast< wxWindow * >(argp1);
37719 ecode2 = SWIG_AsVal_int(obj1, &val2);
37720 if (!SWIG_IsOK(ecode2)) {
37721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37722 }
37723 arg2 = static_cast< int >(val2);
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 resultobj = SWIG_From_int(static_cast< int >(result));
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj = 0;
37739 wxWindow *arg1 = (wxWindow *) 0 ;
37740 int arg2 ;
37741 int result;
37742 void *argp1 = 0 ;
37743 int res1 = 0 ;
37744 int val2 ;
37745 int ecode2 = 0 ;
37746 PyObject * obj0 = 0 ;
37747 PyObject * obj1 = 0 ;
37748 char * kwnames[] = {
37749 (char *) "self",(char *) "orientation", NULL
37750 };
37751
37752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37754 if (!SWIG_IsOK(res1)) {
37755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37756 }
37757 arg1 = reinterpret_cast< wxWindow * >(argp1);
37758 ecode2 = SWIG_AsVal_int(obj1, &val2);
37759 if (!SWIG_IsOK(ecode2)) {
37760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37761 }
37762 arg2 = static_cast< int >(val2);
37763 {
37764 PyThreadState* __tstate = wxPyBeginAllowThreads();
37765 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37766 wxPyEndAllowThreads(__tstate);
37767 if (PyErr_Occurred()) SWIG_fail;
37768 }
37769 resultobj = SWIG_From_int(static_cast< int >(result));
37770 return resultobj;
37771 fail:
37772 return NULL;
37773 }
37774
37775
37776 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37777 PyObject *resultobj = 0;
37778 wxWindow *arg1 = (wxWindow *) 0 ;
37779 int arg2 ;
37780 int result;
37781 void *argp1 = 0 ;
37782 int res1 = 0 ;
37783 int val2 ;
37784 int ecode2 = 0 ;
37785 PyObject * obj0 = 0 ;
37786 PyObject * obj1 = 0 ;
37787 char * kwnames[] = {
37788 (char *) "self",(char *) "orientation", NULL
37789 };
37790
37791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37793 if (!SWIG_IsOK(res1)) {
37794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37795 }
37796 arg1 = reinterpret_cast< wxWindow * >(argp1);
37797 ecode2 = SWIG_AsVal_int(obj1, &val2);
37798 if (!SWIG_IsOK(ecode2)) {
37799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37800 }
37801 arg2 = static_cast< int >(val2);
37802 {
37803 PyThreadState* __tstate = wxPyBeginAllowThreads();
37804 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 resultobj = SWIG_From_int(static_cast< int >(result));
37809 return resultobj;
37810 fail:
37811 return NULL;
37812 }
37813
37814
37815 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37816 PyObject *resultobj = 0;
37817 wxWindow *arg1 = (wxWindow *) 0 ;
37818 int arg2 ;
37819 int arg3 ;
37820 wxRect *arg4 = (wxRect *) NULL ;
37821 void *argp1 = 0 ;
37822 int res1 = 0 ;
37823 int val2 ;
37824 int ecode2 = 0 ;
37825 int val3 ;
37826 int ecode3 = 0 ;
37827 void *argp4 = 0 ;
37828 int res4 = 0 ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 PyObject * obj2 = 0 ;
37832 PyObject * obj3 = 0 ;
37833 char * kwnames[] = {
37834 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37835 };
37836
37837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37839 if (!SWIG_IsOK(res1)) {
37840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37841 }
37842 arg1 = reinterpret_cast< wxWindow * >(argp1);
37843 ecode2 = SWIG_AsVal_int(obj1, &val2);
37844 if (!SWIG_IsOK(ecode2)) {
37845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37846 }
37847 arg2 = static_cast< int >(val2);
37848 ecode3 = SWIG_AsVal_int(obj2, &val3);
37849 if (!SWIG_IsOK(ecode3)) {
37850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37851 }
37852 arg3 = static_cast< int >(val3);
37853 if (obj3) {
37854 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37855 if (!SWIG_IsOK(res4)) {
37856 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37857 }
37858 arg4 = reinterpret_cast< wxRect * >(argp4);
37859 }
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 resultobj = SWIG_Py_Void();
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37874 PyObject *resultobj = 0;
37875 wxWindow *arg1 = (wxWindow *) 0 ;
37876 int arg2 ;
37877 bool result;
37878 void *argp1 = 0 ;
37879 int res1 = 0 ;
37880 int val2 ;
37881 int ecode2 = 0 ;
37882 PyObject * obj0 = 0 ;
37883 PyObject * obj1 = 0 ;
37884 char * kwnames[] = {
37885 (char *) "self",(char *) "lines", NULL
37886 };
37887
37888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37890 if (!SWIG_IsOK(res1)) {
37891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37892 }
37893 arg1 = reinterpret_cast< wxWindow * >(argp1);
37894 ecode2 = SWIG_AsVal_int(obj1, &val2);
37895 if (!SWIG_IsOK(ecode2)) {
37896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37897 }
37898 arg2 = static_cast< int >(val2);
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = (bool)(arg1)->ScrollLines(arg2);
37902 wxPyEndAllowThreads(__tstate);
37903 if (PyErr_Occurred()) SWIG_fail;
37904 }
37905 {
37906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37907 }
37908 return resultobj;
37909 fail:
37910 return NULL;
37911 }
37912
37913
37914 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37915 PyObject *resultobj = 0;
37916 wxWindow *arg1 = (wxWindow *) 0 ;
37917 int arg2 ;
37918 bool result;
37919 void *argp1 = 0 ;
37920 int res1 = 0 ;
37921 int val2 ;
37922 int ecode2 = 0 ;
37923 PyObject * obj0 = 0 ;
37924 PyObject * obj1 = 0 ;
37925 char * kwnames[] = {
37926 (char *) "self",(char *) "pages", NULL
37927 };
37928
37929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37931 if (!SWIG_IsOK(res1)) {
37932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37933 }
37934 arg1 = reinterpret_cast< wxWindow * >(argp1);
37935 ecode2 = SWIG_AsVal_int(obj1, &val2);
37936 if (!SWIG_IsOK(ecode2)) {
37937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37938 }
37939 arg2 = static_cast< int >(val2);
37940 {
37941 PyThreadState* __tstate = wxPyBeginAllowThreads();
37942 result = (bool)(arg1)->ScrollPages(arg2);
37943 wxPyEndAllowThreads(__tstate);
37944 if (PyErr_Occurred()) SWIG_fail;
37945 }
37946 {
37947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37948 }
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37956 PyObject *resultobj = 0;
37957 wxWindow *arg1 = (wxWindow *) 0 ;
37958 bool result;
37959 void *argp1 = 0 ;
37960 int res1 = 0 ;
37961 PyObject *swig_obj[1] ;
37962
37963 if (!args) SWIG_fail;
37964 swig_obj[0] = args;
37965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37966 if (!SWIG_IsOK(res1)) {
37967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37968 }
37969 arg1 = reinterpret_cast< wxWindow * >(argp1);
37970 {
37971 PyThreadState* __tstate = wxPyBeginAllowThreads();
37972 result = (bool)(arg1)->LineUp();
37973 wxPyEndAllowThreads(__tstate);
37974 if (PyErr_Occurred()) SWIG_fail;
37975 }
37976 {
37977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37978 }
37979 return resultobj;
37980 fail:
37981 return NULL;
37982 }
37983
37984
37985 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37986 PyObject *resultobj = 0;
37987 wxWindow *arg1 = (wxWindow *) 0 ;
37988 bool result;
37989 void *argp1 = 0 ;
37990 int res1 = 0 ;
37991 PyObject *swig_obj[1] ;
37992
37993 if (!args) SWIG_fail;
37994 swig_obj[0] = args;
37995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37998 }
37999 arg1 = reinterpret_cast< wxWindow * >(argp1);
38000 {
38001 PyThreadState* __tstate = wxPyBeginAllowThreads();
38002 result = (bool)(arg1)->LineDown();
38003 wxPyEndAllowThreads(__tstate);
38004 if (PyErr_Occurred()) SWIG_fail;
38005 }
38006 {
38007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38008 }
38009 return resultobj;
38010 fail:
38011 return NULL;
38012 }
38013
38014
38015 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38016 PyObject *resultobj = 0;
38017 wxWindow *arg1 = (wxWindow *) 0 ;
38018 bool result;
38019 void *argp1 = 0 ;
38020 int res1 = 0 ;
38021 PyObject *swig_obj[1] ;
38022
38023 if (!args) SWIG_fail;
38024 swig_obj[0] = args;
38025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38026 if (!SWIG_IsOK(res1)) {
38027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38028 }
38029 arg1 = reinterpret_cast< wxWindow * >(argp1);
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (bool)(arg1)->PageUp();
38033 wxPyEndAllowThreads(__tstate);
38034 if (PyErr_Occurred()) SWIG_fail;
38035 }
38036 {
38037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38038 }
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38046 PyObject *resultobj = 0;
38047 wxWindow *arg1 = (wxWindow *) 0 ;
38048 bool result;
38049 void *argp1 = 0 ;
38050 int res1 = 0 ;
38051 PyObject *swig_obj[1] ;
38052
38053 if (!args) SWIG_fail;
38054 swig_obj[0] = args;
38055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38056 if (!SWIG_IsOK(res1)) {
38057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38058 }
38059 arg1 = reinterpret_cast< wxWindow * >(argp1);
38060 {
38061 PyThreadState* __tstate = wxPyBeginAllowThreads();
38062 result = (bool)(arg1)->PageDown();
38063 wxPyEndAllowThreads(__tstate);
38064 if (PyErr_Occurred()) SWIG_fail;
38065 }
38066 {
38067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38068 }
38069 return resultobj;
38070 fail:
38071 return NULL;
38072 }
38073
38074
38075 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38076 PyObject *resultobj = 0;
38077 wxWindow *arg1 = (wxWindow *) 0 ;
38078 wxString *arg2 = 0 ;
38079 void *argp1 = 0 ;
38080 int res1 = 0 ;
38081 bool temp2 = false ;
38082 PyObject * obj0 = 0 ;
38083 PyObject * obj1 = 0 ;
38084 char * kwnames[] = {
38085 (char *) "self",(char *) "text", NULL
38086 };
38087
38088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38090 if (!SWIG_IsOK(res1)) {
38091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38092 }
38093 arg1 = reinterpret_cast< wxWindow * >(argp1);
38094 {
38095 arg2 = wxString_in_helper(obj1);
38096 if (arg2 == NULL) SWIG_fail;
38097 temp2 = true;
38098 }
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 (arg1)->SetHelpText((wxString const &)*arg2);
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 resultobj = SWIG_Py_Void();
38106 {
38107 if (temp2)
38108 delete arg2;
38109 }
38110 return resultobj;
38111 fail:
38112 {
38113 if (temp2)
38114 delete arg2;
38115 }
38116 return NULL;
38117 }
38118
38119
38120 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38121 PyObject *resultobj = 0;
38122 wxWindow *arg1 = (wxWindow *) 0 ;
38123 wxString *arg2 = 0 ;
38124 void *argp1 = 0 ;
38125 int res1 = 0 ;
38126 bool temp2 = false ;
38127 PyObject * obj0 = 0 ;
38128 PyObject * obj1 = 0 ;
38129 char * kwnames[] = {
38130 (char *) "self",(char *) "text", NULL
38131 };
38132
38133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38135 if (!SWIG_IsOK(res1)) {
38136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38137 }
38138 arg1 = reinterpret_cast< wxWindow * >(argp1);
38139 {
38140 arg2 = wxString_in_helper(obj1);
38141 if (arg2 == NULL) SWIG_fail;
38142 temp2 = true;
38143 }
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38147 wxPyEndAllowThreads(__tstate);
38148 if (PyErr_Occurred()) SWIG_fail;
38149 }
38150 resultobj = SWIG_Py_Void();
38151 {
38152 if (temp2)
38153 delete arg2;
38154 }
38155 return resultobj;
38156 fail:
38157 {
38158 if (temp2)
38159 delete arg2;
38160 }
38161 return NULL;
38162 }
38163
38164
38165 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38166 PyObject *resultobj = 0;
38167 wxWindow *arg1 = (wxWindow *) 0 ;
38168 wxPoint *arg2 = 0 ;
38169 wxHelpEvent::Origin arg3 ;
38170 wxString result;
38171 void *argp1 = 0 ;
38172 int res1 = 0 ;
38173 wxPoint temp2 ;
38174 void *argp3 ;
38175 int res3 = 0 ;
38176 PyObject * obj0 = 0 ;
38177 PyObject * obj1 = 0 ;
38178 PyObject * obj2 = 0 ;
38179 char * kwnames[] = {
38180 (char *) "self",(char *) "pt",(char *) "origin", NULL
38181 };
38182
38183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38185 if (!SWIG_IsOK(res1)) {
38186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38187 }
38188 arg1 = reinterpret_cast< wxWindow * >(argp1);
38189 {
38190 arg2 = &temp2;
38191 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38192 }
38193 {
38194 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38195 if (!SWIG_IsOK(res3)) {
38196 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38197 }
38198 if (!argp3) {
38199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38200 } else {
38201 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38202 arg3 = *temp;
38203 if (SWIG_IsNewObj(res3)) delete temp;
38204 }
38205 }
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 {
38213 #if wxUSE_UNICODE
38214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38215 #else
38216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38217 #endif
38218 }
38219 return resultobj;
38220 fail:
38221 return NULL;
38222 }
38223
38224
38225 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38226 PyObject *resultobj = 0;
38227 wxWindow *arg1 = (wxWindow *) 0 ;
38228 wxString result;
38229 void *argp1 = 0 ;
38230 int res1 = 0 ;
38231 PyObject *swig_obj[1] ;
38232
38233 if (!args) SWIG_fail;
38234 swig_obj[0] = args;
38235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38238 }
38239 arg1 = reinterpret_cast< wxWindow * >(argp1);
38240 {
38241 PyThreadState* __tstate = wxPyBeginAllowThreads();
38242 result = ((wxWindow const *)arg1)->GetHelpText();
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 {
38247 #if wxUSE_UNICODE
38248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38249 #else
38250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38251 #endif
38252 }
38253 return resultobj;
38254 fail:
38255 return NULL;
38256 }
38257
38258
38259 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38260 PyObject *resultobj = 0;
38261 wxWindow *arg1 = (wxWindow *) 0 ;
38262 wxString *arg2 = 0 ;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 bool temp2 = false ;
38266 PyObject * obj0 = 0 ;
38267 PyObject * obj1 = 0 ;
38268 char * kwnames[] = {
38269 (char *) "self",(char *) "tip", NULL
38270 };
38271
38272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38274 if (!SWIG_IsOK(res1)) {
38275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38276 }
38277 arg1 = reinterpret_cast< wxWindow * >(argp1);
38278 {
38279 arg2 = wxString_in_helper(obj1);
38280 if (arg2 == NULL) SWIG_fail;
38281 temp2 = true;
38282 }
38283 {
38284 PyThreadState* __tstate = wxPyBeginAllowThreads();
38285 (arg1)->SetToolTip((wxString const &)*arg2);
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 resultobj = SWIG_Py_Void();
38290 {
38291 if (temp2)
38292 delete arg2;
38293 }
38294 return resultobj;
38295 fail:
38296 {
38297 if (temp2)
38298 delete arg2;
38299 }
38300 return NULL;
38301 }
38302
38303
38304 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38305 PyObject *resultobj = 0;
38306 wxWindow *arg1 = (wxWindow *) 0 ;
38307 wxToolTip *arg2 = (wxToolTip *) 0 ;
38308 void *argp1 = 0 ;
38309 int res1 = 0 ;
38310 int res2 = 0 ;
38311 PyObject * obj0 = 0 ;
38312 PyObject * obj1 = 0 ;
38313 char * kwnames[] = {
38314 (char *) "self",(char *) "tip", NULL
38315 };
38316
38317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38319 if (!SWIG_IsOK(res1)) {
38320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38321 }
38322 arg1 = reinterpret_cast< wxWindow * >(argp1);
38323 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38324 if (!SWIG_IsOK(res2)) {
38325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38326 }
38327 {
38328 PyThreadState* __tstate = wxPyBeginAllowThreads();
38329 (arg1)->SetToolTip(arg2);
38330 wxPyEndAllowThreads(__tstate);
38331 if (PyErr_Occurred()) SWIG_fail;
38332 }
38333 resultobj = SWIG_Py_Void();
38334 return resultobj;
38335 fail:
38336 return NULL;
38337 }
38338
38339
38340 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38341 PyObject *resultobj = 0;
38342 wxWindow *arg1 = (wxWindow *) 0 ;
38343 wxToolTip *result = 0 ;
38344 void *argp1 = 0 ;
38345 int res1 = 0 ;
38346 PyObject *swig_obj[1] ;
38347
38348 if (!args) SWIG_fail;
38349 swig_obj[0] = args;
38350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38351 if (!SWIG_IsOK(res1)) {
38352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38353 }
38354 arg1 = reinterpret_cast< wxWindow * >(argp1);
38355 {
38356 PyThreadState* __tstate = wxPyBeginAllowThreads();
38357 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38358 wxPyEndAllowThreads(__tstate);
38359 if (PyErr_Occurred()) SWIG_fail;
38360 }
38361 {
38362 resultobj = wxPyMake_wxObject(result, (bool)0);
38363 }
38364 return resultobj;
38365 fail:
38366 return NULL;
38367 }
38368
38369
38370 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38371 PyObject *resultobj = 0;
38372 wxWindow *arg1 = (wxWindow *) 0 ;
38373 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38374 void *argp1 = 0 ;
38375 int res1 = 0 ;
38376 int res2 = 0 ;
38377 PyObject * obj0 = 0 ;
38378 PyObject * obj1 = 0 ;
38379 char * kwnames[] = {
38380 (char *) "self",(char *) "dropTarget", NULL
38381 };
38382
38383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38385 if (!SWIG_IsOK(res1)) {
38386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38387 }
38388 arg1 = reinterpret_cast< wxWindow * >(argp1);
38389 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38390 if (!SWIG_IsOK(res2)) {
38391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38392 }
38393 {
38394 PyThreadState* __tstate = wxPyBeginAllowThreads();
38395 (arg1)->SetDropTarget(arg2);
38396 wxPyEndAllowThreads(__tstate);
38397 if (PyErr_Occurred()) SWIG_fail;
38398 }
38399 resultobj = SWIG_Py_Void();
38400 return resultobj;
38401 fail:
38402 return NULL;
38403 }
38404
38405
38406 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38407 PyObject *resultobj = 0;
38408 wxWindow *arg1 = (wxWindow *) 0 ;
38409 wxPyDropTarget *result = 0 ;
38410 void *argp1 = 0 ;
38411 int res1 = 0 ;
38412 PyObject *swig_obj[1] ;
38413
38414 if (!args) SWIG_fail;
38415 swig_obj[0] = args;
38416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38417 if (!SWIG_IsOK(res1)) {
38418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38419 }
38420 arg1 = reinterpret_cast< wxWindow * >(argp1);
38421 {
38422 PyThreadState* __tstate = wxPyBeginAllowThreads();
38423 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38424 wxPyEndAllowThreads(__tstate);
38425 if (PyErr_Occurred()) SWIG_fail;
38426 }
38427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38428 return resultobj;
38429 fail:
38430 return NULL;
38431 }
38432
38433
38434 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38435 PyObject *resultobj = 0;
38436 wxWindow *arg1 = (wxWindow *) 0 ;
38437 bool arg2 ;
38438 void *argp1 = 0 ;
38439 int res1 = 0 ;
38440 bool val2 ;
38441 int ecode2 = 0 ;
38442 PyObject * obj0 = 0 ;
38443 PyObject * obj1 = 0 ;
38444 char * kwnames[] = {
38445 (char *) "self",(char *) "accept", NULL
38446 };
38447
38448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38450 if (!SWIG_IsOK(res1)) {
38451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38452 }
38453 arg1 = reinterpret_cast< wxWindow * >(argp1);
38454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38455 if (!SWIG_IsOK(ecode2)) {
38456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38457 }
38458 arg2 = static_cast< bool >(val2);
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 wxWindow_DragAcceptFiles(arg1,arg2);
38462 wxPyEndAllowThreads(__tstate);
38463 if (PyErr_Occurred()) SWIG_fail;
38464 }
38465 resultobj = SWIG_Py_Void();
38466 return resultobj;
38467 fail:
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxWindow *arg1 = (wxWindow *) 0 ;
38475 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38476 void *argp1 = 0 ;
38477 int res1 = 0 ;
38478 int res2 = 0 ;
38479 PyObject * obj0 = 0 ;
38480 PyObject * obj1 = 0 ;
38481 char * kwnames[] = {
38482 (char *) "self",(char *) "constraints", NULL
38483 };
38484
38485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38487 if (!SWIG_IsOK(res1)) {
38488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38489 }
38490 arg1 = reinterpret_cast< wxWindow * >(argp1);
38491 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38492 if (!SWIG_IsOK(res2)) {
38493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38494 }
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 (arg1)->SetConstraints(arg2);
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 resultobj = SWIG_Py_Void();
38502 return resultobj;
38503 fail:
38504 return NULL;
38505 }
38506
38507
38508 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38509 PyObject *resultobj = 0;
38510 wxWindow *arg1 = (wxWindow *) 0 ;
38511 wxLayoutConstraints *result = 0 ;
38512 void *argp1 = 0 ;
38513 int res1 = 0 ;
38514 PyObject *swig_obj[1] ;
38515
38516 if (!args) SWIG_fail;
38517 swig_obj[0] = args;
38518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38519 if (!SWIG_IsOK(res1)) {
38520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38521 }
38522 arg1 = reinterpret_cast< wxWindow * >(argp1);
38523 {
38524 PyThreadState* __tstate = wxPyBeginAllowThreads();
38525 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38526 wxPyEndAllowThreads(__tstate);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 }
38529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38530 return resultobj;
38531 fail:
38532 return NULL;
38533 }
38534
38535
38536 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38537 PyObject *resultobj = 0;
38538 wxWindow *arg1 = (wxWindow *) 0 ;
38539 bool arg2 ;
38540 void *argp1 = 0 ;
38541 int res1 = 0 ;
38542 bool val2 ;
38543 int ecode2 = 0 ;
38544 PyObject * obj0 = 0 ;
38545 PyObject * obj1 = 0 ;
38546 char * kwnames[] = {
38547 (char *) "self",(char *) "autoLayout", NULL
38548 };
38549
38550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38552 if (!SWIG_IsOK(res1)) {
38553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38554 }
38555 arg1 = reinterpret_cast< wxWindow * >(argp1);
38556 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38557 if (!SWIG_IsOK(ecode2)) {
38558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38559 }
38560 arg2 = static_cast< bool >(val2);
38561 {
38562 PyThreadState* __tstate = wxPyBeginAllowThreads();
38563 (arg1)->SetAutoLayout(arg2);
38564 wxPyEndAllowThreads(__tstate);
38565 if (PyErr_Occurred()) SWIG_fail;
38566 }
38567 resultobj = SWIG_Py_Void();
38568 return resultobj;
38569 fail:
38570 return NULL;
38571 }
38572
38573
38574 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38575 PyObject *resultobj = 0;
38576 wxWindow *arg1 = (wxWindow *) 0 ;
38577 bool result;
38578 void *argp1 = 0 ;
38579 int res1 = 0 ;
38580 PyObject *swig_obj[1] ;
38581
38582 if (!args) SWIG_fail;
38583 swig_obj[0] = args;
38584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38585 if (!SWIG_IsOK(res1)) {
38586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38587 }
38588 arg1 = reinterpret_cast< wxWindow * >(argp1);
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38592 wxPyEndAllowThreads(__tstate);
38593 if (PyErr_Occurred()) SWIG_fail;
38594 }
38595 {
38596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38597 }
38598 return resultobj;
38599 fail:
38600 return NULL;
38601 }
38602
38603
38604 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38605 PyObject *resultobj = 0;
38606 wxWindow *arg1 = (wxWindow *) 0 ;
38607 bool result;
38608 void *argp1 = 0 ;
38609 int res1 = 0 ;
38610 PyObject *swig_obj[1] ;
38611
38612 if (!args) SWIG_fail;
38613 swig_obj[0] = args;
38614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38615 if (!SWIG_IsOK(res1)) {
38616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38617 }
38618 arg1 = reinterpret_cast< wxWindow * >(argp1);
38619 {
38620 PyThreadState* __tstate = wxPyBeginAllowThreads();
38621 result = (bool)(arg1)->Layout();
38622 wxPyEndAllowThreads(__tstate);
38623 if (PyErr_Occurred()) SWIG_fail;
38624 }
38625 {
38626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38627 }
38628 return resultobj;
38629 fail:
38630 return NULL;
38631 }
38632
38633
38634 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38635 PyObject *resultobj = 0;
38636 wxWindow *arg1 = (wxWindow *) 0 ;
38637 wxSizer *arg2 = (wxSizer *) 0 ;
38638 bool arg3 = (bool) true ;
38639 void *argp1 = 0 ;
38640 int res1 = 0 ;
38641 int res2 = 0 ;
38642 bool val3 ;
38643 int ecode3 = 0 ;
38644 PyObject * obj0 = 0 ;
38645 PyObject * obj1 = 0 ;
38646 PyObject * obj2 = 0 ;
38647 char * kwnames[] = {
38648 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38649 };
38650
38651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38653 if (!SWIG_IsOK(res1)) {
38654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38655 }
38656 arg1 = reinterpret_cast< wxWindow * >(argp1);
38657 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38658 if (!SWIG_IsOK(res2)) {
38659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38660 }
38661 if (obj2) {
38662 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38663 if (!SWIG_IsOK(ecode3)) {
38664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38665 }
38666 arg3 = static_cast< bool >(val3);
38667 }
38668 {
38669 PyThreadState* __tstate = wxPyBeginAllowThreads();
38670 (arg1)->SetSizer(arg2,arg3);
38671 wxPyEndAllowThreads(__tstate);
38672 if (PyErr_Occurred()) SWIG_fail;
38673 }
38674 resultobj = SWIG_Py_Void();
38675 return resultobj;
38676 fail:
38677 return NULL;
38678 }
38679
38680
38681 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38682 PyObject *resultobj = 0;
38683 wxWindow *arg1 = (wxWindow *) 0 ;
38684 wxSizer *arg2 = (wxSizer *) 0 ;
38685 bool arg3 = (bool) true ;
38686 void *argp1 = 0 ;
38687 int res1 = 0 ;
38688 int res2 = 0 ;
38689 bool val3 ;
38690 int ecode3 = 0 ;
38691 PyObject * obj0 = 0 ;
38692 PyObject * obj1 = 0 ;
38693 PyObject * obj2 = 0 ;
38694 char * kwnames[] = {
38695 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38696 };
38697
38698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38700 if (!SWIG_IsOK(res1)) {
38701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38702 }
38703 arg1 = reinterpret_cast< wxWindow * >(argp1);
38704 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38705 if (!SWIG_IsOK(res2)) {
38706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38707 }
38708 if (obj2) {
38709 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38710 if (!SWIG_IsOK(ecode3)) {
38711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38712 }
38713 arg3 = static_cast< bool >(val3);
38714 }
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 (arg1)->SetSizerAndFit(arg2,arg3);
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 resultobj = SWIG_Py_Void();
38722 return resultobj;
38723 fail:
38724 return NULL;
38725 }
38726
38727
38728 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38729 PyObject *resultobj = 0;
38730 wxWindow *arg1 = (wxWindow *) 0 ;
38731 wxSizer *result = 0 ;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 PyObject *swig_obj[1] ;
38735
38736 if (!args) SWIG_fail;
38737 swig_obj[0] = args;
38738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38739 if (!SWIG_IsOK(res1)) {
38740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38741 }
38742 arg1 = reinterpret_cast< wxWindow * >(argp1);
38743 {
38744 PyThreadState* __tstate = wxPyBeginAllowThreads();
38745 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38746 wxPyEndAllowThreads(__tstate);
38747 if (PyErr_Occurred()) SWIG_fail;
38748 }
38749 {
38750 resultobj = wxPyMake_wxObject(result, (bool)0);
38751 }
38752 return resultobj;
38753 fail:
38754 return NULL;
38755 }
38756
38757
38758 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38759 PyObject *resultobj = 0;
38760 wxWindow *arg1 = (wxWindow *) 0 ;
38761 wxSizer *arg2 = (wxSizer *) 0 ;
38762 void *argp1 = 0 ;
38763 int res1 = 0 ;
38764 void *argp2 = 0 ;
38765 int res2 = 0 ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 char * kwnames[] = {
38769 (char *) "self",(char *) "sizer", NULL
38770 };
38771
38772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38774 if (!SWIG_IsOK(res1)) {
38775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38776 }
38777 arg1 = reinterpret_cast< wxWindow * >(argp1);
38778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38779 if (!SWIG_IsOK(res2)) {
38780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38781 }
38782 arg2 = reinterpret_cast< wxSizer * >(argp2);
38783 {
38784 PyThreadState* __tstate = wxPyBeginAllowThreads();
38785 (arg1)->SetContainingSizer(arg2);
38786 wxPyEndAllowThreads(__tstate);
38787 if (PyErr_Occurred()) SWIG_fail;
38788 }
38789 resultobj = SWIG_Py_Void();
38790 return resultobj;
38791 fail:
38792 return NULL;
38793 }
38794
38795
38796 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38797 PyObject *resultobj = 0;
38798 wxWindow *arg1 = (wxWindow *) 0 ;
38799 wxSizer *result = 0 ;
38800 void *argp1 = 0 ;
38801 int res1 = 0 ;
38802 PyObject *swig_obj[1] ;
38803
38804 if (!args) SWIG_fail;
38805 swig_obj[0] = args;
38806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38807 if (!SWIG_IsOK(res1)) {
38808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38809 }
38810 arg1 = reinterpret_cast< wxWindow * >(argp1);
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38814 wxPyEndAllowThreads(__tstate);
38815 if (PyErr_Occurred()) SWIG_fail;
38816 }
38817 {
38818 resultobj = wxPyMake_wxObject(result, (bool)0);
38819 }
38820 return resultobj;
38821 fail:
38822 return NULL;
38823 }
38824
38825
38826 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38827 PyObject *resultobj = 0;
38828 wxWindow *arg1 = (wxWindow *) 0 ;
38829 void *argp1 = 0 ;
38830 int res1 = 0 ;
38831 PyObject *swig_obj[1] ;
38832
38833 if (!args) SWIG_fail;
38834 swig_obj[0] = args;
38835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38838 }
38839 arg1 = reinterpret_cast< wxWindow * >(argp1);
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 (arg1)->InheritAttributes();
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 resultobj = SWIG_Py_Void();
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38854 PyObject *resultobj = 0;
38855 wxWindow *arg1 = (wxWindow *) 0 ;
38856 bool result;
38857 void *argp1 = 0 ;
38858 int res1 = 0 ;
38859 PyObject *swig_obj[1] ;
38860
38861 if (!args) SWIG_fail;
38862 swig_obj[0] = args;
38863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38864 if (!SWIG_IsOK(res1)) {
38865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38866 }
38867 arg1 = reinterpret_cast< wxWindow * >(argp1);
38868 {
38869 PyThreadState* __tstate = wxPyBeginAllowThreads();
38870 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38871 wxPyEndAllowThreads(__tstate);
38872 if (PyErr_Occurred()) SWIG_fail;
38873 }
38874 {
38875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38876 }
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38884 PyObject *resultobj = 0;
38885 wxWindow *arg1 = (wxWindow *) 0 ;
38886 bool result;
38887 void *argp1 = 0 ;
38888 int res1 = 0 ;
38889 PyObject *swig_obj[1] ;
38890
38891 if (!args) SWIG_fail;
38892 swig_obj[0] = args;
38893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38894 if (!SWIG_IsOK(res1)) {
38895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38896 }
38897 arg1 = reinterpret_cast< wxWindow * >(argp1);
38898 {
38899 PyThreadState* __tstate = wxPyBeginAllowThreads();
38900 result = (bool)(arg1)->CanSetTransparent();
38901 wxPyEndAllowThreads(__tstate);
38902 if (PyErr_Occurred()) SWIG_fail;
38903 }
38904 {
38905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38906 }
38907 return resultobj;
38908 fail:
38909 return NULL;
38910 }
38911
38912
38913 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj = 0;
38915 wxWindow *arg1 = (wxWindow *) 0 ;
38916 byte arg2 ;
38917 bool result;
38918 void *argp1 = 0 ;
38919 int res1 = 0 ;
38920 unsigned char val2 ;
38921 int ecode2 = 0 ;
38922 PyObject * obj0 = 0 ;
38923 PyObject * obj1 = 0 ;
38924 char * kwnames[] = {
38925 (char *) "self",(char *) "alpha", NULL
38926 };
38927
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38932 }
38933 arg1 = reinterpret_cast< wxWindow * >(argp1);
38934 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38935 if (!SWIG_IsOK(ecode2)) {
38936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38937 }
38938 arg2 = static_cast< byte >(val2);
38939 {
38940 PyThreadState* __tstate = wxPyBeginAllowThreads();
38941 result = (bool)(arg1)->SetTransparent(arg2);
38942 wxPyEndAllowThreads(__tstate);
38943 if (PyErr_Occurred()) SWIG_fail;
38944 }
38945 {
38946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38947 }
38948 return resultobj;
38949 fail:
38950 return NULL;
38951 }
38952
38953
38954 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38955 PyObject *obj;
38956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38957 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38958 return SWIG_Py_Void();
38959 }
38960
38961 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38962 return SWIG_Python_InitShadowInstance(args);
38963 }
38964
38965 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38966 PyObject *resultobj = 0;
38967 long arg1 ;
38968 wxWindow *arg2 = (wxWindow *) NULL ;
38969 wxWindow *result = 0 ;
38970 long val1 ;
38971 int ecode1 = 0 ;
38972 void *argp2 = 0 ;
38973 int res2 = 0 ;
38974 PyObject * obj0 = 0 ;
38975 PyObject * obj1 = 0 ;
38976 char * kwnames[] = {
38977 (char *) "id",(char *) "parent", NULL
38978 };
38979
38980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38981 ecode1 = SWIG_AsVal_long(obj0, &val1);
38982 if (!SWIG_IsOK(ecode1)) {
38983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38984 }
38985 arg1 = static_cast< long >(val1);
38986 if (obj1) {
38987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38988 if (!SWIG_IsOK(res2)) {
38989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38990 }
38991 arg2 = reinterpret_cast< wxWindow * >(argp2);
38992 }
38993 {
38994 if (!wxPyCheckForApp()) SWIG_fail;
38995 PyThreadState* __tstate = wxPyBeginAllowThreads();
38996 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38997 wxPyEndAllowThreads(__tstate);
38998 if (PyErr_Occurred()) SWIG_fail;
38999 }
39000 {
39001 resultobj = wxPyMake_wxObject(result, 0);
39002 }
39003 return resultobj;
39004 fail:
39005 return NULL;
39006 }
39007
39008
39009 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39010 PyObject *resultobj = 0;
39011 wxString *arg1 = 0 ;
39012 wxWindow *arg2 = (wxWindow *) NULL ;
39013 wxWindow *result = 0 ;
39014 bool temp1 = false ;
39015 void *argp2 = 0 ;
39016 int res2 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 char * kwnames[] = {
39020 (char *) "name",(char *) "parent", NULL
39021 };
39022
39023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39024 {
39025 arg1 = wxString_in_helper(obj0);
39026 if (arg1 == NULL) SWIG_fail;
39027 temp1 = true;
39028 }
39029 if (obj1) {
39030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39031 if (!SWIG_IsOK(res2)) {
39032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39033 }
39034 arg2 = reinterpret_cast< wxWindow * >(argp2);
39035 }
39036 {
39037 if (!wxPyCheckForApp()) SWIG_fail;
39038 PyThreadState* __tstate = wxPyBeginAllowThreads();
39039 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39040 wxPyEndAllowThreads(__tstate);
39041 if (PyErr_Occurred()) SWIG_fail;
39042 }
39043 {
39044 resultobj = wxPyMake_wxObject(result, 0);
39045 }
39046 {
39047 if (temp1)
39048 delete arg1;
39049 }
39050 return resultobj;
39051 fail:
39052 {
39053 if (temp1)
39054 delete arg1;
39055 }
39056 return NULL;
39057 }
39058
39059
39060 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj = 0;
39062 wxString *arg1 = 0 ;
39063 wxWindow *arg2 = (wxWindow *) NULL ;
39064 wxWindow *result = 0 ;
39065 bool temp1 = false ;
39066 void *argp2 = 0 ;
39067 int res2 = 0 ;
39068 PyObject * obj0 = 0 ;
39069 PyObject * obj1 = 0 ;
39070 char * kwnames[] = {
39071 (char *) "label",(char *) "parent", NULL
39072 };
39073
39074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39075 {
39076 arg1 = wxString_in_helper(obj0);
39077 if (arg1 == NULL) SWIG_fail;
39078 temp1 = true;
39079 }
39080 if (obj1) {
39081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39082 if (!SWIG_IsOK(res2)) {
39083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39084 }
39085 arg2 = reinterpret_cast< wxWindow * >(argp2);
39086 }
39087 {
39088 if (!wxPyCheckForApp()) SWIG_fail;
39089 PyThreadState* __tstate = wxPyBeginAllowThreads();
39090 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39091 wxPyEndAllowThreads(__tstate);
39092 if (PyErr_Occurred()) SWIG_fail;
39093 }
39094 {
39095 resultobj = wxPyMake_wxObject(result, 0);
39096 }
39097 {
39098 if (temp1)
39099 delete arg1;
39100 }
39101 return resultobj;
39102 fail:
39103 {
39104 if (temp1)
39105 delete arg1;
39106 }
39107 return NULL;
39108 }
39109
39110
39111 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39112 PyObject *resultobj = 0;
39113 wxWindow *arg1 = (wxWindow *) 0 ;
39114 unsigned long arg2 ;
39115 wxWindow *result = 0 ;
39116 void *argp1 = 0 ;
39117 int res1 = 0 ;
39118 unsigned long val2 ;
39119 int ecode2 = 0 ;
39120 PyObject * obj0 = 0 ;
39121 PyObject * obj1 = 0 ;
39122 char * kwnames[] = {
39123 (char *) "parent",(char *) "_hWnd", NULL
39124 };
39125
39126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39128 if (!SWIG_IsOK(res1)) {
39129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39130 }
39131 arg1 = reinterpret_cast< wxWindow * >(argp1);
39132 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39133 if (!SWIG_IsOK(ecode2)) {
39134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39135 }
39136 arg2 = static_cast< unsigned long >(val2);
39137 {
39138 PyThreadState* __tstate = wxPyBeginAllowThreads();
39139 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39140 wxPyEndAllowThreads(__tstate);
39141 if (PyErr_Occurred()) SWIG_fail;
39142 }
39143 {
39144 resultobj = wxPyMake_wxObject(result, 0);
39145 }
39146 return resultobj;
39147 fail:
39148 return NULL;
39149 }
39150
39151
39152 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39153 PyObject *resultobj = 0;
39154 PyObject *result = 0 ;
39155
39156 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39157 {
39158 PyThreadState* __tstate = wxPyBeginAllowThreads();
39159 result = (PyObject *)GetTopLevelWindows();
39160 wxPyEndAllowThreads(__tstate);
39161 if (PyErr_Occurred()) SWIG_fail;
39162 }
39163 resultobj = result;
39164 return resultobj;
39165 fail:
39166 return NULL;
39167 }
39168
39169
39170 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39171 PyObject *resultobj = 0;
39172 wxValidator *result = 0 ;
39173
39174 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39175 {
39176 PyThreadState* __tstate = wxPyBeginAllowThreads();
39177 result = (wxValidator *)new wxValidator();
39178 wxPyEndAllowThreads(__tstate);
39179 if (PyErr_Occurred()) SWIG_fail;
39180 }
39181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39189 PyObject *resultobj = 0;
39190 wxValidator *arg1 = (wxValidator *) 0 ;
39191 wxValidator *result = 0 ;
39192 void *argp1 = 0 ;
39193 int res1 = 0 ;
39194 PyObject *swig_obj[1] ;
39195
39196 if (!args) SWIG_fail;
39197 swig_obj[0] = args;
39198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39199 if (!SWIG_IsOK(res1)) {
39200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39201 }
39202 arg1 = reinterpret_cast< wxValidator * >(argp1);
39203 {
39204 PyThreadState* __tstate = wxPyBeginAllowThreads();
39205 result = (wxValidator *)(arg1)->Clone();
39206 wxPyEndAllowThreads(__tstate);
39207 if (PyErr_Occurred()) SWIG_fail;
39208 }
39209 {
39210 resultobj = wxPyMake_wxObject(result, 0);
39211 }
39212 return resultobj;
39213 fail:
39214 return NULL;
39215 }
39216
39217
39218 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39219 PyObject *resultobj = 0;
39220 wxValidator *arg1 = (wxValidator *) 0 ;
39221 wxWindow *arg2 = (wxWindow *) 0 ;
39222 bool result;
39223 void *argp1 = 0 ;
39224 int res1 = 0 ;
39225 void *argp2 = 0 ;
39226 int res2 = 0 ;
39227 PyObject * obj0 = 0 ;
39228 PyObject * obj1 = 0 ;
39229 char * kwnames[] = {
39230 (char *) "self",(char *) "parent", NULL
39231 };
39232
39233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39235 if (!SWIG_IsOK(res1)) {
39236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39237 }
39238 arg1 = reinterpret_cast< wxValidator * >(argp1);
39239 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39240 if (!SWIG_IsOK(res2)) {
39241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39242 }
39243 arg2 = reinterpret_cast< wxWindow * >(argp2);
39244 {
39245 PyThreadState* __tstate = wxPyBeginAllowThreads();
39246 result = (bool)(arg1)->Validate(arg2);
39247 wxPyEndAllowThreads(__tstate);
39248 if (PyErr_Occurred()) SWIG_fail;
39249 }
39250 {
39251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39252 }
39253 return resultobj;
39254 fail:
39255 return NULL;
39256 }
39257
39258
39259 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39260 PyObject *resultobj = 0;
39261 wxValidator *arg1 = (wxValidator *) 0 ;
39262 bool result;
39263 void *argp1 = 0 ;
39264 int res1 = 0 ;
39265 PyObject *swig_obj[1] ;
39266
39267 if (!args) SWIG_fail;
39268 swig_obj[0] = args;
39269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39270 if (!SWIG_IsOK(res1)) {
39271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39272 }
39273 arg1 = reinterpret_cast< wxValidator * >(argp1);
39274 {
39275 PyThreadState* __tstate = wxPyBeginAllowThreads();
39276 result = (bool)(arg1)->TransferToWindow();
39277 wxPyEndAllowThreads(__tstate);
39278 if (PyErr_Occurred()) SWIG_fail;
39279 }
39280 {
39281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39282 }
39283 return resultobj;
39284 fail:
39285 return NULL;
39286 }
39287
39288
39289 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39290 PyObject *resultobj = 0;
39291 wxValidator *arg1 = (wxValidator *) 0 ;
39292 bool result;
39293 void *argp1 = 0 ;
39294 int res1 = 0 ;
39295 PyObject *swig_obj[1] ;
39296
39297 if (!args) SWIG_fail;
39298 swig_obj[0] = args;
39299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39300 if (!SWIG_IsOK(res1)) {
39301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39302 }
39303 arg1 = reinterpret_cast< wxValidator * >(argp1);
39304 {
39305 PyThreadState* __tstate = wxPyBeginAllowThreads();
39306 result = (bool)(arg1)->TransferFromWindow();
39307 wxPyEndAllowThreads(__tstate);
39308 if (PyErr_Occurred()) SWIG_fail;
39309 }
39310 {
39311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39312 }
39313 return resultobj;
39314 fail:
39315 return NULL;
39316 }
39317
39318
39319 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39320 PyObject *resultobj = 0;
39321 wxValidator *arg1 = (wxValidator *) 0 ;
39322 wxWindow *result = 0 ;
39323 void *argp1 = 0 ;
39324 int res1 = 0 ;
39325 PyObject *swig_obj[1] ;
39326
39327 if (!args) SWIG_fail;
39328 swig_obj[0] = args;
39329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39330 if (!SWIG_IsOK(res1)) {
39331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39332 }
39333 arg1 = reinterpret_cast< wxValidator * >(argp1);
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 result = (wxWindow *)(arg1)->GetWindow();
39337 wxPyEndAllowThreads(__tstate);
39338 if (PyErr_Occurred()) SWIG_fail;
39339 }
39340 {
39341 resultobj = wxPyMake_wxObject(result, 0);
39342 }
39343 return resultobj;
39344 fail:
39345 return NULL;
39346 }
39347
39348
39349 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39350 PyObject *resultobj = 0;
39351 wxValidator *arg1 = (wxValidator *) 0 ;
39352 wxWindow *arg2 = (wxWindow *) 0 ;
39353 void *argp1 = 0 ;
39354 int res1 = 0 ;
39355 void *argp2 = 0 ;
39356 int res2 = 0 ;
39357 PyObject * obj0 = 0 ;
39358 PyObject * obj1 = 0 ;
39359 char * kwnames[] = {
39360 (char *) "self",(char *) "window", NULL
39361 };
39362
39363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39365 if (!SWIG_IsOK(res1)) {
39366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39367 }
39368 arg1 = reinterpret_cast< wxValidator * >(argp1);
39369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39370 if (!SWIG_IsOK(res2)) {
39371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39372 }
39373 arg2 = reinterpret_cast< wxWindow * >(argp2);
39374 {
39375 PyThreadState* __tstate = wxPyBeginAllowThreads();
39376 (arg1)->SetWindow(arg2);
39377 wxPyEndAllowThreads(__tstate);
39378 if (PyErr_Occurred()) SWIG_fail;
39379 }
39380 resultobj = SWIG_Py_Void();
39381 return resultobj;
39382 fail:
39383 return NULL;
39384 }
39385
39386
39387 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39388 PyObject *resultobj = 0;
39389 bool result;
39390
39391 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39392 {
39393 PyThreadState* __tstate = wxPyBeginAllowThreads();
39394 result = (bool)wxValidator::IsSilent();
39395 wxPyEndAllowThreads(__tstate);
39396 if (PyErr_Occurred()) SWIG_fail;
39397 }
39398 {
39399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39400 }
39401 return resultobj;
39402 fail:
39403 return NULL;
39404 }
39405
39406
39407 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj = 0;
39409 int arg1 = (int) true ;
39410 int val1 ;
39411 int ecode1 = 0 ;
39412 PyObject * obj0 = 0 ;
39413 char * kwnames[] = {
39414 (char *) "doIt", NULL
39415 };
39416
39417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39418 if (obj0) {
39419 ecode1 = SWIG_AsVal_int(obj0, &val1);
39420 if (!SWIG_IsOK(ecode1)) {
39421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39422 }
39423 arg1 = static_cast< int >(val1);
39424 }
39425 {
39426 PyThreadState* __tstate = wxPyBeginAllowThreads();
39427 wxValidator::SetBellOnError(arg1);
39428 wxPyEndAllowThreads(__tstate);
39429 if (PyErr_Occurred()) SWIG_fail;
39430 }
39431 resultobj = SWIG_Py_Void();
39432 return resultobj;
39433 fail:
39434 return NULL;
39435 }
39436
39437
39438 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39439 PyObject *obj;
39440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39441 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39442 return SWIG_Py_Void();
39443 }
39444
39445 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39446 return SWIG_Python_InitShadowInstance(args);
39447 }
39448
39449 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39450 PyObject *resultobj = 0;
39451 wxPyValidator *result = 0 ;
39452
39453 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39454 {
39455 PyThreadState* __tstate = wxPyBeginAllowThreads();
39456 result = (wxPyValidator *)new wxPyValidator();
39457 wxPyEndAllowThreads(__tstate);
39458 if (PyErr_Occurred()) SWIG_fail;
39459 }
39460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39461 return resultobj;
39462 fail:
39463 return NULL;
39464 }
39465
39466
39467 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39468 PyObject *resultobj = 0;
39469 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39470 PyObject *arg2 = (PyObject *) 0 ;
39471 PyObject *arg3 = (PyObject *) 0 ;
39472 int arg4 = (int) true ;
39473 void *argp1 = 0 ;
39474 int res1 = 0 ;
39475 int val4 ;
39476 int ecode4 = 0 ;
39477 PyObject * obj0 = 0 ;
39478 PyObject * obj1 = 0 ;
39479 PyObject * obj2 = 0 ;
39480 PyObject * obj3 = 0 ;
39481 char * kwnames[] = {
39482 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39483 };
39484
39485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39487 if (!SWIG_IsOK(res1)) {
39488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39489 }
39490 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39491 arg2 = obj1;
39492 arg3 = obj2;
39493 if (obj3) {
39494 ecode4 = SWIG_AsVal_int(obj3, &val4);
39495 if (!SWIG_IsOK(ecode4)) {
39496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39497 }
39498 arg4 = static_cast< int >(val4);
39499 }
39500 {
39501 PyThreadState* __tstate = wxPyBeginAllowThreads();
39502 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39503 wxPyEndAllowThreads(__tstate);
39504 if (PyErr_Occurred()) SWIG_fail;
39505 }
39506 resultobj = SWIG_Py_Void();
39507 return resultobj;
39508 fail:
39509 return NULL;
39510 }
39511
39512
39513 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39514 PyObject *obj;
39515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39516 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39517 return SWIG_Py_Void();
39518 }
39519
39520 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39521 return SWIG_Python_InitShadowInstance(args);
39522 }
39523
39524 SWIGINTERN int DefaultValidator_set(PyObject *) {
39525 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39526 return 1;
39527 }
39528
39529
39530 SWIGINTERN PyObject *DefaultValidator_get(void) {
39531 PyObject *pyobj = 0;
39532
39533 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39534 return pyobj;
39535 }
39536
39537
39538 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39539 PyObject *resultobj = 0;
39540 wxString const &arg1_defvalue = wxPyEmptyString ;
39541 wxString *arg1 = (wxString *) &arg1_defvalue ;
39542 long arg2 = (long) 0 ;
39543 wxMenu *result = 0 ;
39544 bool temp1 = false ;
39545 long val2 ;
39546 int ecode2 = 0 ;
39547 PyObject * obj0 = 0 ;
39548 PyObject * obj1 = 0 ;
39549 char * kwnames[] = {
39550 (char *) "title",(char *) "style", NULL
39551 };
39552
39553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39554 if (obj0) {
39555 {
39556 arg1 = wxString_in_helper(obj0);
39557 if (arg1 == NULL) SWIG_fail;
39558 temp1 = true;
39559 }
39560 }
39561 if (obj1) {
39562 ecode2 = SWIG_AsVal_long(obj1, &val2);
39563 if (!SWIG_IsOK(ecode2)) {
39564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39565 }
39566 arg2 = static_cast< long >(val2);
39567 }
39568 {
39569 if (!wxPyCheckForApp()) SWIG_fail;
39570 PyThreadState* __tstate = wxPyBeginAllowThreads();
39571 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39572 wxPyEndAllowThreads(__tstate);
39573 if (PyErr_Occurred()) SWIG_fail;
39574 }
39575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39576 {
39577 if (temp1)
39578 delete arg1;
39579 }
39580 return resultobj;
39581 fail:
39582 {
39583 if (temp1)
39584 delete arg1;
39585 }
39586 return NULL;
39587 }
39588
39589
39590 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39591 PyObject *resultobj = 0;
39592 wxMenu *arg1 = (wxMenu *) 0 ;
39593 int arg2 ;
39594 wxString const &arg3_defvalue = wxPyEmptyString ;
39595 wxString *arg3 = (wxString *) &arg3_defvalue ;
39596 wxString const &arg4_defvalue = wxPyEmptyString ;
39597 wxString *arg4 = (wxString *) &arg4_defvalue ;
39598 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39599 wxMenuItem *result = 0 ;
39600 void *argp1 = 0 ;
39601 int res1 = 0 ;
39602 int val2 ;
39603 int ecode2 = 0 ;
39604 bool temp3 = false ;
39605 bool temp4 = false ;
39606 int val5 ;
39607 int ecode5 = 0 ;
39608 PyObject * obj0 = 0 ;
39609 PyObject * obj1 = 0 ;
39610 PyObject * obj2 = 0 ;
39611 PyObject * obj3 = 0 ;
39612 PyObject * obj4 = 0 ;
39613 char * kwnames[] = {
39614 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39615 };
39616
39617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39619 if (!SWIG_IsOK(res1)) {
39620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39621 }
39622 arg1 = reinterpret_cast< wxMenu * >(argp1);
39623 ecode2 = SWIG_AsVal_int(obj1, &val2);
39624 if (!SWIG_IsOK(ecode2)) {
39625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39626 }
39627 arg2 = static_cast< int >(val2);
39628 if (obj2) {
39629 {
39630 arg3 = wxString_in_helper(obj2);
39631 if (arg3 == NULL) SWIG_fail;
39632 temp3 = true;
39633 }
39634 }
39635 if (obj3) {
39636 {
39637 arg4 = wxString_in_helper(obj3);
39638 if (arg4 == NULL) SWIG_fail;
39639 temp4 = true;
39640 }
39641 }
39642 if (obj4) {
39643 ecode5 = SWIG_AsVal_int(obj4, &val5);
39644 if (!SWIG_IsOK(ecode5)) {
39645 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39646 }
39647 arg5 = static_cast< wxItemKind >(val5);
39648 }
39649 {
39650 PyThreadState* __tstate = wxPyBeginAllowThreads();
39651 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39652 wxPyEndAllowThreads(__tstate);
39653 if (PyErr_Occurred()) SWIG_fail;
39654 }
39655 {
39656 resultobj = wxPyMake_wxObject(result, (bool)0);
39657 }
39658 {
39659 if (temp3)
39660 delete arg3;
39661 }
39662 {
39663 if (temp4)
39664 delete arg4;
39665 }
39666 return resultobj;
39667 fail:
39668 {
39669 if (temp3)
39670 delete arg3;
39671 }
39672 {
39673 if (temp4)
39674 delete arg4;
39675 }
39676 return NULL;
39677 }
39678
39679
39680 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39681 PyObject *resultobj = 0;
39682 wxMenu *arg1 = (wxMenu *) 0 ;
39683 wxMenuItem *result = 0 ;
39684 void *argp1 = 0 ;
39685 int res1 = 0 ;
39686 PyObject *swig_obj[1] ;
39687
39688 if (!args) SWIG_fail;
39689 swig_obj[0] = args;
39690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39691 if (!SWIG_IsOK(res1)) {
39692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39693 }
39694 arg1 = reinterpret_cast< wxMenu * >(argp1);
39695 {
39696 PyThreadState* __tstate = wxPyBeginAllowThreads();
39697 result = (wxMenuItem *)(arg1)->AppendSeparator();
39698 wxPyEndAllowThreads(__tstate);
39699 if (PyErr_Occurred()) SWIG_fail;
39700 }
39701 {
39702 resultobj = wxPyMake_wxObject(result, (bool)0);
39703 }
39704 return resultobj;
39705 fail:
39706 return NULL;
39707 }
39708
39709
39710 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39711 PyObject *resultobj = 0;
39712 wxMenu *arg1 = (wxMenu *) 0 ;
39713 int arg2 ;
39714 wxString *arg3 = 0 ;
39715 wxString const &arg4_defvalue = wxPyEmptyString ;
39716 wxString *arg4 = (wxString *) &arg4_defvalue ;
39717 wxMenuItem *result = 0 ;
39718 void *argp1 = 0 ;
39719 int res1 = 0 ;
39720 int val2 ;
39721 int ecode2 = 0 ;
39722 bool temp3 = false ;
39723 bool temp4 = false ;
39724 PyObject * obj0 = 0 ;
39725 PyObject * obj1 = 0 ;
39726 PyObject * obj2 = 0 ;
39727 PyObject * obj3 = 0 ;
39728 char * kwnames[] = {
39729 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39730 };
39731
39732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39734 if (!SWIG_IsOK(res1)) {
39735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39736 }
39737 arg1 = reinterpret_cast< wxMenu * >(argp1);
39738 ecode2 = SWIG_AsVal_int(obj1, &val2);
39739 if (!SWIG_IsOK(ecode2)) {
39740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39741 }
39742 arg2 = static_cast< int >(val2);
39743 {
39744 arg3 = wxString_in_helper(obj2);
39745 if (arg3 == NULL) SWIG_fail;
39746 temp3 = true;
39747 }
39748 if (obj3) {
39749 {
39750 arg4 = wxString_in_helper(obj3);
39751 if (arg4 == NULL) SWIG_fail;
39752 temp4 = true;
39753 }
39754 }
39755 {
39756 PyThreadState* __tstate = wxPyBeginAllowThreads();
39757 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39758 wxPyEndAllowThreads(__tstate);
39759 if (PyErr_Occurred()) SWIG_fail;
39760 }
39761 {
39762 resultobj = wxPyMake_wxObject(result, (bool)0);
39763 }
39764 {
39765 if (temp3)
39766 delete arg3;
39767 }
39768 {
39769 if (temp4)
39770 delete arg4;
39771 }
39772 return resultobj;
39773 fail:
39774 {
39775 if (temp3)
39776 delete arg3;
39777 }
39778 {
39779 if (temp4)
39780 delete arg4;
39781 }
39782 return NULL;
39783 }
39784
39785
39786 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj = 0;
39788 wxMenu *arg1 = (wxMenu *) 0 ;
39789 int arg2 ;
39790 wxString *arg3 = 0 ;
39791 wxString const &arg4_defvalue = wxPyEmptyString ;
39792 wxString *arg4 = (wxString *) &arg4_defvalue ;
39793 wxMenuItem *result = 0 ;
39794 void *argp1 = 0 ;
39795 int res1 = 0 ;
39796 int val2 ;
39797 int ecode2 = 0 ;
39798 bool temp3 = false ;
39799 bool temp4 = false ;
39800 PyObject * obj0 = 0 ;
39801 PyObject * obj1 = 0 ;
39802 PyObject * obj2 = 0 ;
39803 PyObject * obj3 = 0 ;
39804 char * kwnames[] = {
39805 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39806 };
39807
39808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39810 if (!SWIG_IsOK(res1)) {
39811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39812 }
39813 arg1 = reinterpret_cast< wxMenu * >(argp1);
39814 ecode2 = SWIG_AsVal_int(obj1, &val2);
39815 if (!SWIG_IsOK(ecode2)) {
39816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39817 }
39818 arg2 = static_cast< int >(val2);
39819 {
39820 arg3 = wxString_in_helper(obj2);
39821 if (arg3 == NULL) SWIG_fail;
39822 temp3 = true;
39823 }
39824 if (obj3) {
39825 {
39826 arg4 = wxString_in_helper(obj3);
39827 if (arg4 == NULL) SWIG_fail;
39828 temp4 = true;
39829 }
39830 }
39831 {
39832 PyThreadState* __tstate = wxPyBeginAllowThreads();
39833 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39834 wxPyEndAllowThreads(__tstate);
39835 if (PyErr_Occurred()) SWIG_fail;
39836 }
39837 {
39838 resultobj = wxPyMake_wxObject(result, (bool)0);
39839 }
39840 {
39841 if (temp3)
39842 delete arg3;
39843 }
39844 {
39845 if (temp4)
39846 delete arg4;
39847 }
39848 return resultobj;
39849 fail:
39850 {
39851 if (temp3)
39852 delete arg3;
39853 }
39854 {
39855 if (temp4)
39856 delete arg4;
39857 }
39858 return NULL;
39859 }
39860
39861
39862 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39863 PyObject *resultobj = 0;
39864 wxMenu *arg1 = (wxMenu *) 0 ;
39865 int arg2 ;
39866 wxString *arg3 = 0 ;
39867 wxMenu *arg4 = (wxMenu *) 0 ;
39868 wxString const &arg5_defvalue = wxPyEmptyString ;
39869 wxString *arg5 = (wxString *) &arg5_defvalue ;
39870 wxMenuItem *result = 0 ;
39871 void *argp1 = 0 ;
39872 int res1 = 0 ;
39873 int val2 ;
39874 int ecode2 = 0 ;
39875 bool temp3 = false ;
39876 void *argp4 = 0 ;
39877 int res4 = 0 ;
39878 bool temp5 = false ;
39879 PyObject * obj0 = 0 ;
39880 PyObject * obj1 = 0 ;
39881 PyObject * obj2 = 0 ;
39882 PyObject * obj3 = 0 ;
39883 PyObject * obj4 = 0 ;
39884 char * kwnames[] = {
39885 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39886 };
39887
39888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39890 if (!SWIG_IsOK(res1)) {
39891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39892 }
39893 arg1 = reinterpret_cast< wxMenu * >(argp1);
39894 ecode2 = SWIG_AsVal_int(obj1, &val2);
39895 if (!SWIG_IsOK(ecode2)) {
39896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39897 }
39898 arg2 = static_cast< int >(val2);
39899 {
39900 arg3 = wxString_in_helper(obj2);
39901 if (arg3 == NULL) SWIG_fail;
39902 temp3 = true;
39903 }
39904 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39905 if (!SWIG_IsOK(res4)) {
39906 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39907 }
39908 arg4 = reinterpret_cast< wxMenu * >(argp4);
39909 if (obj4) {
39910 {
39911 arg5 = wxString_in_helper(obj4);
39912 if (arg5 == NULL) SWIG_fail;
39913 temp5 = true;
39914 }
39915 }
39916 {
39917 PyThreadState* __tstate = wxPyBeginAllowThreads();
39918 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39919 wxPyEndAllowThreads(__tstate);
39920 if (PyErr_Occurred()) SWIG_fail;
39921 }
39922 {
39923 resultobj = wxPyMake_wxObject(result, (bool)0);
39924 }
39925 {
39926 if (temp3)
39927 delete arg3;
39928 }
39929 {
39930 if (temp5)
39931 delete arg5;
39932 }
39933 return resultobj;
39934 fail:
39935 {
39936 if (temp3)
39937 delete arg3;
39938 }
39939 {
39940 if (temp5)
39941 delete arg5;
39942 }
39943 return NULL;
39944 }
39945
39946
39947 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39948 PyObject *resultobj = 0;
39949 wxMenu *arg1 = (wxMenu *) 0 ;
39950 wxMenu *arg2 = (wxMenu *) 0 ;
39951 wxString *arg3 = 0 ;
39952 wxString const &arg4_defvalue = wxPyEmptyString ;
39953 wxString *arg4 = (wxString *) &arg4_defvalue ;
39954 wxMenuItem *result = 0 ;
39955 void *argp1 = 0 ;
39956 int res1 = 0 ;
39957 void *argp2 = 0 ;
39958 int res2 = 0 ;
39959 bool temp3 = false ;
39960 bool temp4 = false ;
39961 PyObject * obj0 = 0 ;
39962 PyObject * obj1 = 0 ;
39963 PyObject * obj2 = 0 ;
39964 PyObject * obj3 = 0 ;
39965 char * kwnames[] = {
39966 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39967 };
39968
39969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39971 if (!SWIG_IsOK(res1)) {
39972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39973 }
39974 arg1 = reinterpret_cast< wxMenu * >(argp1);
39975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39976 if (!SWIG_IsOK(res2)) {
39977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39978 }
39979 arg2 = reinterpret_cast< wxMenu * >(argp2);
39980 {
39981 arg3 = wxString_in_helper(obj2);
39982 if (arg3 == NULL) SWIG_fail;
39983 temp3 = true;
39984 }
39985 if (obj3) {
39986 {
39987 arg4 = wxString_in_helper(obj3);
39988 if (arg4 == NULL) SWIG_fail;
39989 temp4 = true;
39990 }
39991 }
39992 {
39993 PyThreadState* __tstate = wxPyBeginAllowThreads();
39994 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39995 wxPyEndAllowThreads(__tstate);
39996 if (PyErr_Occurred()) SWIG_fail;
39997 }
39998 {
39999 resultobj = wxPyMake_wxObject(result, (bool)0);
40000 }
40001 {
40002 if (temp3)
40003 delete arg3;
40004 }
40005 {
40006 if (temp4)
40007 delete arg4;
40008 }
40009 return resultobj;
40010 fail:
40011 {
40012 if (temp3)
40013 delete arg3;
40014 }
40015 {
40016 if (temp4)
40017 delete arg4;
40018 }
40019 return NULL;
40020 }
40021
40022
40023 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40024 PyObject *resultobj = 0;
40025 wxMenu *arg1 = (wxMenu *) 0 ;
40026 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40027 wxMenuItem *result = 0 ;
40028 void *argp1 = 0 ;
40029 int res1 = 0 ;
40030 int res2 = 0 ;
40031 PyObject * obj0 = 0 ;
40032 PyObject * obj1 = 0 ;
40033 char * kwnames[] = {
40034 (char *) "self",(char *) "item", NULL
40035 };
40036
40037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40039 if (!SWIG_IsOK(res1)) {
40040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40041 }
40042 arg1 = reinterpret_cast< wxMenu * >(argp1);
40043 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40044 if (!SWIG_IsOK(res2)) {
40045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40046 }
40047 {
40048 PyThreadState* __tstate = wxPyBeginAllowThreads();
40049 result = (wxMenuItem *)(arg1)->Append(arg2);
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 {
40054 resultobj = wxPyMake_wxObject(result, (bool)0);
40055 }
40056 return resultobj;
40057 fail:
40058 return NULL;
40059 }
40060
40061
40062 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40063 PyObject *resultobj = 0;
40064 wxMenu *arg1 = (wxMenu *) 0 ;
40065 size_t arg2 ;
40066 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40067 wxMenuItem *result = 0 ;
40068 void *argp1 = 0 ;
40069 int res1 = 0 ;
40070 size_t val2 ;
40071 int ecode2 = 0 ;
40072 int res3 = 0 ;
40073 PyObject * obj0 = 0 ;
40074 PyObject * obj1 = 0 ;
40075 PyObject * obj2 = 0 ;
40076 char * kwnames[] = {
40077 (char *) "self",(char *) "pos",(char *) "item", NULL
40078 };
40079
40080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40082 if (!SWIG_IsOK(res1)) {
40083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40084 }
40085 arg1 = reinterpret_cast< wxMenu * >(argp1);
40086 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40087 if (!SWIG_IsOK(ecode2)) {
40088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40089 }
40090 arg2 = static_cast< size_t >(val2);
40091 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40092 if (!SWIG_IsOK(res3)) {
40093 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40094 }
40095 {
40096 PyThreadState* __tstate = wxPyBeginAllowThreads();
40097 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40098 wxPyEndAllowThreads(__tstate);
40099 if (PyErr_Occurred()) SWIG_fail;
40100 }
40101 {
40102 resultobj = wxPyMake_wxObject(result, (bool)0);
40103 }
40104 return resultobj;
40105 fail:
40106 return NULL;
40107 }
40108
40109
40110 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40111 PyObject *resultobj = 0;
40112 wxMenu *arg1 = (wxMenu *) 0 ;
40113 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40114 wxMenuItem *result = 0 ;
40115 void *argp1 = 0 ;
40116 int res1 = 0 ;
40117 int res2 = 0 ;
40118 PyObject * obj0 = 0 ;
40119 PyObject * obj1 = 0 ;
40120 char * kwnames[] = {
40121 (char *) "self",(char *) "item", NULL
40122 };
40123
40124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40126 if (!SWIG_IsOK(res1)) {
40127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40128 }
40129 arg1 = reinterpret_cast< wxMenu * >(argp1);
40130 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40131 if (!SWIG_IsOK(res2)) {
40132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40133 }
40134 {
40135 PyThreadState* __tstate = wxPyBeginAllowThreads();
40136 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 {
40141 resultobj = wxPyMake_wxObject(result, (bool)0);
40142 }
40143 return resultobj;
40144 fail:
40145 return NULL;
40146 }
40147
40148
40149 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40150 PyObject *resultobj = 0;
40151 wxMenu *arg1 = (wxMenu *) 0 ;
40152 void *argp1 = 0 ;
40153 int res1 = 0 ;
40154 PyObject *swig_obj[1] ;
40155
40156 if (!args) SWIG_fail;
40157 swig_obj[0] = args;
40158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40159 if (!SWIG_IsOK(res1)) {
40160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40161 }
40162 arg1 = reinterpret_cast< wxMenu * >(argp1);
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 (arg1)->Break();
40166 wxPyEndAllowThreads(__tstate);
40167 if (PyErr_Occurred()) SWIG_fail;
40168 }
40169 resultobj = SWIG_Py_Void();
40170 return resultobj;
40171 fail:
40172 return NULL;
40173 }
40174
40175
40176 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40177 PyObject *resultobj = 0;
40178 wxMenu *arg1 = (wxMenu *) 0 ;
40179 size_t arg2 ;
40180 int arg3 ;
40181 wxString const &arg4_defvalue = wxPyEmptyString ;
40182 wxString *arg4 = (wxString *) &arg4_defvalue ;
40183 wxString const &arg5_defvalue = wxPyEmptyString ;
40184 wxString *arg5 = (wxString *) &arg5_defvalue ;
40185 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40186 wxMenuItem *result = 0 ;
40187 void *argp1 = 0 ;
40188 int res1 = 0 ;
40189 size_t val2 ;
40190 int ecode2 = 0 ;
40191 int val3 ;
40192 int ecode3 = 0 ;
40193 bool temp4 = false ;
40194 bool temp5 = false ;
40195 int val6 ;
40196 int ecode6 = 0 ;
40197 PyObject * obj0 = 0 ;
40198 PyObject * obj1 = 0 ;
40199 PyObject * obj2 = 0 ;
40200 PyObject * obj3 = 0 ;
40201 PyObject * obj4 = 0 ;
40202 PyObject * obj5 = 0 ;
40203 char * kwnames[] = {
40204 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40205 };
40206
40207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40209 if (!SWIG_IsOK(res1)) {
40210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40211 }
40212 arg1 = reinterpret_cast< wxMenu * >(argp1);
40213 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40214 if (!SWIG_IsOK(ecode2)) {
40215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40216 }
40217 arg2 = static_cast< size_t >(val2);
40218 ecode3 = SWIG_AsVal_int(obj2, &val3);
40219 if (!SWIG_IsOK(ecode3)) {
40220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40221 }
40222 arg3 = static_cast< int >(val3);
40223 if (obj3) {
40224 {
40225 arg4 = wxString_in_helper(obj3);
40226 if (arg4 == NULL) SWIG_fail;
40227 temp4 = true;
40228 }
40229 }
40230 if (obj4) {
40231 {
40232 arg5 = wxString_in_helper(obj4);
40233 if (arg5 == NULL) SWIG_fail;
40234 temp5 = true;
40235 }
40236 }
40237 if (obj5) {
40238 ecode6 = SWIG_AsVal_int(obj5, &val6);
40239 if (!SWIG_IsOK(ecode6)) {
40240 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40241 }
40242 arg6 = static_cast< wxItemKind >(val6);
40243 }
40244 {
40245 PyThreadState* __tstate = wxPyBeginAllowThreads();
40246 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40247 wxPyEndAllowThreads(__tstate);
40248 if (PyErr_Occurred()) SWIG_fail;
40249 }
40250 {
40251 resultobj = wxPyMake_wxObject(result, (bool)0);
40252 }
40253 {
40254 if (temp4)
40255 delete arg4;
40256 }
40257 {
40258 if (temp5)
40259 delete arg5;
40260 }
40261 return resultobj;
40262 fail:
40263 {
40264 if (temp4)
40265 delete arg4;
40266 }
40267 {
40268 if (temp5)
40269 delete arg5;
40270 }
40271 return NULL;
40272 }
40273
40274
40275 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj = 0;
40277 wxMenu *arg1 = (wxMenu *) 0 ;
40278 size_t arg2 ;
40279 wxMenuItem *result = 0 ;
40280 void *argp1 = 0 ;
40281 int res1 = 0 ;
40282 size_t val2 ;
40283 int ecode2 = 0 ;
40284 PyObject * obj0 = 0 ;
40285 PyObject * obj1 = 0 ;
40286 char * kwnames[] = {
40287 (char *) "self",(char *) "pos", NULL
40288 };
40289
40290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40292 if (!SWIG_IsOK(res1)) {
40293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40294 }
40295 arg1 = reinterpret_cast< wxMenu * >(argp1);
40296 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40297 if (!SWIG_IsOK(ecode2)) {
40298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40299 }
40300 arg2 = static_cast< size_t >(val2);
40301 {
40302 PyThreadState* __tstate = wxPyBeginAllowThreads();
40303 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40304 wxPyEndAllowThreads(__tstate);
40305 if (PyErr_Occurred()) SWIG_fail;
40306 }
40307 {
40308 resultobj = wxPyMake_wxObject(result, (bool)0);
40309 }
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj = 0;
40318 wxMenu *arg1 = (wxMenu *) 0 ;
40319 size_t arg2 ;
40320 int arg3 ;
40321 wxString *arg4 = 0 ;
40322 wxString const &arg5_defvalue = wxPyEmptyString ;
40323 wxString *arg5 = (wxString *) &arg5_defvalue ;
40324 wxMenuItem *result = 0 ;
40325 void *argp1 = 0 ;
40326 int res1 = 0 ;
40327 size_t val2 ;
40328 int ecode2 = 0 ;
40329 int val3 ;
40330 int ecode3 = 0 ;
40331 bool temp4 = false ;
40332 bool temp5 = false ;
40333 PyObject * obj0 = 0 ;
40334 PyObject * obj1 = 0 ;
40335 PyObject * obj2 = 0 ;
40336 PyObject * obj3 = 0 ;
40337 PyObject * obj4 = 0 ;
40338 char * kwnames[] = {
40339 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40340 };
40341
40342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40344 if (!SWIG_IsOK(res1)) {
40345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40346 }
40347 arg1 = reinterpret_cast< wxMenu * >(argp1);
40348 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40349 if (!SWIG_IsOK(ecode2)) {
40350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40351 }
40352 arg2 = static_cast< size_t >(val2);
40353 ecode3 = SWIG_AsVal_int(obj2, &val3);
40354 if (!SWIG_IsOK(ecode3)) {
40355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40356 }
40357 arg3 = static_cast< int >(val3);
40358 {
40359 arg4 = wxString_in_helper(obj3);
40360 if (arg4 == NULL) SWIG_fail;
40361 temp4 = true;
40362 }
40363 if (obj4) {
40364 {
40365 arg5 = wxString_in_helper(obj4);
40366 if (arg5 == NULL) SWIG_fail;
40367 temp5 = true;
40368 }
40369 }
40370 {
40371 PyThreadState* __tstate = wxPyBeginAllowThreads();
40372 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40373 wxPyEndAllowThreads(__tstate);
40374 if (PyErr_Occurred()) SWIG_fail;
40375 }
40376 {
40377 resultobj = wxPyMake_wxObject(result, (bool)0);
40378 }
40379 {
40380 if (temp4)
40381 delete arg4;
40382 }
40383 {
40384 if (temp5)
40385 delete arg5;
40386 }
40387 return resultobj;
40388 fail:
40389 {
40390 if (temp4)
40391 delete arg4;
40392 }
40393 {
40394 if (temp5)
40395 delete arg5;
40396 }
40397 return NULL;
40398 }
40399
40400
40401 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40402 PyObject *resultobj = 0;
40403 wxMenu *arg1 = (wxMenu *) 0 ;
40404 size_t arg2 ;
40405 int arg3 ;
40406 wxString *arg4 = 0 ;
40407 wxString const &arg5_defvalue = wxPyEmptyString ;
40408 wxString *arg5 = (wxString *) &arg5_defvalue ;
40409 wxMenuItem *result = 0 ;
40410 void *argp1 = 0 ;
40411 int res1 = 0 ;
40412 size_t val2 ;
40413 int ecode2 = 0 ;
40414 int val3 ;
40415 int ecode3 = 0 ;
40416 bool temp4 = false ;
40417 bool temp5 = false ;
40418 PyObject * obj0 = 0 ;
40419 PyObject * obj1 = 0 ;
40420 PyObject * obj2 = 0 ;
40421 PyObject * obj3 = 0 ;
40422 PyObject * obj4 = 0 ;
40423 char * kwnames[] = {
40424 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40425 };
40426
40427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40429 if (!SWIG_IsOK(res1)) {
40430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40431 }
40432 arg1 = reinterpret_cast< wxMenu * >(argp1);
40433 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40434 if (!SWIG_IsOK(ecode2)) {
40435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40436 }
40437 arg2 = static_cast< size_t >(val2);
40438 ecode3 = SWIG_AsVal_int(obj2, &val3);
40439 if (!SWIG_IsOK(ecode3)) {
40440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40441 }
40442 arg3 = static_cast< int >(val3);
40443 {
40444 arg4 = wxString_in_helper(obj3);
40445 if (arg4 == NULL) SWIG_fail;
40446 temp4 = true;
40447 }
40448 if (obj4) {
40449 {
40450 arg5 = wxString_in_helper(obj4);
40451 if (arg5 == NULL) SWIG_fail;
40452 temp5 = true;
40453 }
40454 }
40455 {
40456 PyThreadState* __tstate = wxPyBeginAllowThreads();
40457 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40458 wxPyEndAllowThreads(__tstate);
40459 if (PyErr_Occurred()) SWIG_fail;
40460 }
40461 {
40462 resultobj = wxPyMake_wxObject(result, (bool)0);
40463 }
40464 {
40465 if (temp4)
40466 delete arg4;
40467 }
40468 {
40469 if (temp5)
40470 delete arg5;
40471 }
40472 return resultobj;
40473 fail:
40474 {
40475 if (temp4)
40476 delete arg4;
40477 }
40478 {
40479 if (temp5)
40480 delete arg5;
40481 }
40482 return NULL;
40483 }
40484
40485
40486 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40487 PyObject *resultobj = 0;
40488 wxMenu *arg1 = (wxMenu *) 0 ;
40489 size_t arg2 ;
40490 int arg3 ;
40491 wxString *arg4 = 0 ;
40492 wxMenu *arg5 = (wxMenu *) 0 ;
40493 wxString const &arg6_defvalue = wxPyEmptyString ;
40494 wxString *arg6 = (wxString *) &arg6_defvalue ;
40495 wxMenuItem *result = 0 ;
40496 void *argp1 = 0 ;
40497 int res1 = 0 ;
40498 size_t val2 ;
40499 int ecode2 = 0 ;
40500 int val3 ;
40501 int ecode3 = 0 ;
40502 bool temp4 = false ;
40503 void *argp5 = 0 ;
40504 int res5 = 0 ;
40505 bool temp6 = false ;
40506 PyObject * obj0 = 0 ;
40507 PyObject * obj1 = 0 ;
40508 PyObject * obj2 = 0 ;
40509 PyObject * obj3 = 0 ;
40510 PyObject * obj4 = 0 ;
40511 PyObject * obj5 = 0 ;
40512 char * kwnames[] = {
40513 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40514 };
40515
40516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40518 if (!SWIG_IsOK(res1)) {
40519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40520 }
40521 arg1 = reinterpret_cast< wxMenu * >(argp1);
40522 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40523 if (!SWIG_IsOK(ecode2)) {
40524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40525 }
40526 arg2 = static_cast< size_t >(val2);
40527 ecode3 = SWIG_AsVal_int(obj2, &val3);
40528 if (!SWIG_IsOK(ecode3)) {
40529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40530 }
40531 arg3 = static_cast< int >(val3);
40532 {
40533 arg4 = wxString_in_helper(obj3);
40534 if (arg4 == NULL) SWIG_fail;
40535 temp4 = true;
40536 }
40537 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40538 if (!SWIG_IsOK(res5)) {
40539 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40540 }
40541 arg5 = reinterpret_cast< wxMenu * >(argp5);
40542 if (obj5) {
40543 {
40544 arg6 = wxString_in_helper(obj5);
40545 if (arg6 == NULL) SWIG_fail;
40546 temp6 = true;
40547 }
40548 }
40549 {
40550 PyThreadState* __tstate = wxPyBeginAllowThreads();
40551 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40552 wxPyEndAllowThreads(__tstate);
40553 if (PyErr_Occurred()) SWIG_fail;
40554 }
40555 {
40556 resultobj = wxPyMake_wxObject(result, (bool)0);
40557 }
40558 {
40559 if (temp4)
40560 delete arg4;
40561 }
40562 {
40563 if (temp6)
40564 delete arg6;
40565 }
40566 return resultobj;
40567 fail:
40568 {
40569 if (temp4)
40570 delete arg4;
40571 }
40572 {
40573 if (temp6)
40574 delete arg6;
40575 }
40576 return NULL;
40577 }
40578
40579
40580 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40581 PyObject *resultobj = 0;
40582 wxMenu *arg1 = (wxMenu *) 0 ;
40583 int arg2 ;
40584 wxString const &arg3_defvalue = wxPyEmptyString ;
40585 wxString *arg3 = (wxString *) &arg3_defvalue ;
40586 wxString const &arg4_defvalue = wxPyEmptyString ;
40587 wxString *arg4 = (wxString *) &arg4_defvalue ;
40588 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40589 wxMenuItem *result = 0 ;
40590 void *argp1 = 0 ;
40591 int res1 = 0 ;
40592 int val2 ;
40593 int ecode2 = 0 ;
40594 bool temp3 = false ;
40595 bool temp4 = false ;
40596 int val5 ;
40597 int ecode5 = 0 ;
40598 PyObject * obj0 = 0 ;
40599 PyObject * obj1 = 0 ;
40600 PyObject * obj2 = 0 ;
40601 PyObject * obj3 = 0 ;
40602 PyObject * obj4 = 0 ;
40603 char * kwnames[] = {
40604 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40605 };
40606
40607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40609 if (!SWIG_IsOK(res1)) {
40610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40611 }
40612 arg1 = reinterpret_cast< wxMenu * >(argp1);
40613 ecode2 = SWIG_AsVal_int(obj1, &val2);
40614 if (!SWIG_IsOK(ecode2)) {
40615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40616 }
40617 arg2 = static_cast< int >(val2);
40618 if (obj2) {
40619 {
40620 arg3 = wxString_in_helper(obj2);
40621 if (arg3 == NULL) SWIG_fail;
40622 temp3 = true;
40623 }
40624 }
40625 if (obj3) {
40626 {
40627 arg4 = wxString_in_helper(obj3);
40628 if (arg4 == NULL) SWIG_fail;
40629 temp4 = true;
40630 }
40631 }
40632 if (obj4) {
40633 ecode5 = SWIG_AsVal_int(obj4, &val5);
40634 if (!SWIG_IsOK(ecode5)) {
40635 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40636 }
40637 arg5 = static_cast< wxItemKind >(val5);
40638 }
40639 {
40640 PyThreadState* __tstate = wxPyBeginAllowThreads();
40641 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40642 wxPyEndAllowThreads(__tstate);
40643 if (PyErr_Occurred()) SWIG_fail;
40644 }
40645 {
40646 resultobj = wxPyMake_wxObject(result, (bool)0);
40647 }
40648 {
40649 if (temp3)
40650 delete arg3;
40651 }
40652 {
40653 if (temp4)
40654 delete arg4;
40655 }
40656 return resultobj;
40657 fail:
40658 {
40659 if (temp3)
40660 delete arg3;
40661 }
40662 {
40663 if (temp4)
40664 delete arg4;
40665 }
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40671 PyObject *resultobj = 0;
40672 wxMenu *arg1 = (wxMenu *) 0 ;
40673 wxMenuItem *result = 0 ;
40674 void *argp1 = 0 ;
40675 int res1 = 0 ;
40676 PyObject *swig_obj[1] ;
40677
40678 if (!args) SWIG_fail;
40679 swig_obj[0] = args;
40680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40681 if (!SWIG_IsOK(res1)) {
40682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40683 }
40684 arg1 = reinterpret_cast< wxMenu * >(argp1);
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = (wxMenuItem *)(arg1)->PrependSeparator();
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 {
40692 resultobj = wxPyMake_wxObject(result, (bool)0);
40693 }
40694 return resultobj;
40695 fail:
40696 return NULL;
40697 }
40698
40699
40700 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40701 PyObject *resultobj = 0;
40702 wxMenu *arg1 = (wxMenu *) 0 ;
40703 int arg2 ;
40704 wxString *arg3 = 0 ;
40705 wxString const &arg4_defvalue = wxPyEmptyString ;
40706 wxString *arg4 = (wxString *) &arg4_defvalue ;
40707 wxMenuItem *result = 0 ;
40708 void *argp1 = 0 ;
40709 int res1 = 0 ;
40710 int val2 ;
40711 int ecode2 = 0 ;
40712 bool temp3 = false ;
40713 bool temp4 = false ;
40714 PyObject * obj0 = 0 ;
40715 PyObject * obj1 = 0 ;
40716 PyObject * obj2 = 0 ;
40717 PyObject * obj3 = 0 ;
40718 char * kwnames[] = {
40719 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40720 };
40721
40722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res1)) {
40725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40726 }
40727 arg1 = reinterpret_cast< wxMenu * >(argp1);
40728 ecode2 = SWIG_AsVal_int(obj1, &val2);
40729 if (!SWIG_IsOK(ecode2)) {
40730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40731 }
40732 arg2 = static_cast< int >(val2);
40733 {
40734 arg3 = wxString_in_helper(obj2);
40735 if (arg3 == NULL) SWIG_fail;
40736 temp3 = true;
40737 }
40738 if (obj3) {
40739 {
40740 arg4 = wxString_in_helper(obj3);
40741 if (arg4 == NULL) SWIG_fail;
40742 temp4 = true;
40743 }
40744 }
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 {
40752 resultobj = wxPyMake_wxObject(result, (bool)0);
40753 }
40754 {
40755 if (temp3)
40756 delete arg3;
40757 }
40758 {
40759 if (temp4)
40760 delete arg4;
40761 }
40762 return resultobj;
40763 fail:
40764 {
40765 if (temp3)
40766 delete arg3;
40767 }
40768 {
40769 if (temp4)
40770 delete arg4;
40771 }
40772 return NULL;
40773 }
40774
40775
40776 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40777 PyObject *resultobj = 0;
40778 wxMenu *arg1 = (wxMenu *) 0 ;
40779 int arg2 ;
40780 wxString *arg3 = 0 ;
40781 wxString const &arg4_defvalue = wxPyEmptyString ;
40782 wxString *arg4 = (wxString *) &arg4_defvalue ;
40783 wxMenuItem *result = 0 ;
40784 void *argp1 = 0 ;
40785 int res1 = 0 ;
40786 int val2 ;
40787 int ecode2 = 0 ;
40788 bool temp3 = false ;
40789 bool temp4 = false ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 PyObject * obj2 = 0 ;
40793 PyObject * obj3 = 0 ;
40794 char * kwnames[] = {
40795 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40796 };
40797
40798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40800 if (!SWIG_IsOK(res1)) {
40801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40802 }
40803 arg1 = reinterpret_cast< wxMenu * >(argp1);
40804 ecode2 = SWIG_AsVal_int(obj1, &val2);
40805 if (!SWIG_IsOK(ecode2)) {
40806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40807 }
40808 arg2 = static_cast< int >(val2);
40809 {
40810 arg3 = wxString_in_helper(obj2);
40811 if (arg3 == NULL) SWIG_fail;
40812 temp3 = true;
40813 }
40814 if (obj3) {
40815 {
40816 arg4 = wxString_in_helper(obj3);
40817 if (arg4 == NULL) SWIG_fail;
40818 temp4 = true;
40819 }
40820 }
40821 {
40822 PyThreadState* __tstate = wxPyBeginAllowThreads();
40823 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40824 wxPyEndAllowThreads(__tstate);
40825 if (PyErr_Occurred()) SWIG_fail;
40826 }
40827 {
40828 resultobj = wxPyMake_wxObject(result, (bool)0);
40829 }
40830 {
40831 if (temp3)
40832 delete arg3;
40833 }
40834 {
40835 if (temp4)
40836 delete arg4;
40837 }
40838 return resultobj;
40839 fail:
40840 {
40841 if (temp3)
40842 delete arg3;
40843 }
40844 {
40845 if (temp4)
40846 delete arg4;
40847 }
40848 return NULL;
40849 }
40850
40851
40852 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40853 PyObject *resultobj = 0;
40854 wxMenu *arg1 = (wxMenu *) 0 ;
40855 int arg2 ;
40856 wxString *arg3 = 0 ;
40857 wxMenu *arg4 = (wxMenu *) 0 ;
40858 wxString const &arg5_defvalue = wxPyEmptyString ;
40859 wxString *arg5 = (wxString *) &arg5_defvalue ;
40860 wxMenuItem *result = 0 ;
40861 void *argp1 = 0 ;
40862 int res1 = 0 ;
40863 int val2 ;
40864 int ecode2 = 0 ;
40865 bool temp3 = false ;
40866 void *argp4 = 0 ;
40867 int res4 = 0 ;
40868 bool temp5 = false ;
40869 PyObject * obj0 = 0 ;
40870 PyObject * obj1 = 0 ;
40871 PyObject * obj2 = 0 ;
40872 PyObject * obj3 = 0 ;
40873 PyObject * obj4 = 0 ;
40874 char * kwnames[] = {
40875 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40876 };
40877
40878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40880 if (!SWIG_IsOK(res1)) {
40881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40882 }
40883 arg1 = reinterpret_cast< wxMenu * >(argp1);
40884 ecode2 = SWIG_AsVal_int(obj1, &val2);
40885 if (!SWIG_IsOK(ecode2)) {
40886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40887 }
40888 arg2 = static_cast< int >(val2);
40889 {
40890 arg3 = wxString_in_helper(obj2);
40891 if (arg3 == NULL) SWIG_fail;
40892 temp3 = true;
40893 }
40894 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40895 if (!SWIG_IsOK(res4)) {
40896 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40897 }
40898 arg4 = reinterpret_cast< wxMenu * >(argp4);
40899 if (obj4) {
40900 {
40901 arg5 = wxString_in_helper(obj4);
40902 if (arg5 == NULL) SWIG_fail;
40903 temp5 = true;
40904 }
40905 }
40906 {
40907 PyThreadState* __tstate = wxPyBeginAllowThreads();
40908 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40909 wxPyEndAllowThreads(__tstate);
40910 if (PyErr_Occurred()) SWIG_fail;
40911 }
40912 {
40913 resultobj = wxPyMake_wxObject(result, (bool)0);
40914 }
40915 {
40916 if (temp3)
40917 delete arg3;
40918 }
40919 {
40920 if (temp5)
40921 delete arg5;
40922 }
40923 return resultobj;
40924 fail:
40925 {
40926 if (temp3)
40927 delete arg3;
40928 }
40929 {
40930 if (temp5)
40931 delete arg5;
40932 }
40933 return NULL;
40934 }
40935
40936
40937 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40938 PyObject *resultobj = 0;
40939 wxMenu *arg1 = (wxMenu *) 0 ;
40940 int arg2 ;
40941 wxMenuItem *result = 0 ;
40942 void *argp1 = 0 ;
40943 int res1 = 0 ;
40944 int val2 ;
40945 int ecode2 = 0 ;
40946 PyObject * obj0 = 0 ;
40947 PyObject * obj1 = 0 ;
40948 char * kwnames[] = {
40949 (char *) "self",(char *) "id", NULL
40950 };
40951
40952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40954 if (!SWIG_IsOK(res1)) {
40955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40956 }
40957 arg1 = reinterpret_cast< wxMenu * >(argp1);
40958 ecode2 = SWIG_AsVal_int(obj1, &val2);
40959 if (!SWIG_IsOK(ecode2)) {
40960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40961 }
40962 arg2 = static_cast< int >(val2);
40963 {
40964 PyThreadState* __tstate = wxPyBeginAllowThreads();
40965 result = (wxMenuItem *)(arg1)->Remove(arg2);
40966 wxPyEndAllowThreads(__tstate);
40967 if (PyErr_Occurred()) SWIG_fail;
40968 }
40969 {
40970 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40971 }
40972 return resultobj;
40973 fail:
40974 return NULL;
40975 }
40976
40977
40978 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40979 PyObject *resultobj = 0;
40980 wxMenu *arg1 = (wxMenu *) 0 ;
40981 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40982 wxMenuItem *result = 0 ;
40983 void *argp1 = 0 ;
40984 int res1 = 0 ;
40985 void *argp2 = 0 ;
40986 int res2 = 0 ;
40987 PyObject * obj0 = 0 ;
40988 PyObject * obj1 = 0 ;
40989 char * kwnames[] = {
40990 (char *) "self",(char *) "item", NULL
40991 };
40992
40993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40995 if (!SWIG_IsOK(res1)) {
40996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40997 }
40998 arg1 = reinterpret_cast< wxMenu * >(argp1);
40999 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41000 if (!SWIG_IsOK(res2)) {
41001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41002 }
41003 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41004 {
41005 PyThreadState* __tstate = wxPyBeginAllowThreads();
41006 result = (wxMenuItem *)(arg1)->Remove(arg2);
41007 wxPyEndAllowThreads(__tstate);
41008 if (PyErr_Occurred()) SWIG_fail;
41009 }
41010 {
41011 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41012 }
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 wxMenu *arg1 = (wxMenu *) 0 ;
41022 int arg2 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 int val2 ;
41027 int ecode2 = 0 ;
41028 PyObject * obj0 = 0 ;
41029 PyObject * obj1 = 0 ;
41030 char * kwnames[] = {
41031 (char *) "self",(char *) "id", NULL
41032 };
41033
41034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41036 if (!SWIG_IsOK(res1)) {
41037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41038 }
41039 arg1 = reinterpret_cast< wxMenu * >(argp1);
41040 ecode2 = SWIG_AsVal_int(obj1, &val2);
41041 if (!SWIG_IsOK(ecode2)) {
41042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41043 }
41044 arg2 = static_cast< int >(val2);
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = (bool)(arg1)->Delete(arg2);
41048 wxPyEndAllowThreads(__tstate);
41049 if (PyErr_Occurred()) SWIG_fail;
41050 }
41051 {
41052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41053 }
41054 return resultobj;
41055 fail:
41056 return NULL;
41057 }
41058
41059
41060 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41061 PyObject *resultobj = 0;
41062 wxMenu *arg1 = (wxMenu *) 0 ;
41063 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41064 bool result;
41065 void *argp1 = 0 ;
41066 int res1 = 0 ;
41067 void *argp2 = 0 ;
41068 int res2 = 0 ;
41069 PyObject * obj0 = 0 ;
41070 PyObject * obj1 = 0 ;
41071 char * kwnames[] = {
41072 (char *) "self",(char *) "item", NULL
41073 };
41074
41075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41077 if (!SWIG_IsOK(res1)) {
41078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41079 }
41080 arg1 = reinterpret_cast< wxMenu * >(argp1);
41081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41082 if (!SWIG_IsOK(res2)) {
41083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41084 }
41085 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41086 {
41087 PyThreadState* __tstate = wxPyBeginAllowThreads();
41088 result = (bool)(arg1)->Delete(arg2);
41089 wxPyEndAllowThreads(__tstate);
41090 if (PyErr_Occurred()) SWIG_fail;
41091 }
41092 {
41093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41094 }
41095 return resultobj;
41096 fail:
41097 return NULL;
41098 }
41099
41100
41101 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41102 PyObject *resultobj = 0;
41103 wxMenu *arg1 = (wxMenu *) 0 ;
41104 void *argp1 = 0 ;
41105 int res1 = 0 ;
41106 PyObject *swig_obj[1] ;
41107
41108 if (!args) SWIG_fail;
41109 swig_obj[0] = args;
41110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41111 if (!SWIG_IsOK(res1)) {
41112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41113 }
41114 arg1 = reinterpret_cast< wxMenu * >(argp1);
41115 {
41116 PyThreadState* __tstate = wxPyBeginAllowThreads();
41117 wxMenu_Destroy(arg1);
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 resultobj = SWIG_Py_Void();
41122 return resultobj;
41123 fail:
41124 return NULL;
41125 }
41126
41127
41128 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41129 PyObject *resultobj = 0;
41130 wxMenu *arg1 = (wxMenu *) 0 ;
41131 int arg2 ;
41132 bool result;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 int val2 ;
41136 int ecode2 = 0 ;
41137 PyObject * obj0 = 0 ;
41138 PyObject * obj1 = 0 ;
41139 char * kwnames[] = {
41140 (char *) "self",(char *) "id", NULL
41141 };
41142
41143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41145 if (!SWIG_IsOK(res1)) {
41146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41147 }
41148 arg1 = reinterpret_cast< wxMenu * >(argp1);
41149 ecode2 = SWIG_AsVal_int(obj1, &val2);
41150 if (!SWIG_IsOK(ecode2)) {
41151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41152 }
41153 arg2 = static_cast< int >(val2);
41154 {
41155 PyThreadState* __tstate = wxPyBeginAllowThreads();
41156 result = (bool)(arg1)->Destroy(arg2);
41157 wxPyEndAllowThreads(__tstate);
41158 if (PyErr_Occurred()) SWIG_fail;
41159 }
41160 {
41161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41162 }
41163 return resultobj;
41164 fail:
41165 return NULL;
41166 }
41167
41168
41169 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj = 0;
41171 wxMenu *arg1 = (wxMenu *) 0 ;
41172 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41173 bool result;
41174 void *argp1 = 0 ;
41175 int res1 = 0 ;
41176 void *argp2 = 0 ;
41177 int res2 = 0 ;
41178 PyObject * obj0 = 0 ;
41179 PyObject * obj1 = 0 ;
41180 char * kwnames[] = {
41181 (char *) "self",(char *) "item", NULL
41182 };
41183
41184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41186 if (!SWIG_IsOK(res1)) {
41187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41188 }
41189 arg1 = reinterpret_cast< wxMenu * >(argp1);
41190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41191 if (!SWIG_IsOK(res2)) {
41192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41193 }
41194 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 result = (bool)(arg1)->Destroy(arg2);
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 {
41202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41203 }
41204 return resultobj;
41205 fail:
41206 return NULL;
41207 }
41208
41209
41210 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41211 PyObject *resultobj = 0;
41212 wxMenu *arg1 = (wxMenu *) 0 ;
41213 size_t result;
41214 void *argp1 = 0 ;
41215 int res1 = 0 ;
41216 PyObject *swig_obj[1] ;
41217
41218 if (!args) SWIG_fail;
41219 swig_obj[0] = args;
41220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41221 if (!SWIG_IsOK(res1)) {
41222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41223 }
41224 arg1 = reinterpret_cast< wxMenu * >(argp1);
41225 {
41226 PyThreadState* __tstate = wxPyBeginAllowThreads();
41227 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41228 wxPyEndAllowThreads(__tstate);
41229 if (PyErr_Occurred()) SWIG_fail;
41230 }
41231 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41239 PyObject *resultobj = 0;
41240 wxMenu *arg1 = (wxMenu *) 0 ;
41241 PyObject *result = 0 ;
41242 void *argp1 = 0 ;
41243 int res1 = 0 ;
41244 PyObject *swig_obj[1] ;
41245
41246 if (!args) SWIG_fail;
41247 swig_obj[0] = args;
41248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41249 if (!SWIG_IsOK(res1)) {
41250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41251 }
41252 arg1 = reinterpret_cast< wxMenu * >(argp1);
41253 {
41254 PyThreadState* __tstate = wxPyBeginAllowThreads();
41255 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41256 wxPyEndAllowThreads(__tstate);
41257 if (PyErr_Occurred()) SWIG_fail;
41258 }
41259 resultobj = result;
41260 return resultobj;
41261 fail:
41262 return NULL;
41263 }
41264
41265
41266 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41267 PyObject *resultobj = 0;
41268 wxMenu *arg1 = (wxMenu *) 0 ;
41269 wxString *arg2 = 0 ;
41270 int result;
41271 void *argp1 = 0 ;
41272 int res1 = 0 ;
41273 bool temp2 = false ;
41274 PyObject * obj0 = 0 ;
41275 PyObject * obj1 = 0 ;
41276 char * kwnames[] = {
41277 (char *) "self",(char *) "item", NULL
41278 };
41279
41280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41282 if (!SWIG_IsOK(res1)) {
41283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41284 }
41285 arg1 = reinterpret_cast< wxMenu * >(argp1);
41286 {
41287 arg2 = wxString_in_helper(obj1);
41288 if (arg2 == NULL) SWIG_fail;
41289 temp2 = true;
41290 }
41291 {
41292 PyThreadState* __tstate = wxPyBeginAllowThreads();
41293 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41294 wxPyEndAllowThreads(__tstate);
41295 if (PyErr_Occurred()) SWIG_fail;
41296 }
41297 resultobj = SWIG_From_int(static_cast< int >(result));
41298 {
41299 if (temp2)
41300 delete arg2;
41301 }
41302 return resultobj;
41303 fail:
41304 {
41305 if (temp2)
41306 delete arg2;
41307 }
41308 return NULL;
41309 }
41310
41311
41312 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41313 PyObject *resultobj = 0;
41314 wxMenu *arg1 = (wxMenu *) 0 ;
41315 int arg2 ;
41316 wxMenuItem *result = 0 ;
41317 void *argp1 = 0 ;
41318 int res1 = 0 ;
41319 int val2 ;
41320 int ecode2 = 0 ;
41321 PyObject * obj0 = 0 ;
41322 PyObject * obj1 = 0 ;
41323 char * kwnames[] = {
41324 (char *) "self",(char *) "id", NULL
41325 };
41326
41327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41329 if (!SWIG_IsOK(res1)) {
41330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41331 }
41332 arg1 = reinterpret_cast< wxMenu * >(argp1);
41333 ecode2 = SWIG_AsVal_int(obj1, &val2);
41334 if (!SWIG_IsOK(ecode2)) {
41335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41336 }
41337 arg2 = static_cast< int >(val2);
41338 {
41339 PyThreadState* __tstate = wxPyBeginAllowThreads();
41340 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41341 wxPyEndAllowThreads(__tstate);
41342 if (PyErr_Occurred()) SWIG_fail;
41343 }
41344 {
41345 resultobj = wxPyMake_wxObject(result, (bool)0);
41346 }
41347 return resultobj;
41348 fail:
41349 return NULL;
41350 }
41351
41352
41353 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41354 PyObject *resultobj = 0;
41355 wxMenu *arg1 = (wxMenu *) 0 ;
41356 size_t arg2 ;
41357 wxMenuItem *result = 0 ;
41358 void *argp1 = 0 ;
41359 int res1 = 0 ;
41360 size_t val2 ;
41361 int ecode2 = 0 ;
41362 PyObject * obj0 = 0 ;
41363 PyObject * obj1 = 0 ;
41364 char * kwnames[] = {
41365 (char *) "self",(char *) "position", NULL
41366 };
41367
41368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41370 if (!SWIG_IsOK(res1)) {
41371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41372 }
41373 arg1 = reinterpret_cast< wxMenu * >(argp1);
41374 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41375 if (!SWIG_IsOK(ecode2)) {
41376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41377 }
41378 arg2 = static_cast< size_t >(val2);
41379 {
41380 PyThreadState* __tstate = wxPyBeginAllowThreads();
41381 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41382 wxPyEndAllowThreads(__tstate);
41383 if (PyErr_Occurred()) SWIG_fail;
41384 }
41385 {
41386 resultobj = wxPyMake_wxObject(result, (bool)0);
41387 }
41388 return resultobj;
41389 fail:
41390 return NULL;
41391 }
41392
41393
41394 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41395 PyObject *resultobj = 0;
41396 wxMenu *arg1 = (wxMenu *) 0 ;
41397 int arg2 ;
41398 bool arg3 ;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 int val2 ;
41402 int ecode2 = 0 ;
41403 bool val3 ;
41404 int ecode3 = 0 ;
41405 PyObject * obj0 = 0 ;
41406 PyObject * obj1 = 0 ;
41407 PyObject * obj2 = 0 ;
41408 char * kwnames[] = {
41409 (char *) "self",(char *) "id",(char *) "enable", NULL
41410 };
41411
41412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41414 if (!SWIG_IsOK(res1)) {
41415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41416 }
41417 arg1 = reinterpret_cast< wxMenu * >(argp1);
41418 ecode2 = SWIG_AsVal_int(obj1, &val2);
41419 if (!SWIG_IsOK(ecode2)) {
41420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41421 }
41422 arg2 = static_cast< int >(val2);
41423 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41424 if (!SWIG_IsOK(ecode3)) {
41425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41426 }
41427 arg3 = static_cast< bool >(val3);
41428 {
41429 PyThreadState* __tstate = wxPyBeginAllowThreads();
41430 (arg1)->Enable(arg2,arg3);
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 resultobj = SWIG_Py_Void();
41435 return resultobj;
41436 fail:
41437 return NULL;
41438 }
41439
41440
41441 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41442 PyObject *resultobj = 0;
41443 wxMenu *arg1 = (wxMenu *) 0 ;
41444 int arg2 ;
41445 bool result;
41446 void *argp1 = 0 ;
41447 int res1 = 0 ;
41448 int val2 ;
41449 int ecode2 = 0 ;
41450 PyObject * obj0 = 0 ;
41451 PyObject * obj1 = 0 ;
41452 char * kwnames[] = {
41453 (char *) "self",(char *) "id", NULL
41454 };
41455
41456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41458 if (!SWIG_IsOK(res1)) {
41459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41460 }
41461 arg1 = reinterpret_cast< wxMenu * >(argp1);
41462 ecode2 = SWIG_AsVal_int(obj1, &val2);
41463 if (!SWIG_IsOK(ecode2)) {
41464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41465 }
41466 arg2 = static_cast< int >(val2);
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 {
41474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41475 }
41476 return resultobj;
41477 fail:
41478 return NULL;
41479 }
41480
41481
41482 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41483 PyObject *resultobj = 0;
41484 wxMenu *arg1 = (wxMenu *) 0 ;
41485 int arg2 ;
41486 bool arg3 ;
41487 void *argp1 = 0 ;
41488 int res1 = 0 ;
41489 int val2 ;
41490 int ecode2 = 0 ;
41491 bool val3 ;
41492 int ecode3 = 0 ;
41493 PyObject * obj0 = 0 ;
41494 PyObject * obj1 = 0 ;
41495 PyObject * obj2 = 0 ;
41496 char * kwnames[] = {
41497 (char *) "self",(char *) "id",(char *) "check", NULL
41498 };
41499
41500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41502 if (!SWIG_IsOK(res1)) {
41503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41504 }
41505 arg1 = reinterpret_cast< wxMenu * >(argp1);
41506 ecode2 = SWIG_AsVal_int(obj1, &val2);
41507 if (!SWIG_IsOK(ecode2)) {
41508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41509 }
41510 arg2 = static_cast< int >(val2);
41511 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41512 if (!SWIG_IsOK(ecode3)) {
41513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41514 }
41515 arg3 = static_cast< bool >(val3);
41516 {
41517 PyThreadState* __tstate = wxPyBeginAllowThreads();
41518 (arg1)->Check(arg2,arg3);
41519 wxPyEndAllowThreads(__tstate);
41520 if (PyErr_Occurred()) SWIG_fail;
41521 }
41522 resultobj = SWIG_Py_Void();
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj = 0;
41531 wxMenu *arg1 = (wxMenu *) 0 ;
41532 int arg2 ;
41533 bool result;
41534 void *argp1 = 0 ;
41535 int res1 = 0 ;
41536 int val2 ;
41537 int ecode2 = 0 ;
41538 PyObject * obj0 = 0 ;
41539 PyObject * obj1 = 0 ;
41540 char * kwnames[] = {
41541 (char *) "self",(char *) "id", NULL
41542 };
41543
41544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41546 if (!SWIG_IsOK(res1)) {
41547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41548 }
41549 arg1 = reinterpret_cast< wxMenu * >(argp1);
41550 ecode2 = SWIG_AsVal_int(obj1, &val2);
41551 if (!SWIG_IsOK(ecode2)) {
41552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41553 }
41554 arg2 = static_cast< int >(val2);
41555 {
41556 PyThreadState* __tstate = wxPyBeginAllowThreads();
41557 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41558 wxPyEndAllowThreads(__tstate);
41559 if (PyErr_Occurred()) SWIG_fail;
41560 }
41561 {
41562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41563 }
41564 return resultobj;
41565 fail:
41566 return NULL;
41567 }
41568
41569
41570 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41571 PyObject *resultobj = 0;
41572 wxMenu *arg1 = (wxMenu *) 0 ;
41573 int arg2 ;
41574 wxString *arg3 = 0 ;
41575 void *argp1 = 0 ;
41576 int res1 = 0 ;
41577 int val2 ;
41578 int ecode2 = 0 ;
41579 bool temp3 = false ;
41580 PyObject * obj0 = 0 ;
41581 PyObject * obj1 = 0 ;
41582 PyObject * obj2 = 0 ;
41583 char * kwnames[] = {
41584 (char *) "self",(char *) "id",(char *) "label", NULL
41585 };
41586
41587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41589 if (!SWIG_IsOK(res1)) {
41590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41591 }
41592 arg1 = reinterpret_cast< wxMenu * >(argp1);
41593 ecode2 = SWIG_AsVal_int(obj1, &val2);
41594 if (!SWIG_IsOK(ecode2)) {
41595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41596 }
41597 arg2 = static_cast< int >(val2);
41598 {
41599 arg3 = wxString_in_helper(obj2);
41600 if (arg3 == NULL) SWIG_fail;
41601 temp3 = true;
41602 }
41603 {
41604 PyThreadState* __tstate = wxPyBeginAllowThreads();
41605 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41606 wxPyEndAllowThreads(__tstate);
41607 if (PyErr_Occurred()) SWIG_fail;
41608 }
41609 resultobj = SWIG_Py_Void();
41610 {
41611 if (temp3)
41612 delete arg3;
41613 }
41614 return resultobj;
41615 fail:
41616 {
41617 if (temp3)
41618 delete arg3;
41619 }
41620 return NULL;
41621 }
41622
41623
41624 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41625 PyObject *resultobj = 0;
41626 wxMenu *arg1 = (wxMenu *) 0 ;
41627 int arg2 ;
41628 wxString result;
41629 void *argp1 = 0 ;
41630 int res1 = 0 ;
41631 int val2 ;
41632 int ecode2 = 0 ;
41633 PyObject * obj0 = 0 ;
41634 PyObject * obj1 = 0 ;
41635 char * kwnames[] = {
41636 (char *) "self",(char *) "id", NULL
41637 };
41638
41639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41641 if (!SWIG_IsOK(res1)) {
41642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41643 }
41644 arg1 = reinterpret_cast< wxMenu * >(argp1);
41645 ecode2 = SWIG_AsVal_int(obj1, &val2);
41646 if (!SWIG_IsOK(ecode2)) {
41647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41648 }
41649 arg2 = static_cast< int >(val2);
41650 {
41651 PyThreadState* __tstate = wxPyBeginAllowThreads();
41652 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41653 wxPyEndAllowThreads(__tstate);
41654 if (PyErr_Occurred()) SWIG_fail;
41655 }
41656 {
41657 #if wxUSE_UNICODE
41658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41659 #else
41660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41661 #endif
41662 }
41663 return resultobj;
41664 fail:
41665 return NULL;
41666 }
41667
41668
41669 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41670 PyObject *resultobj = 0;
41671 wxMenu *arg1 = (wxMenu *) 0 ;
41672 int arg2 ;
41673 wxString *arg3 = 0 ;
41674 void *argp1 = 0 ;
41675 int res1 = 0 ;
41676 int val2 ;
41677 int ecode2 = 0 ;
41678 bool temp3 = false ;
41679 PyObject * obj0 = 0 ;
41680 PyObject * obj1 = 0 ;
41681 PyObject * obj2 = 0 ;
41682 char * kwnames[] = {
41683 (char *) "self",(char *) "id",(char *) "helpString", NULL
41684 };
41685
41686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41688 if (!SWIG_IsOK(res1)) {
41689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41690 }
41691 arg1 = reinterpret_cast< wxMenu * >(argp1);
41692 ecode2 = SWIG_AsVal_int(obj1, &val2);
41693 if (!SWIG_IsOK(ecode2)) {
41694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41695 }
41696 arg2 = static_cast< int >(val2);
41697 {
41698 arg3 = wxString_in_helper(obj2);
41699 if (arg3 == NULL) SWIG_fail;
41700 temp3 = true;
41701 }
41702 {
41703 PyThreadState* __tstate = wxPyBeginAllowThreads();
41704 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41705 wxPyEndAllowThreads(__tstate);
41706 if (PyErr_Occurred()) SWIG_fail;
41707 }
41708 resultobj = SWIG_Py_Void();
41709 {
41710 if (temp3)
41711 delete arg3;
41712 }
41713 return resultobj;
41714 fail:
41715 {
41716 if (temp3)
41717 delete arg3;
41718 }
41719 return NULL;
41720 }
41721
41722
41723 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41724 PyObject *resultobj = 0;
41725 wxMenu *arg1 = (wxMenu *) 0 ;
41726 int arg2 ;
41727 wxString result;
41728 void *argp1 = 0 ;
41729 int res1 = 0 ;
41730 int val2 ;
41731 int ecode2 = 0 ;
41732 PyObject * obj0 = 0 ;
41733 PyObject * obj1 = 0 ;
41734 char * kwnames[] = {
41735 (char *) "self",(char *) "id", NULL
41736 };
41737
41738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41740 if (!SWIG_IsOK(res1)) {
41741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41742 }
41743 arg1 = reinterpret_cast< wxMenu * >(argp1);
41744 ecode2 = SWIG_AsVal_int(obj1, &val2);
41745 if (!SWIG_IsOK(ecode2)) {
41746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41747 }
41748 arg2 = static_cast< int >(val2);
41749 {
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 {
41756 #if wxUSE_UNICODE
41757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41758 #else
41759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41760 #endif
41761 }
41762 return resultobj;
41763 fail:
41764 return NULL;
41765 }
41766
41767
41768 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41769 PyObject *resultobj = 0;
41770 wxMenu *arg1 = (wxMenu *) 0 ;
41771 wxString *arg2 = 0 ;
41772 void *argp1 = 0 ;
41773 int res1 = 0 ;
41774 bool temp2 = false ;
41775 PyObject * obj0 = 0 ;
41776 PyObject * obj1 = 0 ;
41777 char * kwnames[] = {
41778 (char *) "self",(char *) "title", NULL
41779 };
41780
41781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41783 if (!SWIG_IsOK(res1)) {
41784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41785 }
41786 arg1 = reinterpret_cast< wxMenu * >(argp1);
41787 {
41788 arg2 = wxString_in_helper(obj1);
41789 if (arg2 == NULL) SWIG_fail;
41790 temp2 = true;
41791 }
41792 {
41793 PyThreadState* __tstate = wxPyBeginAllowThreads();
41794 (arg1)->SetTitle((wxString const &)*arg2);
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 resultobj = SWIG_Py_Void();
41799 {
41800 if (temp2)
41801 delete arg2;
41802 }
41803 return resultobj;
41804 fail:
41805 {
41806 if (temp2)
41807 delete arg2;
41808 }
41809 return NULL;
41810 }
41811
41812
41813 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41814 PyObject *resultobj = 0;
41815 wxMenu *arg1 = (wxMenu *) 0 ;
41816 wxString result;
41817 void *argp1 = 0 ;
41818 int res1 = 0 ;
41819 PyObject *swig_obj[1] ;
41820
41821 if (!args) SWIG_fail;
41822 swig_obj[0] = args;
41823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41824 if (!SWIG_IsOK(res1)) {
41825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41826 }
41827 arg1 = reinterpret_cast< wxMenu * >(argp1);
41828 {
41829 PyThreadState* __tstate = wxPyBeginAllowThreads();
41830 result = ((wxMenu const *)arg1)->GetTitle();
41831 wxPyEndAllowThreads(__tstate);
41832 if (PyErr_Occurred()) SWIG_fail;
41833 }
41834 {
41835 #if wxUSE_UNICODE
41836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41837 #else
41838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41839 #endif
41840 }
41841 return resultobj;
41842 fail:
41843 return NULL;
41844 }
41845
41846
41847 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41848 PyObject *resultobj = 0;
41849 wxMenu *arg1 = (wxMenu *) 0 ;
41850 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41851 void *argp1 = 0 ;
41852 int res1 = 0 ;
41853 void *argp2 = 0 ;
41854 int res2 = 0 ;
41855 PyObject * obj0 = 0 ;
41856 PyObject * obj1 = 0 ;
41857 char * kwnames[] = {
41858 (char *) "self",(char *) "handler", NULL
41859 };
41860
41861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41863 if (!SWIG_IsOK(res1)) {
41864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41865 }
41866 arg1 = reinterpret_cast< wxMenu * >(argp1);
41867 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41868 if (!SWIG_IsOK(res2)) {
41869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41870 }
41871 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41872 {
41873 PyThreadState* __tstate = wxPyBeginAllowThreads();
41874 (arg1)->SetEventHandler(arg2);
41875 wxPyEndAllowThreads(__tstate);
41876 if (PyErr_Occurred()) SWIG_fail;
41877 }
41878 resultobj = SWIG_Py_Void();
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41886 PyObject *resultobj = 0;
41887 wxMenu *arg1 = (wxMenu *) 0 ;
41888 wxEvtHandler *result = 0 ;
41889 void *argp1 = 0 ;
41890 int res1 = 0 ;
41891 PyObject *swig_obj[1] ;
41892
41893 if (!args) SWIG_fail;
41894 swig_obj[0] = args;
41895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41896 if (!SWIG_IsOK(res1)) {
41897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41898 }
41899 arg1 = reinterpret_cast< wxMenu * >(argp1);
41900 {
41901 PyThreadState* __tstate = wxPyBeginAllowThreads();
41902 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41903 wxPyEndAllowThreads(__tstate);
41904 if (PyErr_Occurred()) SWIG_fail;
41905 }
41906 {
41907 resultobj = wxPyMake_wxObject(result, 0);
41908 }
41909 return resultobj;
41910 fail:
41911 return NULL;
41912 }
41913
41914
41915 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41916 PyObject *resultobj = 0;
41917 wxMenu *arg1 = (wxMenu *) 0 ;
41918 wxWindow *arg2 = (wxWindow *) 0 ;
41919 void *argp1 = 0 ;
41920 int res1 = 0 ;
41921 void *argp2 = 0 ;
41922 int res2 = 0 ;
41923 PyObject * obj0 = 0 ;
41924 PyObject * obj1 = 0 ;
41925 char * kwnames[] = {
41926 (char *) "self",(char *) "win", NULL
41927 };
41928
41929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41931 if (!SWIG_IsOK(res1)) {
41932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41933 }
41934 arg1 = reinterpret_cast< wxMenu * >(argp1);
41935 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41936 if (!SWIG_IsOK(res2)) {
41937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41938 }
41939 arg2 = reinterpret_cast< wxWindow * >(argp2);
41940 {
41941 PyThreadState* __tstate = wxPyBeginAllowThreads();
41942 (arg1)->SetInvokingWindow(arg2);
41943 wxPyEndAllowThreads(__tstate);
41944 if (PyErr_Occurred()) SWIG_fail;
41945 }
41946 resultobj = SWIG_Py_Void();
41947 return resultobj;
41948 fail:
41949 return NULL;
41950 }
41951
41952
41953 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41954 PyObject *resultobj = 0;
41955 wxMenu *arg1 = (wxMenu *) 0 ;
41956 wxWindow *result = 0 ;
41957 void *argp1 = 0 ;
41958 int res1 = 0 ;
41959 PyObject *swig_obj[1] ;
41960
41961 if (!args) SWIG_fail;
41962 swig_obj[0] = args;
41963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41964 if (!SWIG_IsOK(res1)) {
41965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41966 }
41967 arg1 = reinterpret_cast< wxMenu * >(argp1);
41968 {
41969 PyThreadState* __tstate = wxPyBeginAllowThreads();
41970 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41971 wxPyEndAllowThreads(__tstate);
41972 if (PyErr_Occurred()) SWIG_fail;
41973 }
41974 {
41975 resultobj = wxPyMake_wxObject(result, 0);
41976 }
41977 return resultobj;
41978 fail:
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41984 PyObject *resultobj = 0;
41985 wxMenu *arg1 = (wxMenu *) 0 ;
41986 long result;
41987 void *argp1 = 0 ;
41988 int res1 = 0 ;
41989 PyObject *swig_obj[1] ;
41990
41991 if (!args) SWIG_fail;
41992 swig_obj[0] = args;
41993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41994 if (!SWIG_IsOK(res1)) {
41995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41996 }
41997 arg1 = reinterpret_cast< wxMenu * >(argp1);
41998 {
41999 PyThreadState* __tstate = wxPyBeginAllowThreads();
42000 result = (long)((wxMenu const *)arg1)->GetStyle();
42001 wxPyEndAllowThreads(__tstate);
42002 if (PyErr_Occurred()) SWIG_fail;
42003 }
42004 resultobj = SWIG_From_long(static_cast< long >(result));
42005 return resultobj;
42006 fail:
42007 return NULL;
42008 }
42009
42010
42011 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42012 PyObject *resultobj = 0;
42013 wxMenu *arg1 = (wxMenu *) 0 ;
42014 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42015 void *argp1 = 0 ;
42016 int res1 = 0 ;
42017 void *argp2 = 0 ;
42018 int res2 = 0 ;
42019 PyObject * obj0 = 0 ;
42020 PyObject * obj1 = 0 ;
42021 char * kwnames[] = {
42022 (char *) "self",(char *) "source", NULL
42023 };
42024
42025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42027 if (!SWIG_IsOK(res1)) {
42028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42029 }
42030 arg1 = reinterpret_cast< wxMenu * >(argp1);
42031 if (obj1) {
42032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42033 if (!SWIG_IsOK(res2)) {
42034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42035 }
42036 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42037 }
42038 {
42039 PyThreadState* __tstate = wxPyBeginAllowThreads();
42040 (arg1)->UpdateUI(arg2);
42041 wxPyEndAllowThreads(__tstate);
42042 if (PyErr_Occurred()) SWIG_fail;
42043 }
42044 resultobj = SWIG_Py_Void();
42045 return resultobj;
42046 fail:
42047 return NULL;
42048 }
42049
42050
42051 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42052 PyObject *resultobj = 0;
42053 wxMenu *arg1 = (wxMenu *) 0 ;
42054 wxMenuBar *result = 0 ;
42055 void *argp1 = 0 ;
42056 int res1 = 0 ;
42057 PyObject *swig_obj[1] ;
42058
42059 if (!args) SWIG_fail;
42060 swig_obj[0] = args;
42061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42062 if (!SWIG_IsOK(res1)) {
42063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42064 }
42065 arg1 = reinterpret_cast< wxMenu * >(argp1);
42066 {
42067 PyThreadState* __tstate = wxPyBeginAllowThreads();
42068 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 {
42073 resultobj = wxPyMake_wxObject(result, (bool)0);
42074 }
42075 return resultobj;
42076 fail:
42077 return NULL;
42078 }
42079
42080
42081 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42082 PyObject *resultobj = 0;
42083 wxMenu *arg1 = (wxMenu *) 0 ;
42084 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42085 void *argp1 = 0 ;
42086 int res1 = 0 ;
42087 void *argp2 = 0 ;
42088 int res2 = 0 ;
42089 PyObject * obj0 = 0 ;
42090 PyObject * obj1 = 0 ;
42091 char * kwnames[] = {
42092 (char *) "self",(char *) "menubar", NULL
42093 };
42094
42095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42097 if (!SWIG_IsOK(res1)) {
42098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42099 }
42100 arg1 = reinterpret_cast< wxMenu * >(argp1);
42101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42102 if (!SWIG_IsOK(res2)) {
42103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42104 }
42105 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42106 {
42107 PyThreadState* __tstate = wxPyBeginAllowThreads();
42108 (arg1)->Attach(arg2);
42109 wxPyEndAllowThreads(__tstate);
42110 if (PyErr_Occurred()) SWIG_fail;
42111 }
42112 resultobj = SWIG_Py_Void();
42113 return resultobj;
42114 fail:
42115 return NULL;
42116 }
42117
42118
42119 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42120 PyObject *resultobj = 0;
42121 wxMenu *arg1 = (wxMenu *) 0 ;
42122 void *argp1 = 0 ;
42123 int res1 = 0 ;
42124 PyObject *swig_obj[1] ;
42125
42126 if (!args) SWIG_fail;
42127 swig_obj[0] = args;
42128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42129 if (!SWIG_IsOK(res1)) {
42130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42131 }
42132 arg1 = reinterpret_cast< wxMenu * >(argp1);
42133 {
42134 PyThreadState* __tstate = wxPyBeginAllowThreads();
42135 (arg1)->Detach();
42136 wxPyEndAllowThreads(__tstate);
42137 if (PyErr_Occurred()) SWIG_fail;
42138 }
42139 resultobj = SWIG_Py_Void();
42140 return resultobj;
42141 fail:
42142 return NULL;
42143 }
42144
42145
42146 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42147 PyObject *resultobj = 0;
42148 wxMenu *arg1 = (wxMenu *) 0 ;
42149 bool result;
42150 void *argp1 = 0 ;
42151 int res1 = 0 ;
42152 PyObject *swig_obj[1] ;
42153
42154 if (!args) SWIG_fail;
42155 swig_obj[0] = args;
42156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42157 if (!SWIG_IsOK(res1)) {
42158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42159 }
42160 arg1 = reinterpret_cast< wxMenu * >(argp1);
42161 {
42162 PyThreadState* __tstate = wxPyBeginAllowThreads();
42163 result = (bool)((wxMenu const *)arg1)->IsAttached();
42164 wxPyEndAllowThreads(__tstate);
42165 if (PyErr_Occurred()) SWIG_fail;
42166 }
42167 {
42168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42169 }
42170 return resultobj;
42171 fail:
42172 return NULL;
42173 }
42174
42175
42176 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42177 PyObject *resultobj = 0;
42178 wxMenu *arg1 = (wxMenu *) 0 ;
42179 wxMenu *arg2 = (wxMenu *) 0 ;
42180 void *argp1 = 0 ;
42181 int res1 = 0 ;
42182 void *argp2 = 0 ;
42183 int res2 = 0 ;
42184 PyObject * obj0 = 0 ;
42185 PyObject * obj1 = 0 ;
42186 char * kwnames[] = {
42187 (char *) "self",(char *) "parent", NULL
42188 };
42189
42190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42192 if (!SWIG_IsOK(res1)) {
42193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42194 }
42195 arg1 = reinterpret_cast< wxMenu * >(argp1);
42196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42197 if (!SWIG_IsOK(res2)) {
42198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42199 }
42200 arg2 = reinterpret_cast< wxMenu * >(argp2);
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 (arg1)->SetParent(arg2);
42204 wxPyEndAllowThreads(__tstate);
42205 if (PyErr_Occurred()) SWIG_fail;
42206 }
42207 resultobj = SWIG_Py_Void();
42208 return resultobj;
42209 fail:
42210 return NULL;
42211 }
42212
42213
42214 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42215 PyObject *resultobj = 0;
42216 wxMenu *arg1 = (wxMenu *) 0 ;
42217 wxMenu *result = 0 ;
42218 void *argp1 = 0 ;
42219 int res1 = 0 ;
42220 PyObject *swig_obj[1] ;
42221
42222 if (!args) SWIG_fail;
42223 swig_obj[0] = args;
42224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42225 if (!SWIG_IsOK(res1)) {
42226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42227 }
42228 arg1 = reinterpret_cast< wxMenu * >(argp1);
42229 {
42230 PyThreadState* __tstate = wxPyBeginAllowThreads();
42231 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42232 wxPyEndAllowThreads(__tstate);
42233 if (PyErr_Occurred()) SWIG_fail;
42234 }
42235 {
42236 resultobj = wxPyMake_wxObject(result, 0);
42237 }
42238 return resultobj;
42239 fail:
42240 return NULL;
42241 }
42242
42243
42244 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42245 PyObject *obj;
42246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42247 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42248 return SWIG_Py_Void();
42249 }
42250
42251 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42252 return SWIG_Python_InitShadowInstance(args);
42253 }
42254
42255 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42256 PyObject *resultobj = 0;
42257 long arg1 = (long) 0 ;
42258 wxMenuBar *result = 0 ;
42259 long val1 ;
42260 int ecode1 = 0 ;
42261 PyObject * obj0 = 0 ;
42262 char * kwnames[] = {
42263 (char *) "style", NULL
42264 };
42265
42266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42267 if (obj0) {
42268 ecode1 = SWIG_AsVal_long(obj0, &val1);
42269 if (!SWIG_IsOK(ecode1)) {
42270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42271 }
42272 arg1 = static_cast< long >(val1);
42273 }
42274 {
42275 if (!wxPyCheckForApp()) SWIG_fail;
42276 PyThreadState* __tstate = wxPyBeginAllowThreads();
42277 result = (wxMenuBar *)new wxMenuBar(arg1);
42278 wxPyEndAllowThreads(__tstate);
42279 if (PyErr_Occurred()) SWIG_fail;
42280 }
42281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42282 return resultobj;
42283 fail:
42284 return NULL;
42285 }
42286
42287
42288 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42289 PyObject *resultobj = 0;
42290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42291 wxMenu *arg2 = (wxMenu *) 0 ;
42292 wxString *arg3 = 0 ;
42293 bool result;
42294 void *argp1 = 0 ;
42295 int res1 = 0 ;
42296 void *argp2 = 0 ;
42297 int res2 = 0 ;
42298 bool temp3 = false ;
42299 PyObject * obj0 = 0 ;
42300 PyObject * obj1 = 0 ;
42301 PyObject * obj2 = 0 ;
42302 char * kwnames[] = {
42303 (char *) "self",(char *) "menu",(char *) "title", NULL
42304 };
42305
42306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42308 if (!SWIG_IsOK(res1)) {
42309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42310 }
42311 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42313 if (!SWIG_IsOK(res2)) {
42314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42315 }
42316 arg2 = reinterpret_cast< wxMenu * >(argp2);
42317 {
42318 arg3 = wxString_in_helper(obj2);
42319 if (arg3 == NULL) SWIG_fail;
42320 temp3 = true;
42321 }
42322 {
42323 PyThreadState* __tstate = wxPyBeginAllowThreads();
42324 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42325 wxPyEndAllowThreads(__tstate);
42326 if (PyErr_Occurred()) SWIG_fail;
42327 }
42328 {
42329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42330 }
42331 {
42332 if (temp3)
42333 delete arg3;
42334 }
42335 return resultobj;
42336 fail:
42337 {
42338 if (temp3)
42339 delete arg3;
42340 }
42341 return NULL;
42342 }
42343
42344
42345 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42346 PyObject *resultobj = 0;
42347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42348 size_t arg2 ;
42349 wxMenu *arg3 = (wxMenu *) 0 ;
42350 wxString *arg4 = 0 ;
42351 bool result;
42352 void *argp1 = 0 ;
42353 int res1 = 0 ;
42354 size_t val2 ;
42355 int ecode2 = 0 ;
42356 void *argp3 = 0 ;
42357 int res3 = 0 ;
42358 bool temp4 = false ;
42359 PyObject * obj0 = 0 ;
42360 PyObject * obj1 = 0 ;
42361 PyObject * obj2 = 0 ;
42362 PyObject * obj3 = 0 ;
42363 char * kwnames[] = {
42364 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42365 };
42366
42367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42369 if (!SWIG_IsOK(res1)) {
42370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42371 }
42372 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42373 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42374 if (!SWIG_IsOK(ecode2)) {
42375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42376 }
42377 arg2 = static_cast< size_t >(val2);
42378 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42379 if (!SWIG_IsOK(res3)) {
42380 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42381 }
42382 arg3 = reinterpret_cast< wxMenu * >(argp3);
42383 {
42384 arg4 = wxString_in_helper(obj3);
42385 if (arg4 == NULL) SWIG_fail;
42386 temp4 = true;
42387 }
42388 {
42389 PyThreadState* __tstate = wxPyBeginAllowThreads();
42390 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42391 wxPyEndAllowThreads(__tstate);
42392 if (PyErr_Occurred()) SWIG_fail;
42393 }
42394 {
42395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42396 }
42397 {
42398 if (temp4)
42399 delete arg4;
42400 }
42401 return resultobj;
42402 fail:
42403 {
42404 if (temp4)
42405 delete arg4;
42406 }
42407 return NULL;
42408 }
42409
42410
42411 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42412 PyObject *resultobj = 0;
42413 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42414 size_t result;
42415 void *argp1 = 0 ;
42416 int res1 = 0 ;
42417 PyObject *swig_obj[1] ;
42418
42419 if (!args) SWIG_fail;
42420 swig_obj[0] = args;
42421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42422 if (!SWIG_IsOK(res1)) {
42423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42424 }
42425 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42426 {
42427 PyThreadState* __tstate = wxPyBeginAllowThreads();
42428 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42429 wxPyEndAllowThreads(__tstate);
42430 if (PyErr_Occurred()) SWIG_fail;
42431 }
42432 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42433 return resultobj;
42434 fail:
42435 return NULL;
42436 }
42437
42438
42439 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42440 PyObject *resultobj = 0;
42441 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42442 size_t arg2 ;
42443 wxMenu *result = 0 ;
42444 void *argp1 = 0 ;
42445 int res1 = 0 ;
42446 size_t val2 ;
42447 int ecode2 = 0 ;
42448 PyObject * obj0 = 0 ;
42449 PyObject * obj1 = 0 ;
42450 char * kwnames[] = {
42451 (char *) "self",(char *) "pos", NULL
42452 };
42453
42454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42456 if (!SWIG_IsOK(res1)) {
42457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42458 }
42459 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42460 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42461 if (!SWIG_IsOK(ecode2)) {
42462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42463 }
42464 arg2 = static_cast< size_t >(val2);
42465 {
42466 PyThreadState* __tstate = wxPyBeginAllowThreads();
42467 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42468 wxPyEndAllowThreads(__tstate);
42469 if (PyErr_Occurred()) SWIG_fail;
42470 }
42471 {
42472 resultobj = wxPyMake_wxObject(result, 0);
42473 }
42474 return resultobj;
42475 fail:
42476 return NULL;
42477 }
42478
42479
42480 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42481 PyObject *resultobj = 0;
42482 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42483 size_t arg2 ;
42484 wxMenu *arg3 = (wxMenu *) 0 ;
42485 wxString *arg4 = 0 ;
42486 wxMenu *result = 0 ;
42487 void *argp1 = 0 ;
42488 int res1 = 0 ;
42489 size_t val2 ;
42490 int ecode2 = 0 ;
42491 void *argp3 = 0 ;
42492 int res3 = 0 ;
42493 bool temp4 = false ;
42494 PyObject * obj0 = 0 ;
42495 PyObject * obj1 = 0 ;
42496 PyObject * obj2 = 0 ;
42497 PyObject * obj3 = 0 ;
42498 char * kwnames[] = {
42499 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42500 };
42501
42502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42504 if (!SWIG_IsOK(res1)) {
42505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42506 }
42507 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42508 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42509 if (!SWIG_IsOK(ecode2)) {
42510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42511 }
42512 arg2 = static_cast< size_t >(val2);
42513 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42514 if (!SWIG_IsOK(res3)) {
42515 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42516 }
42517 arg3 = reinterpret_cast< wxMenu * >(argp3);
42518 {
42519 arg4 = wxString_in_helper(obj3);
42520 if (arg4 == NULL) SWIG_fail;
42521 temp4 = true;
42522 }
42523 {
42524 PyThreadState* __tstate = wxPyBeginAllowThreads();
42525 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42526 wxPyEndAllowThreads(__tstate);
42527 if (PyErr_Occurred()) SWIG_fail;
42528 }
42529 {
42530 resultobj = wxPyMake_wxObject(result, 0);
42531 }
42532 {
42533 if (temp4)
42534 delete arg4;
42535 }
42536 return resultobj;
42537 fail:
42538 {
42539 if (temp4)
42540 delete arg4;
42541 }
42542 return NULL;
42543 }
42544
42545
42546 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42547 PyObject *resultobj = 0;
42548 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42549 size_t arg2 ;
42550 wxMenu *result = 0 ;
42551 void *argp1 = 0 ;
42552 int res1 = 0 ;
42553 size_t val2 ;
42554 int ecode2 = 0 ;
42555 PyObject * obj0 = 0 ;
42556 PyObject * obj1 = 0 ;
42557 char * kwnames[] = {
42558 (char *) "self",(char *) "pos", NULL
42559 };
42560
42561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42563 if (!SWIG_IsOK(res1)) {
42564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42565 }
42566 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42567 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42568 if (!SWIG_IsOK(ecode2)) {
42569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42570 }
42571 arg2 = static_cast< size_t >(val2);
42572 {
42573 PyThreadState* __tstate = wxPyBeginAllowThreads();
42574 result = (wxMenu *)(arg1)->Remove(arg2);
42575 wxPyEndAllowThreads(__tstate);
42576 if (PyErr_Occurred()) SWIG_fail;
42577 }
42578 {
42579 resultobj = wxPyMake_wxObject(result, 0);
42580 }
42581 return resultobj;
42582 fail:
42583 return NULL;
42584 }
42585
42586
42587 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42588 PyObject *resultobj = 0;
42589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42590 size_t arg2 ;
42591 bool arg3 ;
42592 void *argp1 = 0 ;
42593 int res1 = 0 ;
42594 size_t val2 ;
42595 int ecode2 = 0 ;
42596 bool val3 ;
42597 int ecode3 = 0 ;
42598 PyObject * obj0 = 0 ;
42599 PyObject * obj1 = 0 ;
42600 PyObject * obj2 = 0 ;
42601 char * kwnames[] = {
42602 (char *) "self",(char *) "pos",(char *) "enable", NULL
42603 };
42604
42605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42607 if (!SWIG_IsOK(res1)) {
42608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42609 }
42610 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42611 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42612 if (!SWIG_IsOK(ecode2)) {
42613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42614 }
42615 arg2 = static_cast< size_t >(val2);
42616 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42617 if (!SWIG_IsOK(ecode3)) {
42618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42619 }
42620 arg3 = static_cast< bool >(val3);
42621 {
42622 PyThreadState* __tstate = wxPyBeginAllowThreads();
42623 (arg1)->EnableTop(arg2,arg3);
42624 wxPyEndAllowThreads(__tstate);
42625 if (PyErr_Occurred()) SWIG_fail;
42626 }
42627 resultobj = SWIG_Py_Void();
42628 return resultobj;
42629 fail:
42630 return NULL;
42631 }
42632
42633
42634 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42635 PyObject *resultobj = 0;
42636 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42637 size_t arg2 ;
42638 bool result;
42639 void *argp1 = 0 ;
42640 int res1 = 0 ;
42641 size_t val2 ;
42642 int ecode2 = 0 ;
42643 PyObject * obj0 = 0 ;
42644 PyObject * obj1 = 0 ;
42645 char * kwnames[] = {
42646 (char *) "self",(char *) "pos", NULL
42647 };
42648
42649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42651 if (!SWIG_IsOK(res1)) {
42652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42653 }
42654 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42656 if (!SWIG_IsOK(ecode2)) {
42657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42658 }
42659 arg2 = static_cast< size_t >(val2);
42660 {
42661 PyThreadState* __tstate = wxPyBeginAllowThreads();
42662 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42663 wxPyEndAllowThreads(__tstate);
42664 if (PyErr_Occurred()) SWIG_fail;
42665 }
42666 {
42667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42668 }
42669 return resultobj;
42670 fail:
42671 return NULL;
42672 }
42673
42674
42675 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42676 PyObject *resultobj = 0;
42677 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42678 size_t arg2 ;
42679 wxString *arg3 = 0 ;
42680 void *argp1 = 0 ;
42681 int res1 = 0 ;
42682 size_t val2 ;
42683 int ecode2 = 0 ;
42684 bool temp3 = false ;
42685 PyObject * obj0 = 0 ;
42686 PyObject * obj1 = 0 ;
42687 PyObject * obj2 = 0 ;
42688 char * kwnames[] = {
42689 (char *) "self",(char *) "pos",(char *) "label", NULL
42690 };
42691
42692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42694 if (!SWIG_IsOK(res1)) {
42695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42696 }
42697 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42698 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42699 if (!SWIG_IsOK(ecode2)) {
42700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42701 }
42702 arg2 = static_cast< size_t >(val2);
42703 {
42704 arg3 = wxString_in_helper(obj2);
42705 if (arg3 == NULL) SWIG_fail;
42706 temp3 = true;
42707 }
42708 {
42709 PyThreadState* __tstate = wxPyBeginAllowThreads();
42710 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42711 wxPyEndAllowThreads(__tstate);
42712 if (PyErr_Occurred()) SWIG_fail;
42713 }
42714 resultobj = SWIG_Py_Void();
42715 {
42716 if (temp3)
42717 delete arg3;
42718 }
42719 return resultobj;
42720 fail:
42721 {
42722 if (temp3)
42723 delete arg3;
42724 }
42725 return NULL;
42726 }
42727
42728
42729 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42730 PyObject *resultobj = 0;
42731 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42732 size_t arg2 ;
42733 wxString result;
42734 void *argp1 = 0 ;
42735 int res1 = 0 ;
42736 size_t val2 ;
42737 int ecode2 = 0 ;
42738 PyObject * obj0 = 0 ;
42739 PyObject * obj1 = 0 ;
42740 char * kwnames[] = {
42741 (char *) "self",(char *) "pos", NULL
42742 };
42743
42744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42746 if (!SWIG_IsOK(res1)) {
42747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42748 }
42749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42750 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42751 if (!SWIG_IsOK(ecode2)) {
42752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42753 }
42754 arg2 = static_cast< size_t >(val2);
42755 {
42756 PyThreadState* __tstate = wxPyBeginAllowThreads();
42757 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42758 wxPyEndAllowThreads(__tstate);
42759 if (PyErr_Occurred()) SWIG_fail;
42760 }
42761 {
42762 #if wxUSE_UNICODE
42763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42764 #else
42765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42766 #endif
42767 }
42768 return resultobj;
42769 fail:
42770 return NULL;
42771 }
42772
42773
42774 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42775 PyObject *resultobj = 0;
42776 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42777 wxString *arg2 = 0 ;
42778 wxString *arg3 = 0 ;
42779 int result;
42780 void *argp1 = 0 ;
42781 int res1 = 0 ;
42782 bool temp2 = false ;
42783 bool temp3 = false ;
42784 PyObject * obj0 = 0 ;
42785 PyObject * obj1 = 0 ;
42786 PyObject * obj2 = 0 ;
42787 char * kwnames[] = {
42788 (char *) "self",(char *) "menu",(char *) "item", NULL
42789 };
42790
42791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42793 if (!SWIG_IsOK(res1)) {
42794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42795 }
42796 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42797 {
42798 arg2 = wxString_in_helper(obj1);
42799 if (arg2 == NULL) SWIG_fail;
42800 temp2 = true;
42801 }
42802 {
42803 arg3 = wxString_in_helper(obj2);
42804 if (arg3 == NULL) SWIG_fail;
42805 temp3 = true;
42806 }
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 resultobj = SWIG_From_int(static_cast< int >(result));
42814 {
42815 if (temp2)
42816 delete arg2;
42817 }
42818 {
42819 if (temp3)
42820 delete arg3;
42821 }
42822 return resultobj;
42823 fail:
42824 {
42825 if (temp2)
42826 delete arg2;
42827 }
42828 {
42829 if (temp3)
42830 delete arg3;
42831 }
42832 return NULL;
42833 }
42834
42835
42836 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42837 PyObject *resultobj = 0;
42838 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42839 int arg2 ;
42840 wxMenuItem *result = 0 ;
42841 void *argp1 = 0 ;
42842 int res1 = 0 ;
42843 int val2 ;
42844 int ecode2 = 0 ;
42845 PyObject * obj0 = 0 ;
42846 PyObject * obj1 = 0 ;
42847 char * kwnames[] = {
42848 (char *) "self",(char *) "id", NULL
42849 };
42850
42851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42853 if (!SWIG_IsOK(res1)) {
42854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42855 }
42856 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42857 ecode2 = SWIG_AsVal_int(obj1, &val2);
42858 if (!SWIG_IsOK(ecode2)) {
42859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42860 }
42861 arg2 = static_cast< int >(val2);
42862 {
42863 PyThreadState* __tstate = wxPyBeginAllowThreads();
42864 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42865 wxPyEndAllowThreads(__tstate);
42866 if (PyErr_Occurred()) SWIG_fail;
42867 }
42868 {
42869 resultobj = wxPyMake_wxObject(result, (bool)0);
42870 }
42871 return resultobj;
42872 fail:
42873 return NULL;
42874 }
42875
42876
42877 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42878 PyObject *resultobj = 0;
42879 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42880 wxString *arg2 = 0 ;
42881 int result;
42882 void *argp1 = 0 ;
42883 int res1 = 0 ;
42884 bool temp2 = false ;
42885 PyObject * obj0 = 0 ;
42886 PyObject * obj1 = 0 ;
42887 char * kwnames[] = {
42888 (char *) "self",(char *) "title", NULL
42889 };
42890
42891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42893 if (!SWIG_IsOK(res1)) {
42894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42895 }
42896 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42897 {
42898 arg2 = wxString_in_helper(obj1);
42899 if (arg2 == NULL) SWIG_fail;
42900 temp2 = true;
42901 }
42902 {
42903 PyThreadState* __tstate = wxPyBeginAllowThreads();
42904 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42905 wxPyEndAllowThreads(__tstate);
42906 if (PyErr_Occurred()) SWIG_fail;
42907 }
42908 resultobj = SWIG_From_int(static_cast< int >(result));
42909 {
42910 if (temp2)
42911 delete arg2;
42912 }
42913 return resultobj;
42914 fail:
42915 {
42916 if (temp2)
42917 delete arg2;
42918 }
42919 return NULL;
42920 }
42921
42922
42923 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42924 PyObject *resultobj = 0;
42925 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42926 int arg2 ;
42927 bool arg3 ;
42928 void *argp1 = 0 ;
42929 int res1 = 0 ;
42930 int val2 ;
42931 int ecode2 = 0 ;
42932 bool val3 ;
42933 int ecode3 = 0 ;
42934 PyObject * obj0 = 0 ;
42935 PyObject * obj1 = 0 ;
42936 PyObject * obj2 = 0 ;
42937 char * kwnames[] = {
42938 (char *) "self",(char *) "id",(char *) "enable", NULL
42939 };
42940
42941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42943 if (!SWIG_IsOK(res1)) {
42944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42945 }
42946 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42947 ecode2 = SWIG_AsVal_int(obj1, &val2);
42948 if (!SWIG_IsOK(ecode2)) {
42949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42950 }
42951 arg2 = static_cast< int >(val2);
42952 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42953 if (!SWIG_IsOK(ecode3)) {
42954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42955 }
42956 arg3 = static_cast< bool >(val3);
42957 {
42958 PyThreadState* __tstate = wxPyBeginAllowThreads();
42959 (arg1)->Enable(arg2,arg3);
42960 wxPyEndAllowThreads(__tstate);
42961 if (PyErr_Occurred()) SWIG_fail;
42962 }
42963 resultobj = SWIG_Py_Void();
42964 return resultobj;
42965 fail:
42966 return NULL;
42967 }
42968
42969
42970 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42971 PyObject *resultobj = 0;
42972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42973 int arg2 ;
42974 bool arg3 ;
42975 void *argp1 = 0 ;
42976 int res1 = 0 ;
42977 int val2 ;
42978 int ecode2 = 0 ;
42979 bool val3 ;
42980 int ecode3 = 0 ;
42981 PyObject * obj0 = 0 ;
42982 PyObject * obj1 = 0 ;
42983 PyObject * obj2 = 0 ;
42984 char * kwnames[] = {
42985 (char *) "self",(char *) "id",(char *) "check", NULL
42986 };
42987
42988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42990 if (!SWIG_IsOK(res1)) {
42991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42992 }
42993 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42994 ecode2 = SWIG_AsVal_int(obj1, &val2);
42995 if (!SWIG_IsOK(ecode2)) {
42996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42997 }
42998 arg2 = static_cast< int >(val2);
42999 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43000 if (!SWIG_IsOK(ecode3)) {
43001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43002 }
43003 arg3 = static_cast< bool >(val3);
43004 {
43005 PyThreadState* __tstate = wxPyBeginAllowThreads();
43006 (arg1)->Check(arg2,arg3);
43007 wxPyEndAllowThreads(__tstate);
43008 if (PyErr_Occurred()) SWIG_fail;
43009 }
43010 resultobj = SWIG_Py_Void();
43011 return resultobj;
43012 fail:
43013 return NULL;
43014 }
43015
43016
43017 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43018 PyObject *resultobj = 0;
43019 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43020 int arg2 ;
43021 bool result;
43022 void *argp1 = 0 ;
43023 int res1 = 0 ;
43024 int val2 ;
43025 int ecode2 = 0 ;
43026 PyObject * obj0 = 0 ;
43027 PyObject * obj1 = 0 ;
43028 char * kwnames[] = {
43029 (char *) "self",(char *) "id", NULL
43030 };
43031
43032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43034 if (!SWIG_IsOK(res1)) {
43035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43036 }
43037 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43038 ecode2 = SWIG_AsVal_int(obj1, &val2);
43039 if (!SWIG_IsOK(ecode2)) {
43040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43041 }
43042 arg2 = static_cast< int >(val2);
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43046 wxPyEndAllowThreads(__tstate);
43047 if (PyErr_Occurred()) SWIG_fail;
43048 }
43049 {
43050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43051 }
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43059 PyObject *resultobj = 0;
43060 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43061 int arg2 ;
43062 bool result;
43063 void *argp1 = 0 ;
43064 int res1 = 0 ;
43065 int val2 ;
43066 int ecode2 = 0 ;
43067 PyObject * obj0 = 0 ;
43068 PyObject * obj1 = 0 ;
43069 char * kwnames[] = {
43070 (char *) "self",(char *) "id", NULL
43071 };
43072
43073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43075 if (!SWIG_IsOK(res1)) {
43076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43077 }
43078 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43079 ecode2 = SWIG_AsVal_int(obj1, &val2);
43080 if (!SWIG_IsOK(ecode2)) {
43081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43082 }
43083 arg2 = static_cast< int >(val2);
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43087 wxPyEndAllowThreads(__tstate);
43088 if (PyErr_Occurred()) SWIG_fail;
43089 }
43090 {
43091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43092 }
43093 return resultobj;
43094 fail:
43095 return NULL;
43096 }
43097
43098
43099 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43100 PyObject *resultobj = 0;
43101 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43102 int arg2 ;
43103 wxString *arg3 = 0 ;
43104 void *argp1 = 0 ;
43105 int res1 = 0 ;
43106 int val2 ;
43107 int ecode2 = 0 ;
43108 bool temp3 = false ;
43109 PyObject * obj0 = 0 ;
43110 PyObject * obj1 = 0 ;
43111 PyObject * obj2 = 0 ;
43112 char * kwnames[] = {
43113 (char *) "self",(char *) "id",(char *) "label", NULL
43114 };
43115
43116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43118 if (!SWIG_IsOK(res1)) {
43119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43120 }
43121 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43122 ecode2 = SWIG_AsVal_int(obj1, &val2);
43123 if (!SWIG_IsOK(ecode2)) {
43124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43125 }
43126 arg2 = static_cast< int >(val2);
43127 {
43128 arg3 = wxString_in_helper(obj2);
43129 if (arg3 == NULL) SWIG_fail;
43130 temp3 = true;
43131 }
43132 {
43133 PyThreadState* __tstate = wxPyBeginAllowThreads();
43134 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43135 wxPyEndAllowThreads(__tstate);
43136 if (PyErr_Occurred()) SWIG_fail;
43137 }
43138 resultobj = SWIG_Py_Void();
43139 {
43140 if (temp3)
43141 delete arg3;
43142 }
43143 return resultobj;
43144 fail:
43145 {
43146 if (temp3)
43147 delete arg3;
43148 }
43149 return NULL;
43150 }
43151
43152
43153 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43154 PyObject *resultobj = 0;
43155 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43156 int arg2 ;
43157 wxString result;
43158 void *argp1 = 0 ;
43159 int res1 = 0 ;
43160 int val2 ;
43161 int ecode2 = 0 ;
43162 PyObject * obj0 = 0 ;
43163 PyObject * obj1 = 0 ;
43164 char * kwnames[] = {
43165 (char *) "self",(char *) "id", NULL
43166 };
43167
43168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43170 if (!SWIG_IsOK(res1)) {
43171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43172 }
43173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43174 ecode2 = SWIG_AsVal_int(obj1, &val2);
43175 if (!SWIG_IsOK(ecode2)) {
43176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43177 }
43178 arg2 = static_cast< int >(val2);
43179 {
43180 PyThreadState* __tstate = wxPyBeginAllowThreads();
43181 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43182 wxPyEndAllowThreads(__tstate);
43183 if (PyErr_Occurred()) SWIG_fail;
43184 }
43185 {
43186 #if wxUSE_UNICODE
43187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43188 #else
43189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43190 #endif
43191 }
43192 return resultobj;
43193 fail:
43194 return NULL;
43195 }
43196
43197
43198 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43199 PyObject *resultobj = 0;
43200 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43201 int arg2 ;
43202 wxString *arg3 = 0 ;
43203 void *argp1 = 0 ;
43204 int res1 = 0 ;
43205 int val2 ;
43206 int ecode2 = 0 ;
43207 bool temp3 = false ;
43208 PyObject * obj0 = 0 ;
43209 PyObject * obj1 = 0 ;
43210 PyObject * obj2 = 0 ;
43211 char * kwnames[] = {
43212 (char *) "self",(char *) "id",(char *) "helpString", NULL
43213 };
43214
43215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43217 if (!SWIG_IsOK(res1)) {
43218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43219 }
43220 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43221 ecode2 = SWIG_AsVal_int(obj1, &val2);
43222 if (!SWIG_IsOK(ecode2)) {
43223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43224 }
43225 arg2 = static_cast< int >(val2);
43226 {
43227 arg3 = wxString_in_helper(obj2);
43228 if (arg3 == NULL) SWIG_fail;
43229 temp3 = true;
43230 }
43231 {
43232 PyThreadState* __tstate = wxPyBeginAllowThreads();
43233 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43234 wxPyEndAllowThreads(__tstate);
43235 if (PyErr_Occurred()) SWIG_fail;
43236 }
43237 resultobj = SWIG_Py_Void();
43238 {
43239 if (temp3)
43240 delete arg3;
43241 }
43242 return resultobj;
43243 fail:
43244 {
43245 if (temp3)
43246 delete arg3;
43247 }
43248 return NULL;
43249 }
43250
43251
43252 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43253 PyObject *resultobj = 0;
43254 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43255 int arg2 ;
43256 wxString result;
43257 void *argp1 = 0 ;
43258 int res1 = 0 ;
43259 int val2 ;
43260 int ecode2 = 0 ;
43261 PyObject * obj0 = 0 ;
43262 PyObject * obj1 = 0 ;
43263 char * kwnames[] = {
43264 (char *) "self",(char *) "id", NULL
43265 };
43266
43267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43269 if (!SWIG_IsOK(res1)) {
43270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43271 }
43272 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43273 ecode2 = SWIG_AsVal_int(obj1, &val2);
43274 if (!SWIG_IsOK(ecode2)) {
43275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43276 }
43277 arg2 = static_cast< int >(val2);
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 {
43285 #if wxUSE_UNICODE
43286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43287 #else
43288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43289 #endif
43290 }
43291 return resultobj;
43292 fail:
43293 return NULL;
43294 }
43295
43296
43297 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43298 PyObject *resultobj = 0;
43299 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43300 wxFrame *result = 0 ;
43301 void *argp1 = 0 ;
43302 int res1 = 0 ;
43303 PyObject *swig_obj[1] ;
43304
43305 if (!args) SWIG_fail;
43306 swig_obj[0] = args;
43307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43308 if (!SWIG_IsOK(res1)) {
43309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43310 }
43311 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43312 {
43313 PyThreadState* __tstate = wxPyBeginAllowThreads();
43314 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43315 wxPyEndAllowThreads(__tstate);
43316 if (PyErr_Occurred()) SWIG_fail;
43317 }
43318 {
43319 resultobj = wxPyMake_wxObject(result, (bool)0);
43320 }
43321 return resultobj;
43322 fail:
43323 return NULL;
43324 }
43325
43326
43327 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43328 PyObject *resultobj = 0;
43329 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43330 bool result;
43331 void *argp1 = 0 ;
43332 int res1 = 0 ;
43333 PyObject *swig_obj[1] ;
43334
43335 if (!args) SWIG_fail;
43336 swig_obj[0] = args;
43337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43338 if (!SWIG_IsOK(res1)) {
43339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43340 }
43341 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43342 {
43343 PyThreadState* __tstate = wxPyBeginAllowThreads();
43344 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43345 wxPyEndAllowThreads(__tstate);
43346 if (PyErr_Occurred()) SWIG_fail;
43347 }
43348 {
43349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43350 }
43351 return resultobj;
43352 fail:
43353 return NULL;
43354 }
43355
43356
43357 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43358 PyObject *resultobj = 0;
43359 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43360 wxFrame *arg2 = (wxFrame *) 0 ;
43361 void *argp1 = 0 ;
43362 int res1 = 0 ;
43363 void *argp2 = 0 ;
43364 int res2 = 0 ;
43365 PyObject * obj0 = 0 ;
43366 PyObject * obj1 = 0 ;
43367 char * kwnames[] = {
43368 (char *) "self",(char *) "frame", NULL
43369 };
43370
43371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43373 if (!SWIG_IsOK(res1)) {
43374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43375 }
43376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43378 if (!SWIG_IsOK(res2)) {
43379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43380 }
43381 arg2 = reinterpret_cast< wxFrame * >(argp2);
43382 {
43383 PyThreadState* __tstate = wxPyBeginAllowThreads();
43384 (arg1)->Attach(arg2);
43385 wxPyEndAllowThreads(__tstate);
43386 if (PyErr_Occurred()) SWIG_fail;
43387 }
43388 resultobj = SWIG_Py_Void();
43389 return resultobj;
43390 fail:
43391 return NULL;
43392 }
43393
43394
43395 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43396 PyObject *resultobj = 0;
43397 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43398 void *argp1 = 0 ;
43399 int res1 = 0 ;
43400 PyObject *swig_obj[1] ;
43401
43402 if (!args) SWIG_fail;
43403 swig_obj[0] = args;
43404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43405 if (!SWIG_IsOK(res1)) {
43406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43407 }
43408 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43409 {
43410 PyThreadState* __tstate = wxPyBeginAllowThreads();
43411 (arg1)->Detach();
43412 wxPyEndAllowThreads(__tstate);
43413 if (PyErr_Occurred()) SWIG_fail;
43414 }
43415 resultobj = SWIG_Py_Void();
43416 return resultobj;
43417 fail:
43418 return NULL;
43419 }
43420
43421
43422 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43423 PyObject *resultobj = 0;
43424 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43425 void *argp1 = 0 ;
43426 int res1 = 0 ;
43427 PyObject *swig_obj[1] ;
43428
43429 if (!args) SWIG_fail;
43430 swig_obj[0] = args;
43431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43432 if (!SWIG_IsOK(res1)) {
43433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43434 }
43435 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43436 {
43437 PyThreadState* __tstate = wxPyBeginAllowThreads();
43438 (arg1)->UpdateMenus();
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 resultobj = SWIG_Py_Void();
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43450 PyObject *resultobj = 0;
43451 bool arg1 ;
43452 bool val1 ;
43453 int ecode1 = 0 ;
43454 PyObject * obj0 = 0 ;
43455 char * kwnames[] = {
43456 (char *) "enable", NULL
43457 };
43458
43459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43460 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43461 if (!SWIG_IsOK(ecode1)) {
43462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43463 }
43464 arg1 = static_cast< bool >(val1);
43465 {
43466 PyThreadState* __tstate = wxPyBeginAllowThreads();
43467 wxMenuBar_SetAutoWindowMenu(arg1);
43468 wxPyEndAllowThreads(__tstate);
43469 if (PyErr_Occurred()) SWIG_fail;
43470 }
43471 resultobj = SWIG_Py_Void();
43472 return resultobj;
43473 fail:
43474 return NULL;
43475 }
43476
43477
43478 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43479 PyObject *resultobj = 0;
43480 bool result;
43481
43482 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43483 {
43484 PyThreadState* __tstate = wxPyBeginAllowThreads();
43485 result = (bool)wxMenuBar_GetAutoWindowMenu();
43486 wxPyEndAllowThreads(__tstate);
43487 if (PyErr_Occurred()) SWIG_fail;
43488 }
43489 {
43490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43491 }
43492 return resultobj;
43493 fail:
43494 return NULL;
43495 }
43496
43497
43498 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43499 PyObject *obj;
43500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43501 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43502 return SWIG_Py_Void();
43503 }
43504
43505 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43506 return SWIG_Python_InitShadowInstance(args);
43507 }
43508
43509 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43510 PyObject *resultobj = 0;
43511 wxMenu *arg1 = (wxMenu *) NULL ;
43512 int arg2 = (int) wxID_ANY ;
43513 wxString const &arg3_defvalue = wxPyEmptyString ;
43514 wxString *arg3 = (wxString *) &arg3_defvalue ;
43515 wxString const &arg4_defvalue = wxPyEmptyString ;
43516 wxString *arg4 = (wxString *) &arg4_defvalue ;
43517 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43518 wxMenu *arg6 = (wxMenu *) NULL ;
43519 wxMenuItem *result = 0 ;
43520 void *argp1 = 0 ;
43521 int res1 = 0 ;
43522 int val2 ;
43523 int ecode2 = 0 ;
43524 bool temp3 = false ;
43525 bool temp4 = false ;
43526 int val5 ;
43527 int ecode5 = 0 ;
43528 void *argp6 = 0 ;
43529 int res6 = 0 ;
43530 PyObject * obj0 = 0 ;
43531 PyObject * obj1 = 0 ;
43532 PyObject * obj2 = 0 ;
43533 PyObject * obj3 = 0 ;
43534 PyObject * obj4 = 0 ;
43535 PyObject * obj5 = 0 ;
43536 char * kwnames[] = {
43537 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43538 };
43539
43540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43541 if (obj0) {
43542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43543 if (!SWIG_IsOK(res1)) {
43544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43545 }
43546 arg1 = reinterpret_cast< wxMenu * >(argp1);
43547 }
43548 if (obj1) {
43549 ecode2 = SWIG_AsVal_int(obj1, &val2);
43550 if (!SWIG_IsOK(ecode2)) {
43551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43552 }
43553 arg2 = static_cast< int >(val2);
43554 }
43555 if (obj2) {
43556 {
43557 arg3 = wxString_in_helper(obj2);
43558 if (arg3 == NULL) SWIG_fail;
43559 temp3 = true;
43560 }
43561 }
43562 if (obj3) {
43563 {
43564 arg4 = wxString_in_helper(obj3);
43565 if (arg4 == NULL) SWIG_fail;
43566 temp4 = true;
43567 }
43568 }
43569 if (obj4) {
43570 ecode5 = SWIG_AsVal_int(obj4, &val5);
43571 if (!SWIG_IsOK(ecode5)) {
43572 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43573 }
43574 arg5 = static_cast< wxItemKind >(val5);
43575 }
43576 if (obj5) {
43577 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43578 if (!SWIG_IsOK(res6)) {
43579 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43580 }
43581 arg6 = reinterpret_cast< wxMenu * >(argp6);
43582 }
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43586 wxPyEndAllowThreads(__tstate);
43587 if (PyErr_Occurred()) SWIG_fail;
43588 }
43589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
43590 {
43591 if (temp3)
43592 delete arg3;
43593 }
43594 {
43595 if (temp4)
43596 delete arg4;
43597 }
43598 return resultobj;
43599 fail:
43600 {
43601 if (temp3)
43602 delete arg3;
43603 }
43604 {
43605 if (temp4)
43606 delete arg4;
43607 }
43608 return NULL;
43609 }
43610
43611
43612 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43613 PyObject *resultobj = 0;
43614 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43615 void *argp1 = 0 ;
43616 int res1 = 0 ;
43617 PyObject *swig_obj[1] ;
43618
43619 if (!args) SWIG_fail;
43620 swig_obj[0] = args;
43621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43622 if (!SWIG_IsOK(res1)) {
43623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43624 }
43625 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43626 {
43627 PyThreadState* __tstate = wxPyBeginAllowThreads();
43628 delete arg1;
43629
43630 wxPyEndAllowThreads(__tstate);
43631 if (PyErr_Occurred()) SWIG_fail;
43632 }
43633 resultobj = SWIG_Py_Void();
43634 return resultobj;
43635 fail:
43636 return NULL;
43637 }
43638
43639
43640 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43641 PyObject *resultobj = 0;
43642 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43643 wxMenu *result = 0 ;
43644 void *argp1 = 0 ;
43645 int res1 = 0 ;
43646 PyObject *swig_obj[1] ;
43647
43648 if (!args) SWIG_fail;
43649 swig_obj[0] = args;
43650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43651 if (!SWIG_IsOK(res1)) {
43652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43653 }
43654 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43655 {
43656 PyThreadState* __tstate = wxPyBeginAllowThreads();
43657 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43658 wxPyEndAllowThreads(__tstate);
43659 if (PyErr_Occurred()) SWIG_fail;
43660 }
43661 {
43662 resultobj = wxPyMake_wxObject(result, 0);
43663 }
43664 return resultobj;
43665 fail:
43666 return NULL;
43667 }
43668
43669
43670 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43671 PyObject *resultobj = 0;
43672 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43673 wxMenu *arg2 = (wxMenu *) 0 ;
43674 void *argp1 = 0 ;
43675 int res1 = 0 ;
43676 void *argp2 = 0 ;
43677 int res2 = 0 ;
43678 PyObject * obj0 = 0 ;
43679 PyObject * obj1 = 0 ;
43680 char * kwnames[] = {
43681 (char *) "self",(char *) "menu", NULL
43682 };
43683
43684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43686 if (!SWIG_IsOK(res1)) {
43687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43688 }
43689 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43691 if (!SWIG_IsOK(res2)) {
43692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43693 }
43694 arg2 = reinterpret_cast< wxMenu * >(argp2);
43695 {
43696 PyThreadState* __tstate = wxPyBeginAllowThreads();
43697 (arg1)->SetMenu(arg2);
43698 wxPyEndAllowThreads(__tstate);
43699 if (PyErr_Occurred()) SWIG_fail;
43700 }
43701 resultobj = SWIG_Py_Void();
43702 return resultobj;
43703 fail:
43704 return NULL;
43705 }
43706
43707
43708 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43709 PyObject *resultobj = 0;
43710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43711 int arg2 ;
43712 void *argp1 = 0 ;
43713 int res1 = 0 ;
43714 int val2 ;
43715 int ecode2 = 0 ;
43716 PyObject * obj0 = 0 ;
43717 PyObject * obj1 = 0 ;
43718 char * kwnames[] = {
43719 (char *) "self",(char *) "id", NULL
43720 };
43721
43722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43724 if (!SWIG_IsOK(res1)) {
43725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43726 }
43727 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43728 ecode2 = SWIG_AsVal_int(obj1, &val2);
43729 if (!SWIG_IsOK(ecode2)) {
43730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43731 }
43732 arg2 = static_cast< int >(val2);
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 (arg1)->SetId(arg2);
43736 wxPyEndAllowThreads(__tstate);
43737 if (PyErr_Occurred()) SWIG_fail;
43738 }
43739 resultobj = SWIG_Py_Void();
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43747 PyObject *resultobj = 0;
43748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43749 int result;
43750 void *argp1 = 0 ;
43751 int res1 = 0 ;
43752 PyObject *swig_obj[1] ;
43753
43754 if (!args) SWIG_fail;
43755 swig_obj[0] = args;
43756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43757 if (!SWIG_IsOK(res1)) {
43758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43759 }
43760 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43761 {
43762 PyThreadState* __tstate = wxPyBeginAllowThreads();
43763 result = (int)((wxMenuItem const *)arg1)->GetId();
43764 wxPyEndAllowThreads(__tstate);
43765 if (PyErr_Occurred()) SWIG_fail;
43766 }
43767 resultobj = SWIG_From_int(static_cast< int >(result));
43768 return resultobj;
43769 fail:
43770 return NULL;
43771 }
43772
43773
43774 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43775 PyObject *resultobj = 0;
43776 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43777 bool result;
43778 void *argp1 = 0 ;
43779 int res1 = 0 ;
43780 PyObject *swig_obj[1] ;
43781
43782 if (!args) SWIG_fail;
43783 swig_obj[0] = args;
43784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43785 if (!SWIG_IsOK(res1)) {
43786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43787 }
43788 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43789 {
43790 PyThreadState* __tstate = wxPyBeginAllowThreads();
43791 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43792 wxPyEndAllowThreads(__tstate);
43793 if (PyErr_Occurred()) SWIG_fail;
43794 }
43795 {
43796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43797 }
43798 return resultobj;
43799 fail:
43800 return NULL;
43801 }
43802
43803
43804 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43805 PyObject *resultobj = 0;
43806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43807 wxString *arg2 = 0 ;
43808 void *argp1 = 0 ;
43809 int res1 = 0 ;
43810 bool temp2 = false ;
43811 PyObject * obj0 = 0 ;
43812 PyObject * obj1 = 0 ;
43813 char * kwnames[] = {
43814 (char *) "self",(char *) "str", NULL
43815 };
43816
43817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43819 if (!SWIG_IsOK(res1)) {
43820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43821 }
43822 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43823 {
43824 arg2 = wxString_in_helper(obj1);
43825 if (arg2 == NULL) SWIG_fail;
43826 temp2 = true;
43827 }
43828 {
43829 PyThreadState* __tstate = wxPyBeginAllowThreads();
43830 (arg1)->SetText((wxString const &)*arg2);
43831 wxPyEndAllowThreads(__tstate);
43832 if (PyErr_Occurred()) SWIG_fail;
43833 }
43834 resultobj = SWIG_Py_Void();
43835 {
43836 if (temp2)
43837 delete arg2;
43838 }
43839 return resultobj;
43840 fail:
43841 {
43842 if (temp2)
43843 delete arg2;
43844 }
43845 return NULL;
43846 }
43847
43848
43849 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43850 PyObject *resultobj = 0;
43851 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43852 wxString result;
43853 void *argp1 = 0 ;
43854 int res1 = 0 ;
43855 PyObject *swig_obj[1] ;
43856
43857 if (!args) SWIG_fail;
43858 swig_obj[0] = args;
43859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43860 if (!SWIG_IsOK(res1)) {
43861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43862 }
43863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43864 {
43865 PyThreadState* __tstate = wxPyBeginAllowThreads();
43866 result = ((wxMenuItem const *)arg1)->GetLabel();
43867 wxPyEndAllowThreads(__tstate);
43868 if (PyErr_Occurred()) SWIG_fail;
43869 }
43870 {
43871 #if wxUSE_UNICODE
43872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43873 #else
43874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43875 #endif
43876 }
43877 return resultobj;
43878 fail:
43879 return NULL;
43880 }
43881
43882
43883 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43884 PyObject *resultobj = 0;
43885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43886 wxString *result = 0 ;
43887 void *argp1 = 0 ;
43888 int res1 = 0 ;
43889 PyObject *swig_obj[1] ;
43890
43891 if (!args) SWIG_fail;
43892 swig_obj[0] = args;
43893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43894 if (!SWIG_IsOK(res1)) {
43895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43896 }
43897 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43898 {
43899 PyThreadState* __tstate = wxPyBeginAllowThreads();
43900 {
43901 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43902 result = (wxString *) &_result_ref;
43903 }
43904 wxPyEndAllowThreads(__tstate);
43905 if (PyErr_Occurred()) SWIG_fail;
43906 }
43907 {
43908 #if wxUSE_UNICODE
43909 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43910 #else
43911 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43912 #endif
43913 }
43914 return resultobj;
43915 fail:
43916 return NULL;
43917 }
43918
43919
43920 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43921 PyObject *resultobj = 0;
43922 wxString *arg1 = 0 ;
43923 wxString result;
43924 bool temp1 = false ;
43925 PyObject * obj0 = 0 ;
43926 char * kwnames[] = {
43927 (char *) "text", NULL
43928 };
43929
43930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43931 {
43932 arg1 = wxString_in_helper(obj0);
43933 if (arg1 == NULL) SWIG_fail;
43934 temp1 = true;
43935 }
43936 {
43937 PyThreadState* __tstate = wxPyBeginAllowThreads();
43938 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43939 wxPyEndAllowThreads(__tstate);
43940 if (PyErr_Occurred()) SWIG_fail;
43941 }
43942 {
43943 #if wxUSE_UNICODE
43944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43945 #else
43946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43947 #endif
43948 }
43949 {
43950 if (temp1)
43951 delete arg1;
43952 }
43953 return resultobj;
43954 fail:
43955 {
43956 if (temp1)
43957 delete arg1;
43958 }
43959 return NULL;
43960 }
43961
43962
43963 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43964 PyObject *resultobj = 0;
43965 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43966 wxItemKind result;
43967 void *argp1 = 0 ;
43968 int res1 = 0 ;
43969 PyObject *swig_obj[1] ;
43970
43971 if (!args) SWIG_fail;
43972 swig_obj[0] = args;
43973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43974 if (!SWIG_IsOK(res1)) {
43975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43976 }
43977 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43978 {
43979 PyThreadState* __tstate = wxPyBeginAllowThreads();
43980 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43981 wxPyEndAllowThreads(__tstate);
43982 if (PyErr_Occurred()) SWIG_fail;
43983 }
43984 resultobj = SWIG_From_int(static_cast< int >(result));
43985 return resultobj;
43986 fail:
43987 return NULL;
43988 }
43989
43990
43991 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43992 PyObject *resultobj = 0;
43993 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43994 wxItemKind arg2 ;
43995 void *argp1 = 0 ;
43996 int res1 = 0 ;
43997 int val2 ;
43998 int ecode2 = 0 ;
43999 PyObject * obj0 = 0 ;
44000 PyObject * obj1 = 0 ;
44001 char * kwnames[] = {
44002 (char *) "self",(char *) "kind", NULL
44003 };
44004
44005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44007 if (!SWIG_IsOK(res1)) {
44008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44009 }
44010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44011 ecode2 = SWIG_AsVal_int(obj1, &val2);
44012 if (!SWIG_IsOK(ecode2)) {
44013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44014 }
44015 arg2 = static_cast< wxItemKind >(val2);
44016 {
44017 PyThreadState* __tstate = wxPyBeginAllowThreads();
44018 (arg1)->SetKind(arg2);
44019 wxPyEndAllowThreads(__tstate);
44020 if (PyErr_Occurred()) SWIG_fail;
44021 }
44022 resultobj = SWIG_Py_Void();
44023 return resultobj;
44024 fail:
44025 return NULL;
44026 }
44027
44028
44029 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44030 PyObject *resultobj = 0;
44031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44032 bool arg2 ;
44033 void *argp1 = 0 ;
44034 int res1 = 0 ;
44035 bool val2 ;
44036 int ecode2 = 0 ;
44037 PyObject * obj0 = 0 ;
44038 PyObject * obj1 = 0 ;
44039 char * kwnames[] = {
44040 (char *) "self",(char *) "checkable", NULL
44041 };
44042
44043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44045 if (!SWIG_IsOK(res1)) {
44046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44047 }
44048 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44050 if (!SWIG_IsOK(ecode2)) {
44051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44052 }
44053 arg2 = static_cast< bool >(val2);
44054 {
44055 PyThreadState* __tstate = wxPyBeginAllowThreads();
44056 (arg1)->SetCheckable(arg2);
44057 wxPyEndAllowThreads(__tstate);
44058 if (PyErr_Occurred()) SWIG_fail;
44059 }
44060 resultobj = SWIG_Py_Void();
44061 return resultobj;
44062 fail:
44063 return NULL;
44064 }
44065
44066
44067 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44068 PyObject *resultobj = 0;
44069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44070 bool result;
44071 void *argp1 = 0 ;
44072 int res1 = 0 ;
44073 PyObject *swig_obj[1] ;
44074
44075 if (!args) SWIG_fail;
44076 swig_obj[0] = args;
44077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44078 if (!SWIG_IsOK(res1)) {
44079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44080 }
44081 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44082 {
44083 PyThreadState* __tstate = wxPyBeginAllowThreads();
44084 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44085 wxPyEndAllowThreads(__tstate);
44086 if (PyErr_Occurred()) SWIG_fail;
44087 }
44088 {
44089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44090 }
44091 return resultobj;
44092 fail:
44093 return NULL;
44094 }
44095
44096
44097 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44098 PyObject *resultobj = 0;
44099 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44100 bool result;
44101 void *argp1 = 0 ;
44102 int res1 = 0 ;
44103 PyObject *swig_obj[1] ;
44104
44105 if (!args) SWIG_fail;
44106 swig_obj[0] = args;
44107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44108 if (!SWIG_IsOK(res1)) {
44109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44110 }
44111 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44112 {
44113 PyThreadState* __tstate = wxPyBeginAllowThreads();
44114 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44115 wxPyEndAllowThreads(__tstate);
44116 if (PyErr_Occurred()) SWIG_fail;
44117 }
44118 {
44119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44120 }
44121 return resultobj;
44122 fail:
44123 return NULL;
44124 }
44125
44126
44127 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44128 PyObject *resultobj = 0;
44129 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44130 wxMenu *arg2 = (wxMenu *) 0 ;
44131 void *argp1 = 0 ;
44132 int res1 = 0 ;
44133 void *argp2 = 0 ;
44134 int res2 = 0 ;
44135 PyObject * obj0 = 0 ;
44136 PyObject * obj1 = 0 ;
44137 char * kwnames[] = {
44138 (char *) "self",(char *) "menu", NULL
44139 };
44140
44141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44143 if (!SWIG_IsOK(res1)) {
44144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44145 }
44146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44148 if (!SWIG_IsOK(res2)) {
44149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44150 }
44151 arg2 = reinterpret_cast< wxMenu * >(argp2);
44152 {
44153 PyThreadState* __tstate = wxPyBeginAllowThreads();
44154 (arg1)->SetSubMenu(arg2);
44155 wxPyEndAllowThreads(__tstate);
44156 if (PyErr_Occurred()) SWIG_fail;
44157 }
44158 resultobj = SWIG_Py_Void();
44159 return resultobj;
44160 fail:
44161 return NULL;
44162 }
44163
44164
44165 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44166 PyObject *resultobj = 0;
44167 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44168 wxMenu *result = 0 ;
44169 void *argp1 = 0 ;
44170 int res1 = 0 ;
44171 PyObject *swig_obj[1] ;
44172
44173 if (!args) SWIG_fail;
44174 swig_obj[0] = args;
44175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44176 if (!SWIG_IsOK(res1)) {
44177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44178 }
44179 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44180 {
44181 PyThreadState* __tstate = wxPyBeginAllowThreads();
44182 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44183 wxPyEndAllowThreads(__tstate);
44184 if (PyErr_Occurred()) SWIG_fail;
44185 }
44186 {
44187 resultobj = wxPyMake_wxObject(result, 0);
44188 }
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44196 PyObject *resultobj = 0;
44197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44198 bool arg2 = (bool) true ;
44199 void *argp1 = 0 ;
44200 int res1 = 0 ;
44201 bool val2 ;
44202 int ecode2 = 0 ;
44203 PyObject * obj0 = 0 ;
44204 PyObject * obj1 = 0 ;
44205 char * kwnames[] = {
44206 (char *) "self",(char *) "enable", NULL
44207 };
44208
44209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44211 if (!SWIG_IsOK(res1)) {
44212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44213 }
44214 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44215 if (obj1) {
44216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44217 if (!SWIG_IsOK(ecode2)) {
44218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44219 }
44220 arg2 = static_cast< bool >(val2);
44221 }
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 (arg1)->Enable(arg2);
44225 wxPyEndAllowThreads(__tstate);
44226 if (PyErr_Occurred()) SWIG_fail;
44227 }
44228 resultobj = SWIG_Py_Void();
44229 return resultobj;
44230 fail:
44231 return NULL;
44232 }
44233
44234
44235 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44236 PyObject *resultobj = 0;
44237 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44238 bool result;
44239 void *argp1 = 0 ;
44240 int res1 = 0 ;
44241 PyObject *swig_obj[1] ;
44242
44243 if (!args) SWIG_fail;
44244 swig_obj[0] = args;
44245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44248 }
44249 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44250 {
44251 PyThreadState* __tstate = wxPyBeginAllowThreads();
44252 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44253 wxPyEndAllowThreads(__tstate);
44254 if (PyErr_Occurred()) SWIG_fail;
44255 }
44256 {
44257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44258 }
44259 return resultobj;
44260 fail:
44261 return NULL;
44262 }
44263
44264
44265 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44266 PyObject *resultobj = 0;
44267 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44268 bool arg2 = (bool) true ;
44269 void *argp1 = 0 ;
44270 int res1 = 0 ;
44271 bool val2 ;
44272 int ecode2 = 0 ;
44273 PyObject * obj0 = 0 ;
44274 PyObject * obj1 = 0 ;
44275 char * kwnames[] = {
44276 (char *) "self",(char *) "check", NULL
44277 };
44278
44279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44281 if (!SWIG_IsOK(res1)) {
44282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44283 }
44284 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44285 if (obj1) {
44286 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44287 if (!SWIG_IsOK(ecode2)) {
44288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44289 }
44290 arg2 = static_cast< bool >(val2);
44291 }
44292 {
44293 PyThreadState* __tstate = wxPyBeginAllowThreads();
44294 (arg1)->Check(arg2);
44295 wxPyEndAllowThreads(__tstate);
44296 if (PyErr_Occurred()) SWIG_fail;
44297 }
44298 resultobj = SWIG_Py_Void();
44299 return resultobj;
44300 fail:
44301 return NULL;
44302 }
44303
44304
44305 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44306 PyObject *resultobj = 0;
44307 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44308 bool result;
44309 void *argp1 = 0 ;
44310 int res1 = 0 ;
44311 PyObject *swig_obj[1] ;
44312
44313 if (!args) SWIG_fail;
44314 swig_obj[0] = args;
44315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44316 if (!SWIG_IsOK(res1)) {
44317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44318 }
44319 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44320 {
44321 PyThreadState* __tstate = wxPyBeginAllowThreads();
44322 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44323 wxPyEndAllowThreads(__tstate);
44324 if (PyErr_Occurred()) SWIG_fail;
44325 }
44326 {
44327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44328 }
44329 return resultobj;
44330 fail:
44331 return NULL;
44332 }
44333
44334
44335 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44336 PyObject *resultobj = 0;
44337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44338 void *argp1 = 0 ;
44339 int res1 = 0 ;
44340 PyObject *swig_obj[1] ;
44341
44342 if (!args) SWIG_fail;
44343 swig_obj[0] = args;
44344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44345 if (!SWIG_IsOK(res1)) {
44346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44347 }
44348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44349 {
44350 PyThreadState* __tstate = wxPyBeginAllowThreads();
44351 (arg1)->Toggle();
44352 wxPyEndAllowThreads(__tstate);
44353 if (PyErr_Occurred()) SWIG_fail;
44354 }
44355 resultobj = SWIG_Py_Void();
44356 return resultobj;
44357 fail:
44358 return NULL;
44359 }
44360
44361
44362 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44363 PyObject *resultobj = 0;
44364 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44365 wxString *arg2 = 0 ;
44366 void *argp1 = 0 ;
44367 int res1 = 0 ;
44368 bool temp2 = false ;
44369 PyObject * obj0 = 0 ;
44370 PyObject * obj1 = 0 ;
44371 char * kwnames[] = {
44372 (char *) "self",(char *) "str", NULL
44373 };
44374
44375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44377 if (!SWIG_IsOK(res1)) {
44378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44379 }
44380 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44381 {
44382 arg2 = wxString_in_helper(obj1);
44383 if (arg2 == NULL) SWIG_fail;
44384 temp2 = true;
44385 }
44386 {
44387 PyThreadState* __tstate = wxPyBeginAllowThreads();
44388 (arg1)->SetHelp((wxString const &)*arg2);
44389 wxPyEndAllowThreads(__tstate);
44390 if (PyErr_Occurred()) SWIG_fail;
44391 }
44392 resultobj = SWIG_Py_Void();
44393 {
44394 if (temp2)
44395 delete arg2;
44396 }
44397 return resultobj;
44398 fail:
44399 {
44400 if (temp2)
44401 delete arg2;
44402 }
44403 return NULL;
44404 }
44405
44406
44407 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44408 PyObject *resultobj = 0;
44409 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44410 wxString *result = 0 ;
44411 void *argp1 = 0 ;
44412 int res1 = 0 ;
44413 PyObject *swig_obj[1] ;
44414
44415 if (!args) SWIG_fail;
44416 swig_obj[0] = args;
44417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44418 if (!SWIG_IsOK(res1)) {
44419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44420 }
44421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44422 {
44423 PyThreadState* __tstate = wxPyBeginAllowThreads();
44424 {
44425 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44426 result = (wxString *) &_result_ref;
44427 }
44428 wxPyEndAllowThreads(__tstate);
44429 if (PyErr_Occurred()) SWIG_fail;
44430 }
44431 {
44432 #if wxUSE_UNICODE
44433 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44434 #else
44435 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44436 #endif
44437 }
44438 return resultobj;
44439 fail:
44440 return NULL;
44441 }
44442
44443
44444 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44445 PyObject *resultobj = 0;
44446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44447 wxAcceleratorEntry *result = 0 ;
44448 void *argp1 = 0 ;
44449 int res1 = 0 ;
44450 PyObject *swig_obj[1] ;
44451
44452 if (!args) SWIG_fail;
44453 swig_obj[0] = args;
44454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44455 if (!SWIG_IsOK(res1)) {
44456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44457 }
44458 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44459 {
44460 PyThreadState* __tstate = wxPyBeginAllowThreads();
44461 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44462 wxPyEndAllowThreads(__tstate);
44463 if (PyErr_Occurred()) SWIG_fail;
44464 }
44465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44466 return resultobj;
44467 fail:
44468 return NULL;
44469 }
44470
44471
44472 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44473 PyObject *resultobj = 0;
44474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44475 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44476 void *argp1 = 0 ;
44477 int res1 = 0 ;
44478 void *argp2 = 0 ;
44479 int res2 = 0 ;
44480 PyObject * obj0 = 0 ;
44481 PyObject * obj1 = 0 ;
44482 char * kwnames[] = {
44483 (char *) "self",(char *) "accel", NULL
44484 };
44485
44486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44488 if (!SWIG_IsOK(res1)) {
44489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44490 }
44491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44493 if (!SWIG_IsOK(res2)) {
44494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44495 }
44496 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44497 {
44498 PyThreadState* __tstate = wxPyBeginAllowThreads();
44499 (arg1)->SetAccel(arg2);
44500 wxPyEndAllowThreads(__tstate);
44501 if (PyErr_Occurred()) SWIG_fail;
44502 }
44503 resultobj = SWIG_Py_Void();
44504 return resultobj;
44505 fail:
44506 return NULL;
44507 }
44508
44509
44510 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44511 PyObject *resultobj = 0;
44512 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44513 wxBitmap *arg2 = 0 ;
44514 void *argp1 = 0 ;
44515 int res1 = 0 ;
44516 void *argp2 = 0 ;
44517 int res2 = 0 ;
44518 PyObject * obj0 = 0 ;
44519 PyObject * obj1 = 0 ;
44520 char * kwnames[] = {
44521 (char *) "self",(char *) "bitmap", NULL
44522 };
44523
44524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44526 if (!SWIG_IsOK(res1)) {
44527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44528 }
44529 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44530 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44531 if (!SWIG_IsOK(res2)) {
44532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44533 }
44534 if (!argp2) {
44535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44536 }
44537 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44538 {
44539 PyThreadState* __tstate = wxPyBeginAllowThreads();
44540 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44541 wxPyEndAllowThreads(__tstate);
44542 if (PyErr_Occurred()) SWIG_fail;
44543 }
44544 resultobj = SWIG_Py_Void();
44545 return resultobj;
44546 fail:
44547 return NULL;
44548 }
44549
44550
44551 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44552 PyObject *resultobj = 0;
44553 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44554 wxBitmap *result = 0 ;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 PyObject *swig_obj[1] ;
44558
44559 if (!args) SWIG_fail;
44560 swig_obj[0] = args;
44561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44562 if (!SWIG_IsOK(res1)) {
44563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44564 }
44565 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44566 {
44567 PyThreadState* __tstate = wxPyBeginAllowThreads();
44568 {
44569 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44570 result = (wxBitmap *) &_result_ref;
44571 }
44572 wxPyEndAllowThreads(__tstate);
44573 if (PyErr_Occurred()) SWIG_fail;
44574 }
44575 {
44576 wxBitmap* resultptr = new wxBitmap(*result);
44577 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44578 }
44579 return resultobj;
44580 fail:
44581 return NULL;
44582 }
44583
44584
44585 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44586 PyObject *resultobj = 0;
44587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44588 wxFont *arg2 = 0 ;
44589 void *argp1 = 0 ;
44590 int res1 = 0 ;
44591 void *argp2 = 0 ;
44592 int res2 = 0 ;
44593 PyObject * obj0 = 0 ;
44594 PyObject * obj1 = 0 ;
44595 char * kwnames[] = {
44596 (char *) "self",(char *) "font", NULL
44597 };
44598
44599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44601 if (!SWIG_IsOK(res1)) {
44602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44603 }
44604 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44606 if (!SWIG_IsOK(res2)) {
44607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44608 }
44609 if (!argp2) {
44610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44611 }
44612 arg2 = reinterpret_cast< wxFont * >(argp2);
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 resultobj = SWIG_Py_Void();
44620 return resultobj;
44621 fail:
44622 return NULL;
44623 }
44624
44625
44626 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44627 PyObject *resultobj = 0;
44628 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44629 wxFont result;
44630 void *argp1 = 0 ;
44631 int res1 = 0 ;
44632 PyObject *swig_obj[1] ;
44633
44634 if (!args) SWIG_fail;
44635 swig_obj[0] = args;
44636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44637 if (!SWIG_IsOK(res1)) {
44638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44639 }
44640 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44641 {
44642 PyThreadState* __tstate = wxPyBeginAllowThreads();
44643 result = wxMenuItem_GetFont(arg1);
44644 wxPyEndAllowThreads(__tstate);
44645 if (PyErr_Occurred()) SWIG_fail;
44646 }
44647 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44648 return resultobj;
44649 fail:
44650 return NULL;
44651 }
44652
44653
44654 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44655 PyObject *resultobj = 0;
44656 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44657 wxColour *arg2 = 0 ;
44658 void *argp1 = 0 ;
44659 int res1 = 0 ;
44660 wxColour temp2 ;
44661 PyObject * obj0 = 0 ;
44662 PyObject * obj1 = 0 ;
44663 char * kwnames[] = {
44664 (char *) "self",(char *) "colText", NULL
44665 };
44666
44667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44669 if (!SWIG_IsOK(res1)) {
44670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44671 }
44672 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44673 {
44674 arg2 = &temp2;
44675 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44676 }
44677 {
44678 PyThreadState* __tstate = wxPyBeginAllowThreads();
44679 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44680 wxPyEndAllowThreads(__tstate);
44681 if (PyErr_Occurred()) SWIG_fail;
44682 }
44683 resultobj = SWIG_Py_Void();
44684 return resultobj;
44685 fail:
44686 return NULL;
44687 }
44688
44689
44690 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44691 PyObject *resultobj = 0;
44692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44693 wxColour result;
44694 void *argp1 = 0 ;
44695 int res1 = 0 ;
44696 PyObject *swig_obj[1] ;
44697
44698 if (!args) SWIG_fail;
44699 swig_obj[0] = args;
44700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44701 if (!SWIG_IsOK(res1)) {
44702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44703 }
44704 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44705 {
44706 PyThreadState* __tstate = wxPyBeginAllowThreads();
44707 result = wxMenuItem_GetTextColour(arg1);
44708 wxPyEndAllowThreads(__tstate);
44709 if (PyErr_Occurred()) SWIG_fail;
44710 }
44711 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44712 return resultobj;
44713 fail:
44714 return NULL;
44715 }
44716
44717
44718 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44719 PyObject *resultobj = 0;
44720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44721 wxColour *arg2 = 0 ;
44722 void *argp1 = 0 ;
44723 int res1 = 0 ;
44724 wxColour temp2 ;
44725 PyObject * obj0 = 0 ;
44726 PyObject * obj1 = 0 ;
44727 char * kwnames[] = {
44728 (char *) "self",(char *) "colBack", NULL
44729 };
44730
44731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44733 if (!SWIG_IsOK(res1)) {
44734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44735 }
44736 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44737 {
44738 arg2 = &temp2;
44739 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44740 }
44741 {
44742 PyThreadState* __tstate = wxPyBeginAllowThreads();
44743 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44744 wxPyEndAllowThreads(__tstate);
44745 if (PyErr_Occurred()) SWIG_fail;
44746 }
44747 resultobj = SWIG_Py_Void();
44748 return resultobj;
44749 fail:
44750 return NULL;
44751 }
44752
44753
44754 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44755 PyObject *resultobj = 0;
44756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44757 wxColour result;
44758 void *argp1 = 0 ;
44759 int res1 = 0 ;
44760 PyObject *swig_obj[1] ;
44761
44762 if (!args) SWIG_fail;
44763 swig_obj[0] = args;
44764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44765 if (!SWIG_IsOK(res1)) {
44766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44767 }
44768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44769 {
44770 PyThreadState* __tstate = wxPyBeginAllowThreads();
44771 result = wxMenuItem_GetBackgroundColour(arg1);
44772 wxPyEndAllowThreads(__tstate);
44773 if (PyErr_Occurred()) SWIG_fail;
44774 }
44775 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44776 return resultobj;
44777 fail:
44778 return NULL;
44779 }
44780
44781
44782 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44783 PyObject *resultobj = 0;
44784 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44785 wxBitmap *arg2 = 0 ;
44786 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44787 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44788 void *argp1 = 0 ;
44789 int res1 = 0 ;
44790 void *argp2 = 0 ;
44791 int res2 = 0 ;
44792 void *argp3 = 0 ;
44793 int res3 = 0 ;
44794 PyObject * obj0 = 0 ;
44795 PyObject * obj1 = 0 ;
44796 PyObject * obj2 = 0 ;
44797 char * kwnames[] = {
44798 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44799 };
44800
44801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44803 if (!SWIG_IsOK(res1)) {
44804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44805 }
44806 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44807 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44808 if (!SWIG_IsOK(res2)) {
44809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44810 }
44811 if (!argp2) {
44812 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44813 }
44814 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44815 if (obj2) {
44816 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44817 if (!SWIG_IsOK(res3)) {
44818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44819 }
44820 if (!argp3) {
44821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44822 }
44823 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44824 }
44825 {
44826 PyThreadState* __tstate = wxPyBeginAllowThreads();
44827 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44828 wxPyEndAllowThreads(__tstate);
44829 if (PyErr_Occurred()) SWIG_fail;
44830 }
44831 resultobj = SWIG_Py_Void();
44832 return resultobj;
44833 fail:
44834 return NULL;
44835 }
44836
44837
44838 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44839 PyObject *resultobj = 0;
44840 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44841 wxBitmap *arg2 = 0 ;
44842 void *argp1 = 0 ;
44843 int res1 = 0 ;
44844 void *argp2 = 0 ;
44845 int res2 = 0 ;
44846 PyObject * obj0 = 0 ;
44847 PyObject * obj1 = 0 ;
44848 char * kwnames[] = {
44849 (char *) "self",(char *) "bmpDisabled", NULL
44850 };
44851
44852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44854 if (!SWIG_IsOK(res1)) {
44855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44856 }
44857 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44858 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44859 if (!SWIG_IsOK(res2)) {
44860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44861 }
44862 if (!argp2) {
44863 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44864 }
44865 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44866 {
44867 PyThreadState* __tstate = wxPyBeginAllowThreads();
44868 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44869 wxPyEndAllowThreads(__tstate);
44870 if (PyErr_Occurred()) SWIG_fail;
44871 }
44872 resultobj = SWIG_Py_Void();
44873 return resultobj;
44874 fail:
44875 return NULL;
44876 }
44877
44878
44879 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44880 PyObject *resultobj = 0;
44881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44882 wxBitmap *result = 0 ;
44883 void *argp1 = 0 ;
44884 int res1 = 0 ;
44885 PyObject *swig_obj[1] ;
44886
44887 if (!args) SWIG_fail;
44888 swig_obj[0] = args;
44889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44890 if (!SWIG_IsOK(res1)) {
44891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44892 }
44893 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 {
44897 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44898 result = (wxBitmap *) &_result_ref;
44899 }
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 {
44904 wxBitmap* resultptr = new wxBitmap(*result);
44905 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44906 }
44907 return resultobj;
44908 fail:
44909 return NULL;
44910 }
44911
44912
44913 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44914 PyObject *resultobj = 0;
44915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44916 int arg2 ;
44917 void *argp1 = 0 ;
44918 int res1 = 0 ;
44919 int val2 ;
44920 int ecode2 = 0 ;
44921 PyObject * obj0 = 0 ;
44922 PyObject * obj1 = 0 ;
44923 char * kwnames[] = {
44924 (char *) "self",(char *) "nWidth", NULL
44925 };
44926
44927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44929 if (!SWIG_IsOK(res1)) {
44930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44931 }
44932 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44933 ecode2 = SWIG_AsVal_int(obj1, &val2);
44934 if (!SWIG_IsOK(ecode2)) {
44935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44936 }
44937 arg2 = static_cast< int >(val2);
44938 {
44939 PyThreadState* __tstate = wxPyBeginAllowThreads();
44940 wxMenuItem_SetMarginWidth(arg1,arg2);
44941 wxPyEndAllowThreads(__tstate);
44942 if (PyErr_Occurred()) SWIG_fail;
44943 }
44944 resultobj = SWIG_Py_Void();
44945 return resultobj;
44946 fail:
44947 return NULL;
44948 }
44949
44950
44951 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44952 PyObject *resultobj = 0;
44953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44954 int result;
44955 void *argp1 = 0 ;
44956 int res1 = 0 ;
44957 PyObject *swig_obj[1] ;
44958
44959 if (!args) SWIG_fail;
44960 swig_obj[0] = args;
44961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44962 if (!SWIG_IsOK(res1)) {
44963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44964 }
44965 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44966 {
44967 PyThreadState* __tstate = wxPyBeginAllowThreads();
44968 result = (int)wxMenuItem_GetMarginWidth(arg1);
44969 wxPyEndAllowThreads(__tstate);
44970 if (PyErr_Occurred()) SWIG_fail;
44971 }
44972 resultobj = SWIG_From_int(static_cast< int >(result));
44973 return resultobj;
44974 fail:
44975 return NULL;
44976 }
44977
44978
44979 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44980 PyObject *resultobj = 0;
44981 int result;
44982
44983 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44984 {
44985 PyThreadState* __tstate = wxPyBeginAllowThreads();
44986 result = (int)wxMenuItem_GetDefaultMarginWidth();
44987 wxPyEndAllowThreads(__tstate);
44988 if (PyErr_Occurred()) SWIG_fail;
44989 }
44990 resultobj = SWIG_From_int(static_cast< int >(result));
44991 return resultobj;
44992 fail:
44993 return NULL;
44994 }
44995
44996
44997 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44998 PyObject *resultobj = 0;
44999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45000 bool result;
45001 void *argp1 = 0 ;
45002 int res1 = 0 ;
45003 PyObject *swig_obj[1] ;
45004
45005 if (!args) SWIG_fail;
45006 swig_obj[0] = args;
45007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45008 if (!SWIG_IsOK(res1)) {
45009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45010 }
45011 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45012 {
45013 PyThreadState* __tstate = wxPyBeginAllowThreads();
45014 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
45015 wxPyEndAllowThreads(__tstate);
45016 if (PyErr_Occurred()) SWIG_fail;
45017 }
45018 {
45019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45020 }
45021 return resultobj;
45022 fail:
45023 return NULL;
45024 }
45025
45026
45027 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45028 PyObject *resultobj = 0;
45029 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45030 bool arg2 = (bool) true ;
45031 void *argp1 = 0 ;
45032 int res1 = 0 ;
45033 bool val2 ;
45034 int ecode2 = 0 ;
45035 PyObject * obj0 = 0 ;
45036 PyObject * obj1 = 0 ;
45037 char * kwnames[] = {
45038 (char *) "self",(char *) "ownerDrawn", NULL
45039 };
45040
45041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45043 if (!SWIG_IsOK(res1)) {
45044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45045 }
45046 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45047 if (obj1) {
45048 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45049 if (!SWIG_IsOK(ecode2)) {
45050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45051 }
45052 arg2 = static_cast< bool >(val2);
45053 }
45054 {
45055 PyThreadState* __tstate = wxPyBeginAllowThreads();
45056 wxMenuItem_SetOwnerDrawn(arg1,arg2);
45057 wxPyEndAllowThreads(__tstate);
45058 if (PyErr_Occurred()) SWIG_fail;
45059 }
45060 resultobj = SWIG_Py_Void();
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45068 PyObject *resultobj = 0;
45069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45070 void *argp1 = 0 ;
45071 int res1 = 0 ;
45072 PyObject *swig_obj[1] ;
45073
45074 if (!args) SWIG_fail;
45075 swig_obj[0] = args;
45076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45077 if (!SWIG_IsOK(res1)) {
45078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45079 }
45080 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45081 {
45082 PyThreadState* __tstate = wxPyBeginAllowThreads();
45083 wxMenuItem_ResetOwnerDrawn(arg1);
45084 wxPyEndAllowThreads(__tstate);
45085 if (PyErr_Occurred()) SWIG_fail;
45086 }
45087 resultobj = SWIG_Py_Void();
45088 return resultobj;
45089 fail:
45090 return NULL;
45091 }
45092
45093
45094 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45095 PyObject *obj;
45096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45097 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45098 return SWIG_Py_Void();
45099 }
45100
45101 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45102 return SWIG_Python_InitShadowInstance(args);
45103 }
45104
45105 SWIGINTERN int ControlNameStr_set(PyObject *) {
45106 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45107 return 1;
45108 }
45109
45110
45111 SWIGINTERN PyObject *ControlNameStr_get(void) {
45112 PyObject *pyobj = 0;
45113
45114 {
45115 #if wxUSE_UNICODE
45116 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45117 #else
45118 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45119 #endif
45120 }
45121 return pyobj;
45122 }
45123
45124
45125 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45126 PyObject *resultobj = 0;
45127 wxWindow *arg1 = (wxWindow *) 0 ;
45128 int arg2 = (int) -1 ;
45129 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45130 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45131 wxSize const &arg4_defvalue = wxDefaultSize ;
45132 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45133 long arg5 = (long) 0 ;
45134 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45135 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45136 wxString const &arg7_defvalue = wxPyControlNameStr ;
45137 wxString *arg7 = (wxString *) &arg7_defvalue ;
45138 wxControl *result = 0 ;
45139 void *argp1 = 0 ;
45140 int res1 = 0 ;
45141 int val2 ;
45142 int ecode2 = 0 ;
45143 wxPoint temp3 ;
45144 wxSize temp4 ;
45145 long val5 ;
45146 int ecode5 = 0 ;
45147 void *argp6 = 0 ;
45148 int res6 = 0 ;
45149 bool temp7 = false ;
45150 PyObject * obj0 = 0 ;
45151 PyObject * obj1 = 0 ;
45152 PyObject * obj2 = 0 ;
45153 PyObject * obj3 = 0 ;
45154 PyObject * obj4 = 0 ;
45155 PyObject * obj5 = 0 ;
45156 PyObject * obj6 = 0 ;
45157 char * kwnames[] = {
45158 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45159 };
45160
45161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45163 if (!SWIG_IsOK(res1)) {
45164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45165 }
45166 arg1 = reinterpret_cast< wxWindow * >(argp1);
45167 if (obj1) {
45168 ecode2 = SWIG_AsVal_int(obj1, &val2);
45169 if (!SWIG_IsOK(ecode2)) {
45170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45171 }
45172 arg2 = static_cast< int >(val2);
45173 }
45174 if (obj2) {
45175 {
45176 arg3 = &temp3;
45177 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45178 }
45179 }
45180 if (obj3) {
45181 {
45182 arg4 = &temp4;
45183 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45184 }
45185 }
45186 if (obj4) {
45187 ecode5 = SWIG_AsVal_long(obj4, &val5);
45188 if (!SWIG_IsOK(ecode5)) {
45189 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45190 }
45191 arg5 = static_cast< long >(val5);
45192 }
45193 if (obj5) {
45194 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45195 if (!SWIG_IsOK(res6)) {
45196 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45197 }
45198 if (!argp6) {
45199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45200 }
45201 arg6 = reinterpret_cast< wxValidator * >(argp6);
45202 }
45203 if (obj6) {
45204 {
45205 arg7 = wxString_in_helper(obj6);
45206 if (arg7 == NULL) SWIG_fail;
45207 temp7 = true;
45208 }
45209 }
45210 {
45211 if (!wxPyCheckForApp()) SWIG_fail;
45212 PyThreadState* __tstate = wxPyBeginAllowThreads();
45213 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45214 wxPyEndAllowThreads(__tstate);
45215 if (PyErr_Occurred()) SWIG_fail;
45216 }
45217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45218 {
45219 if (temp7)
45220 delete arg7;
45221 }
45222 return resultobj;
45223 fail:
45224 {
45225 if (temp7)
45226 delete arg7;
45227 }
45228 return NULL;
45229 }
45230
45231
45232 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45233 PyObject *resultobj = 0;
45234 wxControl *result = 0 ;
45235
45236 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45237 {
45238 if (!wxPyCheckForApp()) SWIG_fail;
45239 PyThreadState* __tstate = wxPyBeginAllowThreads();
45240 result = (wxControl *)new wxControl();
45241 wxPyEndAllowThreads(__tstate);
45242 if (PyErr_Occurred()) SWIG_fail;
45243 }
45244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45245 return resultobj;
45246 fail:
45247 return NULL;
45248 }
45249
45250
45251 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45252 PyObject *resultobj = 0;
45253 wxControl *arg1 = (wxControl *) 0 ;
45254 wxWindow *arg2 = (wxWindow *) 0 ;
45255 int arg3 = (int) -1 ;
45256 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45257 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45258 wxSize const &arg5_defvalue = wxDefaultSize ;
45259 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45260 long arg6 = (long) 0 ;
45261 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45262 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45263 wxString const &arg8_defvalue = wxPyControlNameStr ;
45264 wxString *arg8 = (wxString *) &arg8_defvalue ;
45265 bool result;
45266 void *argp1 = 0 ;
45267 int res1 = 0 ;
45268 void *argp2 = 0 ;
45269 int res2 = 0 ;
45270 int val3 ;
45271 int ecode3 = 0 ;
45272 wxPoint temp4 ;
45273 wxSize temp5 ;
45274 long val6 ;
45275 int ecode6 = 0 ;
45276 void *argp7 = 0 ;
45277 int res7 = 0 ;
45278 bool temp8 = false ;
45279 PyObject * obj0 = 0 ;
45280 PyObject * obj1 = 0 ;
45281 PyObject * obj2 = 0 ;
45282 PyObject * obj3 = 0 ;
45283 PyObject * obj4 = 0 ;
45284 PyObject * obj5 = 0 ;
45285 PyObject * obj6 = 0 ;
45286 PyObject * obj7 = 0 ;
45287 char * kwnames[] = {
45288 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45289 };
45290
45291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45293 if (!SWIG_IsOK(res1)) {
45294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45295 }
45296 arg1 = reinterpret_cast< wxControl * >(argp1);
45297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45298 if (!SWIG_IsOK(res2)) {
45299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45300 }
45301 arg2 = reinterpret_cast< wxWindow * >(argp2);
45302 if (obj2) {
45303 ecode3 = SWIG_AsVal_int(obj2, &val3);
45304 if (!SWIG_IsOK(ecode3)) {
45305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45306 }
45307 arg3 = static_cast< int >(val3);
45308 }
45309 if (obj3) {
45310 {
45311 arg4 = &temp4;
45312 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45313 }
45314 }
45315 if (obj4) {
45316 {
45317 arg5 = &temp5;
45318 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45319 }
45320 }
45321 if (obj5) {
45322 ecode6 = SWIG_AsVal_long(obj5, &val6);
45323 if (!SWIG_IsOK(ecode6)) {
45324 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45325 }
45326 arg6 = static_cast< long >(val6);
45327 }
45328 if (obj6) {
45329 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45330 if (!SWIG_IsOK(res7)) {
45331 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45332 }
45333 if (!argp7) {
45334 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45335 }
45336 arg7 = reinterpret_cast< wxValidator * >(argp7);
45337 }
45338 if (obj7) {
45339 {
45340 arg8 = wxString_in_helper(obj7);
45341 if (arg8 == NULL) SWIG_fail;
45342 temp8 = true;
45343 }
45344 }
45345 {
45346 PyThreadState* __tstate = wxPyBeginAllowThreads();
45347 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45348 wxPyEndAllowThreads(__tstate);
45349 if (PyErr_Occurred()) SWIG_fail;
45350 }
45351 {
45352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45353 }
45354 {
45355 if (temp8)
45356 delete arg8;
45357 }
45358 return resultobj;
45359 fail:
45360 {
45361 if (temp8)
45362 delete arg8;
45363 }
45364 return NULL;
45365 }
45366
45367
45368 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45369 PyObject *resultobj = 0;
45370 wxControl *arg1 = (wxControl *) 0 ;
45371 int result;
45372 void *argp1 = 0 ;
45373 int res1 = 0 ;
45374 PyObject *swig_obj[1] ;
45375
45376 if (!args) SWIG_fail;
45377 swig_obj[0] = args;
45378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45379 if (!SWIG_IsOK(res1)) {
45380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45381 }
45382 arg1 = reinterpret_cast< wxControl * >(argp1);
45383 {
45384 PyThreadState* __tstate = wxPyBeginAllowThreads();
45385 result = (int)((wxControl const *)arg1)->GetAlignment();
45386 wxPyEndAllowThreads(__tstate);
45387 if (PyErr_Occurred()) SWIG_fail;
45388 }
45389 resultobj = SWIG_From_int(static_cast< int >(result));
45390 return resultobj;
45391 fail:
45392 return NULL;
45393 }
45394
45395
45396 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45397 PyObject *resultobj = 0;
45398 wxControl *arg1 = (wxControl *) 0 ;
45399 wxString result;
45400 void *argp1 = 0 ;
45401 int res1 = 0 ;
45402 PyObject *swig_obj[1] ;
45403
45404 if (!args) SWIG_fail;
45405 swig_obj[0] = args;
45406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45407 if (!SWIG_IsOK(res1)) {
45408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45409 }
45410 arg1 = reinterpret_cast< wxControl * >(argp1);
45411 {
45412 PyThreadState* __tstate = wxPyBeginAllowThreads();
45413 result = ((wxControl const *)arg1)->GetLabelText();
45414 wxPyEndAllowThreads(__tstate);
45415 if (PyErr_Occurred()) SWIG_fail;
45416 }
45417 {
45418 #if wxUSE_UNICODE
45419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45420 #else
45421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45422 #endif
45423 }
45424 return resultobj;
45425 fail:
45426 return NULL;
45427 }
45428
45429
45430 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45431 PyObject *resultobj = 0;
45432 wxControl *arg1 = (wxControl *) 0 ;
45433 wxCommandEvent *arg2 = 0 ;
45434 void *argp1 = 0 ;
45435 int res1 = 0 ;
45436 void *argp2 = 0 ;
45437 int res2 = 0 ;
45438 PyObject * obj0 = 0 ;
45439 PyObject * obj1 = 0 ;
45440 char * kwnames[] = {
45441 (char *) "self",(char *) "event", NULL
45442 };
45443
45444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45446 if (!SWIG_IsOK(res1)) {
45447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45448 }
45449 arg1 = reinterpret_cast< wxControl * >(argp1);
45450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45451 if (!SWIG_IsOK(res2)) {
45452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45453 }
45454 if (!argp2) {
45455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45456 }
45457 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45458 {
45459 PyThreadState* __tstate = wxPyBeginAllowThreads();
45460 (arg1)->Command(*arg2);
45461 wxPyEndAllowThreads(__tstate);
45462 if (PyErr_Occurred()) SWIG_fail;
45463 }
45464 resultobj = SWIG_Py_Void();
45465 return resultobj;
45466 fail:
45467 return NULL;
45468 }
45469
45470
45471 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45472 PyObject *resultobj = 0;
45473 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45474 SwigValueWrapper<wxVisualAttributes > result;
45475 int val1 ;
45476 int ecode1 = 0 ;
45477 PyObject * obj0 = 0 ;
45478 char * kwnames[] = {
45479 (char *) "variant", NULL
45480 };
45481
45482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45483 if (obj0) {
45484 ecode1 = SWIG_AsVal_int(obj0, &val1);
45485 if (!SWIG_IsOK(ecode1)) {
45486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45487 }
45488 arg1 = static_cast< wxWindowVariant >(val1);
45489 }
45490 {
45491 if (!wxPyCheckForApp()) SWIG_fail;
45492 PyThreadState* __tstate = wxPyBeginAllowThreads();
45493 result = wxControl::GetClassDefaultAttributes(arg1);
45494 wxPyEndAllowThreads(__tstate);
45495 if (PyErr_Occurred()) SWIG_fail;
45496 }
45497 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45505 PyObject *obj;
45506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45507 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45508 return SWIG_Py_Void();
45509 }
45510
45511 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45512 return SWIG_Python_InitShadowInstance(args);
45513 }
45514
45515 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45516 PyObject *resultobj = 0;
45517 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45518 wxString *arg2 = 0 ;
45519 PyObject *arg3 = (PyObject *) NULL ;
45520 int result;
45521 void *argp1 = 0 ;
45522 int res1 = 0 ;
45523 bool temp2 = false ;
45524 PyObject * obj0 = 0 ;
45525 PyObject * obj1 = 0 ;
45526 PyObject * obj2 = 0 ;
45527 char * kwnames[] = {
45528 (char *) "self",(char *) "item",(char *) "clientData", NULL
45529 };
45530
45531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45533 if (!SWIG_IsOK(res1)) {
45534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45535 }
45536 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45537 {
45538 arg2 = wxString_in_helper(obj1);
45539 if (arg2 == NULL) SWIG_fail;
45540 temp2 = true;
45541 }
45542 if (obj2) {
45543 arg3 = obj2;
45544 }
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 resultobj = SWIG_From_int(static_cast< int >(result));
45552 {
45553 if (temp2)
45554 delete arg2;
45555 }
45556 return resultobj;
45557 fail:
45558 {
45559 if (temp2)
45560 delete arg2;
45561 }
45562 return NULL;
45563 }
45564
45565
45566 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45567 PyObject *resultobj = 0;
45568 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45569 wxArrayString *arg2 = 0 ;
45570 void *argp1 = 0 ;
45571 int res1 = 0 ;
45572 bool temp2 = false ;
45573 PyObject * obj0 = 0 ;
45574 PyObject * obj1 = 0 ;
45575 char * kwnames[] = {
45576 (char *) "self",(char *) "strings", NULL
45577 };
45578
45579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45581 if (!SWIG_IsOK(res1)) {
45582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45583 }
45584 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45585 {
45586 if (! PySequence_Check(obj1)) {
45587 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45588 SWIG_fail;
45589 }
45590 arg2 = new wxArrayString;
45591 temp2 = true;
45592 int i, len=PySequence_Length(obj1);
45593 for (i=0; i<len; i++) {
45594 PyObject* item = PySequence_GetItem(obj1, i);
45595 wxString* s = wxString_in_helper(item);
45596 if (PyErr_Occurred()) SWIG_fail;
45597 arg2->Add(*s);
45598 delete s;
45599 Py_DECREF(item);
45600 }
45601 }
45602 {
45603 PyThreadState* __tstate = wxPyBeginAllowThreads();
45604 (arg1)->Append((wxArrayString const &)*arg2);
45605 wxPyEndAllowThreads(__tstate);
45606 if (PyErr_Occurred()) SWIG_fail;
45607 }
45608 resultobj = SWIG_Py_Void();
45609 {
45610 if (temp2) delete arg2;
45611 }
45612 return resultobj;
45613 fail:
45614 {
45615 if (temp2) delete arg2;
45616 }
45617 return NULL;
45618 }
45619
45620
45621 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45622 PyObject *resultobj = 0;
45623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45624 wxString *arg2 = 0 ;
45625 unsigned int arg3 ;
45626 PyObject *arg4 = (PyObject *) NULL ;
45627 int result;
45628 void *argp1 = 0 ;
45629 int res1 = 0 ;
45630 bool temp2 = false ;
45631 unsigned int val3 ;
45632 int ecode3 = 0 ;
45633 PyObject * obj0 = 0 ;
45634 PyObject * obj1 = 0 ;
45635 PyObject * obj2 = 0 ;
45636 PyObject * obj3 = 0 ;
45637 char * kwnames[] = {
45638 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45639 };
45640
45641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45643 if (!SWIG_IsOK(res1)) {
45644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45645 }
45646 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45647 {
45648 arg2 = wxString_in_helper(obj1);
45649 if (arg2 == NULL) SWIG_fail;
45650 temp2 = true;
45651 }
45652 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45653 if (!SWIG_IsOK(ecode3)) {
45654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45655 }
45656 arg3 = static_cast< unsigned int >(val3);
45657 if (obj3) {
45658 arg4 = obj3;
45659 }
45660 {
45661 PyThreadState* __tstate = wxPyBeginAllowThreads();
45662 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45663 wxPyEndAllowThreads(__tstate);
45664 if (PyErr_Occurred()) SWIG_fail;
45665 }
45666 resultobj = SWIG_From_int(static_cast< int >(result));
45667 {
45668 if (temp2)
45669 delete arg2;
45670 }
45671 return resultobj;
45672 fail:
45673 {
45674 if (temp2)
45675 delete arg2;
45676 }
45677 return NULL;
45678 }
45679
45680
45681 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45682 PyObject *resultobj = 0;
45683 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45684 void *argp1 = 0 ;
45685 int res1 = 0 ;
45686 PyObject *swig_obj[1] ;
45687
45688 if (!args) SWIG_fail;
45689 swig_obj[0] = args;
45690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45691 if (!SWIG_IsOK(res1)) {
45692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45693 }
45694 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45695 {
45696 PyThreadState* __tstate = wxPyBeginAllowThreads();
45697 (arg1)->Clear();
45698 wxPyEndAllowThreads(__tstate);
45699 if (PyErr_Occurred()) SWIG_fail;
45700 }
45701 resultobj = SWIG_Py_Void();
45702 return resultobj;
45703 fail:
45704 return NULL;
45705 }
45706
45707
45708 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45709 PyObject *resultobj = 0;
45710 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45711 unsigned int arg2 ;
45712 void *argp1 = 0 ;
45713 int res1 = 0 ;
45714 unsigned int val2 ;
45715 int ecode2 = 0 ;
45716 PyObject * obj0 = 0 ;
45717 PyObject * obj1 = 0 ;
45718 char * kwnames[] = {
45719 (char *) "self",(char *) "n", NULL
45720 };
45721
45722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45724 if (!SWIG_IsOK(res1)) {
45725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45726 }
45727 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45728 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45729 if (!SWIG_IsOK(ecode2)) {
45730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45731 }
45732 arg2 = static_cast< unsigned int >(val2);
45733 {
45734 PyThreadState* __tstate = wxPyBeginAllowThreads();
45735 (arg1)->Delete(arg2);
45736 wxPyEndAllowThreads(__tstate);
45737 if (PyErr_Occurred()) SWIG_fail;
45738 }
45739 resultobj = SWIG_Py_Void();
45740 return resultobj;
45741 fail:
45742 return NULL;
45743 }
45744
45745
45746 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45747 PyObject *resultobj = 0;
45748 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45749 unsigned int arg2 ;
45750 PyObject *result = 0 ;
45751 void *argp1 = 0 ;
45752 int res1 = 0 ;
45753 unsigned int val2 ;
45754 int ecode2 = 0 ;
45755 PyObject * obj0 = 0 ;
45756 PyObject * obj1 = 0 ;
45757 char * kwnames[] = {
45758 (char *) "self",(char *) "n", NULL
45759 };
45760
45761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45763 if (!SWIG_IsOK(res1)) {
45764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45765 }
45766 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45767 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45768 if (!SWIG_IsOK(ecode2)) {
45769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45770 }
45771 arg2 = static_cast< unsigned int >(val2);
45772 {
45773 PyThreadState* __tstate = wxPyBeginAllowThreads();
45774 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45775 wxPyEndAllowThreads(__tstate);
45776 if (PyErr_Occurred()) SWIG_fail;
45777 }
45778 resultobj = result;
45779 return resultobj;
45780 fail:
45781 return NULL;
45782 }
45783
45784
45785 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45786 PyObject *resultobj = 0;
45787 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45788 unsigned int arg2 ;
45789 PyObject *arg3 = (PyObject *) 0 ;
45790 void *argp1 = 0 ;
45791 int res1 = 0 ;
45792 unsigned int val2 ;
45793 int ecode2 = 0 ;
45794 PyObject * obj0 = 0 ;
45795 PyObject * obj1 = 0 ;
45796 PyObject * obj2 = 0 ;
45797 char * kwnames[] = {
45798 (char *) "self",(char *) "n",(char *) "clientData", NULL
45799 };
45800
45801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45803 if (!SWIG_IsOK(res1)) {
45804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45805 }
45806 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45807 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45808 if (!SWIG_IsOK(ecode2)) {
45809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45810 }
45811 arg2 = static_cast< unsigned int >(val2);
45812 arg3 = obj2;
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 wxItemContainer_SetClientData(arg1,arg2,arg3);
45816 wxPyEndAllowThreads(__tstate);
45817 if (PyErr_Occurred()) SWIG_fail;
45818 }
45819 resultobj = SWIG_Py_Void();
45820 return resultobj;
45821 fail:
45822 return NULL;
45823 }
45824
45825
45826 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45827 PyObject *resultobj = 0;
45828 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45829 unsigned int result;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 PyObject *swig_obj[1] ;
45833
45834 if (!args) SWIG_fail;
45835 swig_obj[0] = args;
45836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45837 if (!SWIG_IsOK(res1)) {
45838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45839 }
45840 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45844 wxPyEndAllowThreads(__tstate);
45845 if (PyErr_Occurred()) SWIG_fail;
45846 }
45847 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45848 return resultobj;
45849 fail:
45850 return NULL;
45851 }
45852
45853
45854 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45855 PyObject *resultobj = 0;
45856 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45857 bool result;
45858 void *argp1 = 0 ;
45859 int res1 = 0 ;
45860 PyObject *swig_obj[1] ;
45861
45862 if (!args) SWIG_fail;
45863 swig_obj[0] = args;
45864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45865 if (!SWIG_IsOK(res1)) {
45866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45867 }
45868 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45872 wxPyEndAllowThreads(__tstate);
45873 if (PyErr_Occurred()) SWIG_fail;
45874 }
45875 {
45876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45877 }
45878 return resultobj;
45879 fail:
45880 return NULL;
45881 }
45882
45883
45884 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45885 PyObject *resultobj = 0;
45886 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45887 unsigned int arg2 ;
45888 wxString result;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 unsigned int val2 ;
45892 int ecode2 = 0 ;
45893 PyObject * obj0 = 0 ;
45894 PyObject * obj1 = 0 ;
45895 char * kwnames[] = {
45896 (char *) "self",(char *) "n", NULL
45897 };
45898
45899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45901 if (!SWIG_IsOK(res1)) {
45902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45903 }
45904 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45905 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45906 if (!SWIG_IsOK(ecode2)) {
45907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45908 }
45909 arg2 = static_cast< unsigned int >(val2);
45910 {
45911 PyThreadState* __tstate = wxPyBeginAllowThreads();
45912 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 {
45917 #if wxUSE_UNICODE
45918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45919 #else
45920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45921 #endif
45922 }
45923 return resultobj;
45924 fail:
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45930 PyObject *resultobj = 0;
45931 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45932 wxArrayString result;
45933 void *argp1 = 0 ;
45934 int res1 = 0 ;
45935 PyObject *swig_obj[1] ;
45936
45937 if (!args) SWIG_fail;
45938 swig_obj[0] = args;
45939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45942 }
45943 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45944 {
45945 PyThreadState* __tstate = wxPyBeginAllowThreads();
45946 result = ((wxItemContainer const *)arg1)->GetStrings();
45947 wxPyEndAllowThreads(__tstate);
45948 if (PyErr_Occurred()) SWIG_fail;
45949 }
45950 {
45951 resultobj = wxArrayString2PyList_helper(result);
45952 }
45953 return resultobj;
45954 fail:
45955 return NULL;
45956 }
45957
45958
45959 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45960 PyObject *resultobj = 0;
45961 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45962 unsigned int arg2 ;
45963 wxString *arg3 = 0 ;
45964 void *argp1 = 0 ;
45965 int res1 = 0 ;
45966 unsigned int val2 ;
45967 int ecode2 = 0 ;
45968 bool temp3 = false ;
45969 PyObject * obj0 = 0 ;
45970 PyObject * obj1 = 0 ;
45971 PyObject * obj2 = 0 ;
45972 char * kwnames[] = {
45973 (char *) "self",(char *) "n",(char *) "s", NULL
45974 };
45975
45976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45978 if (!SWIG_IsOK(res1)) {
45979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45980 }
45981 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45982 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45983 if (!SWIG_IsOK(ecode2)) {
45984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45985 }
45986 arg2 = static_cast< unsigned int >(val2);
45987 {
45988 arg3 = wxString_in_helper(obj2);
45989 if (arg3 == NULL) SWIG_fail;
45990 temp3 = true;
45991 }
45992 {
45993 PyThreadState* __tstate = wxPyBeginAllowThreads();
45994 (arg1)->SetString(arg2,(wxString const &)*arg3);
45995 wxPyEndAllowThreads(__tstate);
45996 if (PyErr_Occurred()) SWIG_fail;
45997 }
45998 resultobj = SWIG_Py_Void();
45999 {
46000 if (temp3)
46001 delete arg3;
46002 }
46003 return resultobj;
46004 fail:
46005 {
46006 if (temp3)
46007 delete arg3;
46008 }
46009 return NULL;
46010 }
46011
46012
46013 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46014 PyObject *resultobj = 0;
46015 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46016 wxString *arg2 = 0 ;
46017 int result;
46018 void *argp1 = 0 ;
46019 int res1 = 0 ;
46020 bool temp2 = false ;
46021 PyObject * obj0 = 0 ;
46022 PyObject * obj1 = 0 ;
46023 char * kwnames[] = {
46024 (char *) "self",(char *) "s", NULL
46025 };
46026
46027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46029 if (!SWIG_IsOK(res1)) {
46030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46031 }
46032 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46033 {
46034 arg2 = wxString_in_helper(obj1);
46035 if (arg2 == NULL) SWIG_fail;
46036 temp2 = true;
46037 }
46038 {
46039 PyThreadState* __tstate = wxPyBeginAllowThreads();
46040 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46041 wxPyEndAllowThreads(__tstate);
46042 if (PyErr_Occurred()) SWIG_fail;
46043 }
46044 resultobj = SWIG_From_int(static_cast< int >(result));
46045 {
46046 if (temp2)
46047 delete arg2;
46048 }
46049 return resultobj;
46050 fail:
46051 {
46052 if (temp2)
46053 delete arg2;
46054 }
46055 return NULL;
46056 }
46057
46058
46059 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46060 PyObject *resultobj = 0;
46061 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46062 int arg2 ;
46063 void *argp1 = 0 ;
46064 int res1 = 0 ;
46065 int val2 ;
46066 int ecode2 = 0 ;
46067 PyObject * obj0 = 0 ;
46068 PyObject * obj1 = 0 ;
46069 char * kwnames[] = {
46070 (char *) "self",(char *) "n", NULL
46071 };
46072
46073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46075 if (!SWIG_IsOK(res1)) {
46076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46077 }
46078 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46079 ecode2 = SWIG_AsVal_int(obj1, &val2);
46080 if (!SWIG_IsOK(ecode2)) {
46081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46082 }
46083 arg2 = static_cast< int >(val2);
46084 {
46085 PyThreadState* __tstate = wxPyBeginAllowThreads();
46086 (arg1)->SetSelection(arg2);
46087 wxPyEndAllowThreads(__tstate);
46088 if (PyErr_Occurred()) SWIG_fail;
46089 }
46090 resultobj = SWIG_Py_Void();
46091 return resultobj;
46092 fail:
46093 return NULL;
46094 }
46095
46096
46097 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46098 PyObject *resultobj = 0;
46099 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46100 int result;
46101 void *argp1 = 0 ;
46102 int res1 = 0 ;
46103 PyObject *swig_obj[1] ;
46104
46105 if (!args) SWIG_fail;
46106 swig_obj[0] = args;
46107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46108 if (!SWIG_IsOK(res1)) {
46109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46110 }
46111 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46112 {
46113 PyThreadState* __tstate = wxPyBeginAllowThreads();
46114 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46115 wxPyEndAllowThreads(__tstate);
46116 if (PyErr_Occurred()) SWIG_fail;
46117 }
46118 resultobj = SWIG_From_int(static_cast< int >(result));
46119 return resultobj;
46120 fail:
46121 return NULL;
46122 }
46123
46124
46125 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46126 PyObject *resultobj = 0;
46127 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46128 wxString *arg2 = 0 ;
46129 bool result;
46130 void *argp1 = 0 ;
46131 int res1 = 0 ;
46132 bool temp2 = false ;
46133 PyObject * obj0 = 0 ;
46134 PyObject * obj1 = 0 ;
46135 char * kwnames[] = {
46136 (char *) "self",(char *) "s", NULL
46137 };
46138
46139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46141 if (!SWIG_IsOK(res1)) {
46142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46143 }
46144 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46145 {
46146 arg2 = wxString_in_helper(obj1);
46147 if (arg2 == NULL) SWIG_fail;
46148 temp2 = true;
46149 }
46150 {
46151 PyThreadState* __tstate = wxPyBeginAllowThreads();
46152 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46153 wxPyEndAllowThreads(__tstate);
46154 if (PyErr_Occurred()) SWIG_fail;
46155 }
46156 {
46157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46158 }
46159 {
46160 if (temp2)
46161 delete arg2;
46162 }
46163 return resultobj;
46164 fail:
46165 {
46166 if (temp2)
46167 delete arg2;
46168 }
46169 return NULL;
46170 }
46171
46172
46173 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46174 PyObject *resultobj = 0;
46175 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46176 wxString result;
46177 void *argp1 = 0 ;
46178 int res1 = 0 ;
46179 PyObject *swig_obj[1] ;
46180
46181 if (!args) SWIG_fail;
46182 swig_obj[0] = args;
46183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46184 if (!SWIG_IsOK(res1)) {
46185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46186 }
46187 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46188 {
46189 PyThreadState* __tstate = wxPyBeginAllowThreads();
46190 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46191 wxPyEndAllowThreads(__tstate);
46192 if (PyErr_Occurred()) SWIG_fail;
46193 }
46194 {
46195 #if wxUSE_UNICODE
46196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46197 #else
46198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46199 #endif
46200 }
46201 return resultobj;
46202 fail:
46203 return NULL;
46204 }
46205
46206
46207 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46208 PyObject *resultobj = 0;
46209 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46210 int arg2 ;
46211 void *argp1 = 0 ;
46212 int res1 = 0 ;
46213 int val2 ;
46214 int ecode2 = 0 ;
46215 PyObject * obj0 = 0 ;
46216 PyObject * obj1 = 0 ;
46217 char * kwnames[] = {
46218 (char *) "self",(char *) "n", NULL
46219 };
46220
46221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46223 if (!SWIG_IsOK(res1)) {
46224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46225 }
46226 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46227 ecode2 = SWIG_AsVal_int(obj1, &val2);
46228 if (!SWIG_IsOK(ecode2)) {
46229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46230 }
46231 arg2 = static_cast< int >(val2);
46232 {
46233 PyThreadState* __tstate = wxPyBeginAllowThreads();
46234 (arg1)->Select(arg2);
46235 wxPyEndAllowThreads(__tstate);
46236 if (PyErr_Occurred()) SWIG_fail;
46237 }
46238 resultobj = SWIG_Py_Void();
46239 return resultobj;
46240 fail:
46241 return NULL;
46242 }
46243
46244
46245 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46246 PyObject *obj;
46247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46248 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46249 return SWIG_Py_Void();
46250 }
46251
46252 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46253 PyObject *obj;
46254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46255 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46256 return SWIG_Py_Void();
46257 }
46258
46259 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46260 PyObject *resultobj = 0;
46261 wxSizerItem *result = 0 ;
46262
46263 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46264 {
46265 PyThreadState* __tstate = wxPyBeginAllowThreads();
46266 result = (wxSizerItem *)new wxSizerItem();
46267 wxPyEndAllowThreads(__tstate);
46268 if (PyErr_Occurred()) SWIG_fail;
46269 }
46270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46278 PyObject *resultobj = 0;
46279 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46280 void *argp1 = 0 ;
46281 int res1 = 0 ;
46282 PyObject *swig_obj[1] ;
46283
46284 if (!args) SWIG_fail;
46285 swig_obj[0] = args;
46286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46287 if (!SWIG_IsOK(res1)) {
46288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46289 }
46290 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46291 {
46292 PyThreadState* __tstate = wxPyBeginAllowThreads();
46293 delete arg1;
46294
46295 wxPyEndAllowThreads(__tstate);
46296 if (PyErr_Occurred()) SWIG_fail;
46297 }
46298 resultobj = SWIG_Py_Void();
46299 return resultobj;
46300 fail:
46301 return NULL;
46302 }
46303
46304
46305 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46306 PyObject *resultobj = 0;
46307 wxWindow *arg1 = (wxWindow *) 0 ;
46308 int arg2 ;
46309 int arg3 ;
46310 int arg4 ;
46311 PyObject *arg5 = (PyObject *) NULL ;
46312 wxSizerItem *result = 0 ;
46313 void *argp1 = 0 ;
46314 int res1 = 0 ;
46315 int val2 ;
46316 int ecode2 = 0 ;
46317 int val3 ;
46318 int ecode3 = 0 ;
46319 int val4 ;
46320 int ecode4 = 0 ;
46321 PyObject * obj0 = 0 ;
46322 PyObject * obj1 = 0 ;
46323 PyObject * obj2 = 0 ;
46324 PyObject * obj3 = 0 ;
46325 PyObject * obj4 = 0 ;
46326 char * kwnames[] = {
46327 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46328 };
46329
46330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46332 if (!SWIG_IsOK(res1)) {
46333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46334 }
46335 arg1 = reinterpret_cast< wxWindow * >(argp1);
46336 ecode2 = SWIG_AsVal_int(obj1, &val2);
46337 if (!SWIG_IsOK(ecode2)) {
46338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46339 }
46340 arg2 = static_cast< int >(val2);
46341 ecode3 = SWIG_AsVal_int(obj2, &val3);
46342 if (!SWIG_IsOK(ecode3)) {
46343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46344 }
46345 arg3 = static_cast< int >(val3);
46346 ecode4 = SWIG_AsVal_int(obj3, &val4);
46347 if (!SWIG_IsOK(ecode4)) {
46348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46349 }
46350 arg4 = static_cast< int >(val4);
46351 if (obj4) {
46352 arg5 = obj4;
46353 }
46354 {
46355 PyThreadState* __tstate = wxPyBeginAllowThreads();
46356 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46357 wxPyEndAllowThreads(__tstate);
46358 if (PyErr_Occurred()) SWIG_fail;
46359 }
46360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46361 return resultobj;
46362 fail:
46363 return NULL;
46364 }
46365
46366
46367 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46368 PyObject *resultobj = 0;
46369 int arg1 ;
46370 int arg2 ;
46371 int arg3 ;
46372 int arg4 ;
46373 int arg5 ;
46374 PyObject *arg6 = (PyObject *) NULL ;
46375 wxSizerItem *result = 0 ;
46376 int val1 ;
46377 int ecode1 = 0 ;
46378 int val2 ;
46379 int ecode2 = 0 ;
46380 int val3 ;
46381 int ecode3 = 0 ;
46382 int val4 ;
46383 int ecode4 = 0 ;
46384 int val5 ;
46385 int ecode5 = 0 ;
46386 PyObject * obj0 = 0 ;
46387 PyObject * obj1 = 0 ;
46388 PyObject * obj2 = 0 ;
46389 PyObject * obj3 = 0 ;
46390 PyObject * obj4 = 0 ;
46391 PyObject * obj5 = 0 ;
46392 char * kwnames[] = {
46393 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46394 };
46395
46396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46397 ecode1 = SWIG_AsVal_int(obj0, &val1);
46398 if (!SWIG_IsOK(ecode1)) {
46399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46400 }
46401 arg1 = static_cast< int >(val1);
46402 ecode2 = SWIG_AsVal_int(obj1, &val2);
46403 if (!SWIG_IsOK(ecode2)) {
46404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46405 }
46406 arg2 = static_cast< int >(val2);
46407 ecode3 = SWIG_AsVal_int(obj2, &val3);
46408 if (!SWIG_IsOK(ecode3)) {
46409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46410 }
46411 arg3 = static_cast< int >(val3);
46412 ecode4 = SWIG_AsVal_int(obj3, &val4);
46413 if (!SWIG_IsOK(ecode4)) {
46414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46415 }
46416 arg4 = static_cast< int >(val4);
46417 ecode5 = SWIG_AsVal_int(obj4, &val5);
46418 if (!SWIG_IsOK(ecode5)) {
46419 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46420 }
46421 arg5 = static_cast< int >(val5);
46422 if (obj5) {
46423 arg6 = obj5;
46424 }
46425 {
46426 PyThreadState* __tstate = wxPyBeginAllowThreads();
46427 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46428 wxPyEndAllowThreads(__tstate);
46429 if (PyErr_Occurred()) SWIG_fail;
46430 }
46431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46432 return resultobj;
46433 fail:
46434 return NULL;
46435 }
46436
46437
46438 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46439 PyObject *resultobj = 0;
46440 wxSizer *arg1 = (wxSizer *) 0 ;
46441 int arg2 ;
46442 int arg3 ;
46443 int arg4 ;
46444 PyObject *arg5 = (PyObject *) NULL ;
46445 wxSizerItem *result = 0 ;
46446 int res1 = 0 ;
46447 int val2 ;
46448 int ecode2 = 0 ;
46449 int val3 ;
46450 int ecode3 = 0 ;
46451 int val4 ;
46452 int ecode4 = 0 ;
46453 PyObject * obj0 = 0 ;
46454 PyObject * obj1 = 0 ;
46455 PyObject * obj2 = 0 ;
46456 PyObject * obj3 = 0 ;
46457 PyObject * obj4 = 0 ;
46458 char * kwnames[] = {
46459 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46460 };
46461
46462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46463 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46464 if (!SWIG_IsOK(res1)) {
46465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46466 }
46467 ecode2 = SWIG_AsVal_int(obj1, &val2);
46468 if (!SWIG_IsOK(ecode2)) {
46469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46470 }
46471 arg2 = static_cast< int >(val2);
46472 ecode3 = SWIG_AsVal_int(obj2, &val3);
46473 if (!SWIG_IsOK(ecode3)) {
46474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46475 }
46476 arg3 = static_cast< int >(val3);
46477 ecode4 = SWIG_AsVal_int(obj3, &val4);
46478 if (!SWIG_IsOK(ecode4)) {
46479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46480 }
46481 arg4 = static_cast< int >(val4);
46482 if (obj4) {
46483 arg5 = obj4;
46484 }
46485 {
46486 PyThreadState* __tstate = wxPyBeginAllowThreads();
46487 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46488 wxPyEndAllowThreads(__tstate);
46489 if (PyErr_Occurred()) SWIG_fail;
46490 }
46491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46492 return resultobj;
46493 fail:
46494 return NULL;
46495 }
46496
46497
46498 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46499 PyObject *resultobj = 0;
46500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 PyObject *swig_obj[1] ;
46504
46505 if (!args) SWIG_fail;
46506 swig_obj[0] = args;
46507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46508 if (!SWIG_IsOK(res1)) {
46509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46510 }
46511 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46512 {
46513 PyThreadState* __tstate = wxPyBeginAllowThreads();
46514 (arg1)->DeleteWindows();
46515 wxPyEndAllowThreads(__tstate);
46516 if (PyErr_Occurred()) SWIG_fail;
46517 }
46518 resultobj = SWIG_Py_Void();
46519 return resultobj;
46520 fail:
46521 return NULL;
46522 }
46523
46524
46525 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46526 PyObject *resultobj = 0;
46527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 PyObject *swig_obj[1] ;
46531
46532 if (!args) SWIG_fail;
46533 swig_obj[0] = args;
46534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46535 if (!SWIG_IsOK(res1)) {
46536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46537 }
46538 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46539 {
46540 PyThreadState* __tstate = wxPyBeginAllowThreads();
46541 (arg1)->DetachSizer();
46542 wxPyEndAllowThreads(__tstate);
46543 if (PyErr_Occurred()) SWIG_fail;
46544 }
46545 resultobj = SWIG_Py_Void();
46546 return resultobj;
46547 fail:
46548 return NULL;
46549 }
46550
46551
46552 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46553 PyObject *resultobj = 0;
46554 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46555 wxSize result;
46556 void *argp1 = 0 ;
46557 int res1 = 0 ;
46558 PyObject *swig_obj[1] ;
46559
46560 if (!args) SWIG_fail;
46561 swig_obj[0] = args;
46562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46563 if (!SWIG_IsOK(res1)) {
46564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46565 }
46566 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46567 {
46568 PyThreadState* __tstate = wxPyBeginAllowThreads();
46569 result = (arg1)->GetSize();
46570 wxPyEndAllowThreads(__tstate);
46571 if (PyErr_Occurred()) SWIG_fail;
46572 }
46573 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46574 return resultobj;
46575 fail:
46576 return NULL;
46577 }
46578
46579
46580 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46581 PyObject *resultobj = 0;
46582 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46583 wxSize result;
46584 void *argp1 = 0 ;
46585 int res1 = 0 ;
46586 PyObject *swig_obj[1] ;
46587
46588 if (!args) SWIG_fail;
46589 swig_obj[0] = args;
46590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46591 if (!SWIG_IsOK(res1)) {
46592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46593 }
46594 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46595 {
46596 PyThreadState* __tstate = wxPyBeginAllowThreads();
46597 result = (arg1)->CalcMin();
46598 wxPyEndAllowThreads(__tstate);
46599 if (PyErr_Occurred()) SWIG_fail;
46600 }
46601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46602 return resultobj;
46603 fail:
46604 return NULL;
46605 }
46606
46607
46608 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46609 PyObject *resultobj = 0;
46610 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46611 wxPoint *arg2 = 0 ;
46612 wxSize *arg3 = 0 ;
46613 void *argp1 = 0 ;
46614 int res1 = 0 ;
46615 wxPoint temp2 ;
46616 wxSize temp3 ;
46617 PyObject * obj0 = 0 ;
46618 PyObject * obj1 = 0 ;
46619 PyObject * obj2 = 0 ;
46620 char * kwnames[] = {
46621 (char *) "self",(char *) "pos",(char *) "size", NULL
46622 };
46623
46624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46626 if (!SWIG_IsOK(res1)) {
46627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46628 }
46629 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46630 {
46631 arg2 = &temp2;
46632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46633 }
46634 {
46635 arg3 = &temp3;
46636 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46637 }
46638 {
46639 PyThreadState* __tstate = wxPyBeginAllowThreads();
46640 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46641 wxPyEndAllowThreads(__tstate);
46642 if (PyErr_Occurred()) SWIG_fail;
46643 }
46644 resultobj = SWIG_Py_Void();
46645 return resultobj;
46646 fail:
46647 return NULL;
46648 }
46649
46650
46651 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46652 PyObject *resultobj = 0;
46653 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46654 wxSize result;
46655 void *argp1 = 0 ;
46656 int res1 = 0 ;
46657 PyObject *swig_obj[1] ;
46658
46659 if (!args) SWIG_fail;
46660 swig_obj[0] = args;
46661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46662 if (!SWIG_IsOK(res1)) {
46663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46664 }
46665 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46666 {
46667 PyThreadState* __tstate = wxPyBeginAllowThreads();
46668 result = (arg1)->GetMinSize();
46669 wxPyEndAllowThreads(__tstate);
46670 if (PyErr_Occurred()) SWIG_fail;
46671 }
46672 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46673 return resultobj;
46674 fail:
46675 return NULL;
46676 }
46677
46678
46679 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46680 PyObject *resultobj = 0;
46681 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46682 wxSize result;
46683 void *argp1 = 0 ;
46684 int res1 = 0 ;
46685 PyObject *swig_obj[1] ;
46686
46687 if (!args) SWIG_fail;
46688 swig_obj[0] = args;
46689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46690 if (!SWIG_IsOK(res1)) {
46691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46692 }
46693 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46694 {
46695 PyThreadState* __tstate = wxPyBeginAllowThreads();
46696 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46697 wxPyEndAllowThreads(__tstate);
46698 if (PyErr_Occurred()) SWIG_fail;
46699 }
46700 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46701 return resultobj;
46702 fail:
46703 return NULL;
46704 }
46705
46706
46707 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46708 PyObject *resultobj = 0;
46709 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46710 int arg2 ;
46711 int arg3 ;
46712 void *argp1 = 0 ;
46713 int res1 = 0 ;
46714 int val2 ;
46715 int ecode2 = 0 ;
46716 int val3 ;
46717 int ecode3 = 0 ;
46718 PyObject * obj0 = 0 ;
46719 PyObject * obj1 = 0 ;
46720 PyObject * obj2 = 0 ;
46721 char * kwnames[] = {
46722 (char *) "self",(char *) "x",(char *) "y", NULL
46723 };
46724
46725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46727 if (!SWIG_IsOK(res1)) {
46728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46729 }
46730 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46731 ecode2 = SWIG_AsVal_int(obj1, &val2);
46732 if (!SWIG_IsOK(ecode2)) {
46733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46734 }
46735 arg2 = static_cast< int >(val2);
46736 ecode3 = SWIG_AsVal_int(obj2, &val3);
46737 if (!SWIG_IsOK(ecode3)) {
46738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46739 }
46740 arg3 = static_cast< int >(val3);
46741 {
46742 PyThreadState* __tstate = wxPyBeginAllowThreads();
46743 (arg1)->SetInitSize(arg2,arg3);
46744 wxPyEndAllowThreads(__tstate);
46745 if (PyErr_Occurred()) SWIG_fail;
46746 }
46747 resultobj = SWIG_Py_Void();
46748 return resultobj;
46749 fail:
46750 return NULL;
46751 }
46752
46753
46754 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46755 PyObject *resultobj = 0;
46756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46757 int arg2 ;
46758 int arg3 ;
46759 void *argp1 = 0 ;
46760 int res1 = 0 ;
46761 int val2 ;
46762 int ecode2 = 0 ;
46763 int val3 ;
46764 int ecode3 = 0 ;
46765 PyObject * obj0 = 0 ;
46766 PyObject * obj1 = 0 ;
46767 PyObject * obj2 = 0 ;
46768 char * kwnames[] = {
46769 (char *) "self",(char *) "width",(char *) "height", NULL
46770 };
46771
46772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46774 if (!SWIG_IsOK(res1)) {
46775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46776 }
46777 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46778 ecode2 = SWIG_AsVal_int(obj1, &val2);
46779 if (!SWIG_IsOK(ecode2)) {
46780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46781 }
46782 arg2 = static_cast< int >(val2);
46783 ecode3 = SWIG_AsVal_int(obj2, &val3);
46784 if (!SWIG_IsOK(ecode3)) {
46785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46786 }
46787 arg3 = static_cast< int >(val3);
46788 {
46789 PyThreadState* __tstate = wxPyBeginAllowThreads();
46790 (arg1)->SetRatio(arg2,arg3);
46791 wxPyEndAllowThreads(__tstate);
46792 if (PyErr_Occurred()) SWIG_fail;
46793 }
46794 resultobj = SWIG_Py_Void();
46795 return resultobj;
46796 fail:
46797 return NULL;
46798 }
46799
46800
46801 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46802 PyObject *resultobj = 0;
46803 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46804 wxSize *arg2 = 0 ;
46805 void *argp1 = 0 ;
46806 int res1 = 0 ;
46807 wxSize temp2 ;
46808 PyObject * obj0 = 0 ;
46809 PyObject * obj1 = 0 ;
46810 char * kwnames[] = {
46811 (char *) "self",(char *) "size", NULL
46812 };
46813
46814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46818 }
46819 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46820 {
46821 arg2 = &temp2;
46822 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46823 }
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 (arg1)->SetRatio((wxSize const &)*arg2);
46827 wxPyEndAllowThreads(__tstate);
46828 if (PyErr_Occurred()) SWIG_fail;
46829 }
46830 resultobj = SWIG_Py_Void();
46831 return resultobj;
46832 fail:
46833 return NULL;
46834 }
46835
46836
46837 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46838 PyObject *resultobj = 0;
46839 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46840 float arg2 ;
46841 void *argp1 = 0 ;
46842 int res1 = 0 ;
46843 float val2 ;
46844 int ecode2 = 0 ;
46845 PyObject * obj0 = 0 ;
46846 PyObject * obj1 = 0 ;
46847 char * kwnames[] = {
46848 (char *) "self",(char *) "ratio", NULL
46849 };
46850
46851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46853 if (!SWIG_IsOK(res1)) {
46854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46855 }
46856 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46857 ecode2 = SWIG_AsVal_float(obj1, &val2);
46858 if (!SWIG_IsOK(ecode2)) {
46859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46860 }
46861 arg2 = static_cast< float >(val2);
46862 {
46863 PyThreadState* __tstate = wxPyBeginAllowThreads();
46864 (arg1)->SetRatio(arg2);
46865 wxPyEndAllowThreads(__tstate);
46866 if (PyErr_Occurred()) SWIG_fail;
46867 }
46868 resultobj = SWIG_Py_Void();
46869 return resultobj;
46870 fail:
46871 return NULL;
46872 }
46873
46874
46875 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46876 PyObject *resultobj = 0;
46877 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46878 float result;
46879 void *argp1 = 0 ;
46880 int res1 = 0 ;
46881 PyObject *swig_obj[1] ;
46882
46883 if (!args) SWIG_fail;
46884 swig_obj[0] = args;
46885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46886 if (!SWIG_IsOK(res1)) {
46887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46888 }
46889 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46890 {
46891 PyThreadState* __tstate = wxPyBeginAllowThreads();
46892 result = (float)(arg1)->GetRatio();
46893 wxPyEndAllowThreads(__tstate);
46894 if (PyErr_Occurred()) SWIG_fail;
46895 }
46896 resultobj = SWIG_From_float(static_cast< float >(result));
46897 return resultobj;
46898 fail:
46899 return NULL;
46900 }
46901
46902
46903 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46904 PyObject *resultobj = 0;
46905 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46906 wxRect result;
46907 void *argp1 = 0 ;
46908 int res1 = 0 ;
46909 PyObject *swig_obj[1] ;
46910
46911 if (!args) SWIG_fail;
46912 swig_obj[0] = args;
46913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46914 if (!SWIG_IsOK(res1)) {
46915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46916 }
46917 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46918 {
46919 PyThreadState* __tstate = wxPyBeginAllowThreads();
46920 result = (arg1)->GetRect();
46921 wxPyEndAllowThreads(__tstate);
46922 if (PyErr_Occurred()) SWIG_fail;
46923 }
46924 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46925 return resultobj;
46926 fail:
46927 return NULL;
46928 }
46929
46930
46931 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46932 PyObject *resultobj = 0;
46933 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46934 bool result;
46935 void *argp1 = 0 ;
46936 int res1 = 0 ;
46937 PyObject *swig_obj[1] ;
46938
46939 if (!args) SWIG_fail;
46940 swig_obj[0] = args;
46941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46942 if (!SWIG_IsOK(res1)) {
46943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46944 }
46945 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46946 {
46947 PyThreadState* __tstate = wxPyBeginAllowThreads();
46948 result = (bool)(arg1)->IsWindow();
46949 wxPyEndAllowThreads(__tstate);
46950 if (PyErr_Occurred()) SWIG_fail;
46951 }
46952 {
46953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46954 }
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46962 PyObject *resultobj = 0;
46963 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46964 bool result;
46965 void *argp1 = 0 ;
46966 int res1 = 0 ;
46967 PyObject *swig_obj[1] ;
46968
46969 if (!args) SWIG_fail;
46970 swig_obj[0] = args;
46971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46972 if (!SWIG_IsOK(res1)) {
46973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46974 }
46975 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46976 {
46977 PyThreadState* __tstate = wxPyBeginAllowThreads();
46978 result = (bool)(arg1)->IsSizer();
46979 wxPyEndAllowThreads(__tstate);
46980 if (PyErr_Occurred()) SWIG_fail;
46981 }
46982 {
46983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46984 }
46985 return resultobj;
46986 fail:
46987 return NULL;
46988 }
46989
46990
46991 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46992 PyObject *resultobj = 0;
46993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46994 bool result;
46995 void *argp1 = 0 ;
46996 int res1 = 0 ;
46997 PyObject *swig_obj[1] ;
46998
46999 if (!args) SWIG_fail;
47000 swig_obj[0] = args;
47001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47002 if (!SWIG_IsOK(res1)) {
47003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47004 }
47005 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47006 {
47007 PyThreadState* __tstate = wxPyBeginAllowThreads();
47008 result = (bool)(arg1)->IsSpacer();
47009 wxPyEndAllowThreads(__tstate);
47010 if (PyErr_Occurred()) SWIG_fail;
47011 }
47012 {
47013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47014 }
47015 return resultobj;
47016 fail:
47017 return NULL;
47018 }
47019
47020
47021 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47022 PyObject *resultobj = 0;
47023 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47024 int arg2 ;
47025 void *argp1 = 0 ;
47026 int res1 = 0 ;
47027 int val2 ;
47028 int ecode2 = 0 ;
47029 PyObject * obj0 = 0 ;
47030 PyObject * obj1 = 0 ;
47031 char * kwnames[] = {
47032 (char *) "self",(char *) "proportion", NULL
47033 };
47034
47035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47037 if (!SWIG_IsOK(res1)) {
47038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47039 }
47040 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47041 ecode2 = SWIG_AsVal_int(obj1, &val2);
47042 if (!SWIG_IsOK(ecode2)) {
47043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47044 }
47045 arg2 = static_cast< int >(val2);
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 (arg1)->SetProportion(arg2);
47049 wxPyEndAllowThreads(__tstate);
47050 if (PyErr_Occurred()) SWIG_fail;
47051 }
47052 resultobj = SWIG_Py_Void();
47053 return resultobj;
47054 fail:
47055 return NULL;
47056 }
47057
47058
47059 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47060 PyObject *resultobj = 0;
47061 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47062 int result;
47063 void *argp1 = 0 ;
47064 int res1 = 0 ;
47065 PyObject *swig_obj[1] ;
47066
47067 if (!args) SWIG_fail;
47068 swig_obj[0] = args;
47069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47070 if (!SWIG_IsOK(res1)) {
47071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47072 }
47073 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47074 {
47075 PyThreadState* __tstate = wxPyBeginAllowThreads();
47076 result = (int)(arg1)->GetProportion();
47077 wxPyEndAllowThreads(__tstate);
47078 if (PyErr_Occurred()) SWIG_fail;
47079 }
47080 resultobj = SWIG_From_int(static_cast< int >(result));
47081 return resultobj;
47082 fail:
47083 return NULL;
47084 }
47085
47086
47087 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47088 PyObject *resultobj = 0;
47089 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47090 int arg2 ;
47091 void *argp1 = 0 ;
47092 int res1 = 0 ;
47093 int val2 ;
47094 int ecode2 = 0 ;
47095 PyObject * obj0 = 0 ;
47096 PyObject * obj1 = 0 ;
47097 char * kwnames[] = {
47098 (char *) "self",(char *) "flag", NULL
47099 };
47100
47101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47103 if (!SWIG_IsOK(res1)) {
47104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47105 }
47106 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47107 ecode2 = SWIG_AsVal_int(obj1, &val2);
47108 if (!SWIG_IsOK(ecode2)) {
47109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47110 }
47111 arg2 = static_cast< int >(val2);
47112 {
47113 PyThreadState* __tstate = wxPyBeginAllowThreads();
47114 (arg1)->SetFlag(arg2);
47115 wxPyEndAllowThreads(__tstate);
47116 if (PyErr_Occurred()) SWIG_fail;
47117 }
47118 resultobj = SWIG_Py_Void();
47119 return resultobj;
47120 fail:
47121 return NULL;
47122 }
47123
47124
47125 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47126 PyObject *resultobj = 0;
47127 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47128 int result;
47129 void *argp1 = 0 ;
47130 int res1 = 0 ;
47131 PyObject *swig_obj[1] ;
47132
47133 if (!args) SWIG_fail;
47134 swig_obj[0] = args;
47135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47136 if (!SWIG_IsOK(res1)) {
47137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47138 }
47139 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47140 {
47141 PyThreadState* __tstate = wxPyBeginAllowThreads();
47142 result = (int)(arg1)->GetFlag();
47143 wxPyEndAllowThreads(__tstate);
47144 if (PyErr_Occurred()) SWIG_fail;
47145 }
47146 resultobj = SWIG_From_int(static_cast< int >(result));
47147 return resultobj;
47148 fail:
47149 return NULL;
47150 }
47151
47152
47153 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47154 PyObject *resultobj = 0;
47155 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47156 int arg2 ;
47157 void *argp1 = 0 ;
47158 int res1 = 0 ;
47159 int val2 ;
47160 int ecode2 = 0 ;
47161 PyObject * obj0 = 0 ;
47162 PyObject * obj1 = 0 ;
47163 char * kwnames[] = {
47164 (char *) "self",(char *) "border", NULL
47165 };
47166
47167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47169 if (!SWIG_IsOK(res1)) {
47170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47171 }
47172 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47173 ecode2 = SWIG_AsVal_int(obj1, &val2);
47174 if (!SWIG_IsOK(ecode2)) {
47175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47176 }
47177 arg2 = static_cast< int >(val2);
47178 {
47179 PyThreadState* __tstate = wxPyBeginAllowThreads();
47180 (arg1)->SetBorder(arg2);
47181 wxPyEndAllowThreads(__tstate);
47182 if (PyErr_Occurred()) SWIG_fail;
47183 }
47184 resultobj = SWIG_Py_Void();
47185 return resultobj;
47186 fail:
47187 return NULL;
47188 }
47189
47190
47191 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47192 PyObject *resultobj = 0;
47193 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47194 int result;
47195 void *argp1 = 0 ;
47196 int res1 = 0 ;
47197 PyObject *swig_obj[1] ;
47198
47199 if (!args) SWIG_fail;
47200 swig_obj[0] = args;
47201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47202 if (!SWIG_IsOK(res1)) {
47203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47204 }
47205 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47206 {
47207 PyThreadState* __tstate = wxPyBeginAllowThreads();
47208 result = (int)(arg1)->GetBorder();
47209 wxPyEndAllowThreads(__tstate);
47210 if (PyErr_Occurred()) SWIG_fail;
47211 }
47212 resultobj = SWIG_From_int(static_cast< int >(result));
47213 return resultobj;
47214 fail:
47215 return NULL;
47216 }
47217
47218
47219 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47220 PyObject *resultobj = 0;
47221 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47222 wxWindow *result = 0 ;
47223 void *argp1 = 0 ;
47224 int res1 = 0 ;
47225 PyObject *swig_obj[1] ;
47226
47227 if (!args) SWIG_fail;
47228 swig_obj[0] = args;
47229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47230 if (!SWIG_IsOK(res1)) {
47231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47232 }
47233 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47234 {
47235 PyThreadState* __tstate = wxPyBeginAllowThreads();
47236 result = (wxWindow *)(arg1)->GetWindow();
47237 wxPyEndAllowThreads(__tstate);
47238 if (PyErr_Occurred()) SWIG_fail;
47239 }
47240 {
47241 resultobj = wxPyMake_wxObject(result, 0);
47242 }
47243 return resultobj;
47244 fail:
47245 return NULL;
47246 }
47247
47248
47249 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47250 PyObject *resultobj = 0;
47251 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47252 wxWindow *arg2 = (wxWindow *) 0 ;
47253 void *argp1 = 0 ;
47254 int res1 = 0 ;
47255 void *argp2 = 0 ;
47256 int res2 = 0 ;
47257 PyObject * obj0 = 0 ;
47258 PyObject * obj1 = 0 ;
47259 char * kwnames[] = {
47260 (char *) "self",(char *) "window", NULL
47261 };
47262
47263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47265 if (!SWIG_IsOK(res1)) {
47266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47267 }
47268 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47270 if (!SWIG_IsOK(res2)) {
47271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47272 }
47273 arg2 = reinterpret_cast< wxWindow * >(argp2);
47274 {
47275 PyThreadState* __tstate = wxPyBeginAllowThreads();
47276 (arg1)->SetWindow(arg2);
47277 wxPyEndAllowThreads(__tstate);
47278 if (PyErr_Occurred()) SWIG_fail;
47279 }
47280 resultobj = SWIG_Py_Void();
47281 return resultobj;
47282 fail:
47283 return NULL;
47284 }
47285
47286
47287 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47288 PyObject *resultobj = 0;
47289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47290 wxSizer *result = 0 ;
47291 void *argp1 = 0 ;
47292 int res1 = 0 ;
47293 PyObject *swig_obj[1] ;
47294
47295 if (!args) SWIG_fail;
47296 swig_obj[0] = args;
47297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47298 if (!SWIG_IsOK(res1)) {
47299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47300 }
47301 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47302 {
47303 PyThreadState* __tstate = wxPyBeginAllowThreads();
47304 result = (wxSizer *)(arg1)->GetSizer();
47305 wxPyEndAllowThreads(__tstate);
47306 if (PyErr_Occurred()) SWIG_fail;
47307 }
47308 {
47309 resultobj = wxPyMake_wxObject(result, (bool)0);
47310 }
47311 return resultobj;
47312 fail:
47313 return NULL;
47314 }
47315
47316
47317 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47318 PyObject *resultobj = 0;
47319 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47320 wxSizer *arg2 = (wxSizer *) 0 ;
47321 void *argp1 = 0 ;
47322 int res1 = 0 ;
47323 int res2 = 0 ;
47324 PyObject * obj0 = 0 ;
47325 PyObject * obj1 = 0 ;
47326 char * kwnames[] = {
47327 (char *) "self",(char *) "sizer", NULL
47328 };
47329
47330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47332 if (!SWIG_IsOK(res1)) {
47333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47334 }
47335 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47336 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47337 if (!SWIG_IsOK(res2)) {
47338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47339 }
47340 {
47341 PyThreadState* __tstate = wxPyBeginAllowThreads();
47342 (arg1)->SetSizer(arg2);
47343 wxPyEndAllowThreads(__tstate);
47344 if (PyErr_Occurred()) SWIG_fail;
47345 }
47346 resultobj = SWIG_Py_Void();
47347 return resultobj;
47348 fail:
47349 return NULL;
47350 }
47351
47352
47353 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47354 PyObject *resultobj = 0;
47355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47356 wxSize result;
47357 void *argp1 = 0 ;
47358 int res1 = 0 ;
47359 PyObject *swig_obj[1] ;
47360
47361 if (!args) SWIG_fail;
47362 swig_obj[0] = args;
47363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47364 if (!SWIG_IsOK(res1)) {
47365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47366 }
47367 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47368 {
47369 PyThreadState* __tstate = wxPyBeginAllowThreads();
47370 result = (arg1)->GetSpacer();
47371 wxPyEndAllowThreads(__tstate);
47372 if (PyErr_Occurred()) SWIG_fail;
47373 }
47374 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47375 return resultobj;
47376 fail:
47377 return NULL;
47378 }
47379
47380
47381 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47382 PyObject *resultobj = 0;
47383 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47384 wxSize *arg2 = 0 ;
47385 void *argp1 = 0 ;
47386 int res1 = 0 ;
47387 wxSize temp2 ;
47388 PyObject * obj0 = 0 ;
47389 PyObject * obj1 = 0 ;
47390 char * kwnames[] = {
47391 (char *) "self",(char *) "size", NULL
47392 };
47393
47394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47396 if (!SWIG_IsOK(res1)) {
47397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47398 }
47399 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47400 {
47401 arg2 = &temp2;
47402 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47403 }
47404 {
47405 PyThreadState* __tstate = wxPyBeginAllowThreads();
47406 (arg1)->SetSpacer((wxSize const &)*arg2);
47407 wxPyEndAllowThreads(__tstate);
47408 if (PyErr_Occurred()) SWIG_fail;
47409 }
47410 resultobj = SWIG_Py_Void();
47411 return resultobj;
47412 fail:
47413 return NULL;
47414 }
47415
47416
47417 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47418 PyObject *resultobj = 0;
47419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47420 bool arg2 ;
47421 void *argp1 = 0 ;
47422 int res1 = 0 ;
47423 bool val2 ;
47424 int ecode2 = 0 ;
47425 PyObject * obj0 = 0 ;
47426 PyObject * obj1 = 0 ;
47427 char * kwnames[] = {
47428 (char *) "self",(char *) "show", NULL
47429 };
47430
47431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47433 if (!SWIG_IsOK(res1)) {
47434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47435 }
47436 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47437 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47438 if (!SWIG_IsOK(ecode2)) {
47439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47440 }
47441 arg2 = static_cast< bool >(val2);
47442 {
47443 PyThreadState* __tstate = wxPyBeginAllowThreads();
47444 (arg1)->Show(arg2);
47445 wxPyEndAllowThreads(__tstate);
47446 if (PyErr_Occurred()) SWIG_fail;
47447 }
47448 resultobj = SWIG_Py_Void();
47449 return resultobj;
47450 fail:
47451 return NULL;
47452 }
47453
47454
47455 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47456 PyObject *resultobj = 0;
47457 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47458 bool result;
47459 void *argp1 = 0 ;
47460 int res1 = 0 ;
47461 PyObject *swig_obj[1] ;
47462
47463 if (!args) SWIG_fail;
47464 swig_obj[0] = args;
47465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47466 if (!SWIG_IsOK(res1)) {
47467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47468 }
47469 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47470 {
47471 PyThreadState* __tstate = wxPyBeginAllowThreads();
47472 result = (bool)(arg1)->IsShown();
47473 wxPyEndAllowThreads(__tstate);
47474 if (PyErr_Occurred()) SWIG_fail;
47475 }
47476 {
47477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47478 }
47479 return resultobj;
47480 fail:
47481 return NULL;
47482 }
47483
47484
47485 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47486 PyObject *resultobj = 0;
47487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47488 wxPoint result;
47489 void *argp1 = 0 ;
47490 int res1 = 0 ;
47491 PyObject *swig_obj[1] ;
47492
47493 if (!args) SWIG_fail;
47494 swig_obj[0] = args;
47495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47496 if (!SWIG_IsOK(res1)) {
47497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47498 }
47499 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47500 {
47501 PyThreadState* __tstate = wxPyBeginAllowThreads();
47502 result = (arg1)->GetPosition();
47503 wxPyEndAllowThreads(__tstate);
47504 if (PyErr_Occurred()) SWIG_fail;
47505 }
47506 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47507 return resultobj;
47508 fail:
47509 return NULL;
47510 }
47511
47512
47513 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47514 PyObject *resultobj = 0;
47515 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47516 PyObject *result = 0 ;
47517 void *argp1 = 0 ;
47518 int res1 = 0 ;
47519 PyObject *swig_obj[1] ;
47520
47521 if (!args) SWIG_fail;
47522 swig_obj[0] = args;
47523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47524 if (!SWIG_IsOK(res1)) {
47525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47526 }
47527 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47528 {
47529 PyThreadState* __tstate = wxPyBeginAllowThreads();
47530 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47531 wxPyEndAllowThreads(__tstate);
47532 if (PyErr_Occurred()) SWIG_fail;
47533 }
47534 resultobj = result;
47535 return resultobj;
47536 fail:
47537 return NULL;
47538 }
47539
47540
47541 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47542 PyObject *resultobj = 0;
47543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47544 PyObject *arg2 = (PyObject *) 0 ;
47545 void *argp1 = 0 ;
47546 int res1 = 0 ;
47547 PyObject * obj0 = 0 ;
47548 PyObject * obj1 = 0 ;
47549 char * kwnames[] = {
47550 (char *) "self",(char *) "userData", NULL
47551 };
47552
47553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47555 if (!SWIG_IsOK(res1)) {
47556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47557 }
47558 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47559 arg2 = obj1;
47560 {
47561 PyThreadState* __tstate = wxPyBeginAllowThreads();
47562 wxSizerItem_SetUserData(arg1,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 *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47574 PyObject *obj;
47575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47576 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47577 return SWIG_Py_Void();
47578 }
47579
47580 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47581 return SWIG_Python_InitShadowInstance(args);
47582 }
47583
47584 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47585 PyObject *resultobj = 0;
47586 wxSizer *arg1 = (wxSizer *) 0 ;
47587 void *argp1 = 0 ;
47588 int res1 = 0 ;
47589 PyObject *swig_obj[1] ;
47590
47591 if (!args) SWIG_fail;
47592 swig_obj[0] = args;
47593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47594 if (!SWIG_IsOK(res1)) {
47595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47596 }
47597 arg1 = reinterpret_cast< wxSizer * >(argp1);
47598 {
47599 PyThreadState* __tstate = wxPyBeginAllowThreads();
47600 delete arg1;
47601
47602 wxPyEndAllowThreads(__tstate);
47603 if (PyErr_Occurred()) SWIG_fail;
47604 }
47605 resultobj = SWIG_Py_Void();
47606 return resultobj;
47607 fail:
47608 return NULL;
47609 }
47610
47611
47612 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47613 PyObject *resultobj = 0;
47614 wxSizer *arg1 = (wxSizer *) 0 ;
47615 PyObject *arg2 = (PyObject *) 0 ;
47616 void *argp1 = 0 ;
47617 int res1 = 0 ;
47618 PyObject * obj0 = 0 ;
47619 PyObject * obj1 = 0 ;
47620 char * kwnames[] = {
47621 (char *) "self",(char *) "_self", NULL
47622 };
47623
47624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47626 if (!SWIG_IsOK(res1)) {
47627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47628 }
47629 arg1 = reinterpret_cast< wxSizer * >(argp1);
47630 arg2 = obj1;
47631 {
47632 PyThreadState* __tstate = wxPyBeginAllowThreads();
47633 wxSizer__setOORInfo(arg1,arg2);
47634 wxPyEndAllowThreads(__tstate);
47635 if (PyErr_Occurred()) SWIG_fail;
47636 }
47637 resultobj = SWIG_Py_Void();
47638 return resultobj;
47639 fail:
47640 return NULL;
47641 }
47642
47643
47644 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47645 PyObject *resultobj = 0;
47646 wxSizer *arg1 = (wxSizer *) 0 ;
47647 PyObject *arg2 = (PyObject *) 0 ;
47648 int arg3 = (int) 0 ;
47649 int arg4 = (int) 0 ;
47650 int arg5 = (int) 0 ;
47651 PyObject *arg6 = (PyObject *) NULL ;
47652 wxSizerItem *result = 0 ;
47653 void *argp1 = 0 ;
47654 int res1 = 0 ;
47655 int val3 ;
47656 int ecode3 = 0 ;
47657 int val4 ;
47658 int ecode4 = 0 ;
47659 int val5 ;
47660 int ecode5 = 0 ;
47661 PyObject * obj0 = 0 ;
47662 PyObject * obj1 = 0 ;
47663 PyObject * obj2 = 0 ;
47664 PyObject * obj3 = 0 ;
47665 PyObject * obj4 = 0 ;
47666 PyObject * obj5 = 0 ;
47667 char * kwnames[] = {
47668 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47669 };
47670
47671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47673 if (!SWIG_IsOK(res1)) {
47674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47675 }
47676 arg1 = reinterpret_cast< wxSizer * >(argp1);
47677 arg2 = obj1;
47678 if (obj2) {
47679 ecode3 = SWIG_AsVal_int(obj2, &val3);
47680 if (!SWIG_IsOK(ecode3)) {
47681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47682 }
47683 arg3 = static_cast< int >(val3);
47684 }
47685 if (obj3) {
47686 ecode4 = SWIG_AsVal_int(obj3, &val4);
47687 if (!SWIG_IsOK(ecode4)) {
47688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47689 }
47690 arg4 = static_cast< int >(val4);
47691 }
47692 if (obj4) {
47693 ecode5 = SWIG_AsVal_int(obj4, &val5);
47694 if (!SWIG_IsOK(ecode5)) {
47695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47696 }
47697 arg5 = static_cast< int >(val5);
47698 }
47699 if (obj5) {
47700 arg6 = obj5;
47701 }
47702 {
47703 PyThreadState* __tstate = wxPyBeginAllowThreads();
47704 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47705 wxPyEndAllowThreads(__tstate);
47706 if (PyErr_Occurred()) SWIG_fail;
47707 }
47708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47709 return resultobj;
47710 fail:
47711 return NULL;
47712 }
47713
47714
47715 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47716 PyObject *resultobj = 0;
47717 wxSizer *arg1 = (wxSizer *) 0 ;
47718 int arg2 ;
47719 PyObject *arg3 = (PyObject *) 0 ;
47720 int arg4 = (int) 0 ;
47721 int arg5 = (int) 0 ;
47722 int arg6 = (int) 0 ;
47723 PyObject *arg7 = (PyObject *) NULL ;
47724 wxSizerItem *result = 0 ;
47725 void *argp1 = 0 ;
47726 int res1 = 0 ;
47727 int val2 ;
47728 int ecode2 = 0 ;
47729 int val4 ;
47730 int ecode4 = 0 ;
47731 int val5 ;
47732 int ecode5 = 0 ;
47733 int val6 ;
47734 int ecode6 = 0 ;
47735 PyObject * obj0 = 0 ;
47736 PyObject * obj1 = 0 ;
47737 PyObject * obj2 = 0 ;
47738 PyObject * obj3 = 0 ;
47739 PyObject * obj4 = 0 ;
47740 PyObject * obj5 = 0 ;
47741 PyObject * obj6 = 0 ;
47742 char * kwnames[] = {
47743 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47744 };
47745
47746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47748 if (!SWIG_IsOK(res1)) {
47749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47750 }
47751 arg1 = reinterpret_cast< wxSizer * >(argp1);
47752 ecode2 = SWIG_AsVal_int(obj1, &val2);
47753 if (!SWIG_IsOK(ecode2)) {
47754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47755 }
47756 arg2 = static_cast< int >(val2);
47757 arg3 = obj2;
47758 if (obj3) {
47759 ecode4 = SWIG_AsVal_int(obj3, &val4);
47760 if (!SWIG_IsOK(ecode4)) {
47761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47762 }
47763 arg4 = static_cast< int >(val4);
47764 }
47765 if (obj4) {
47766 ecode5 = SWIG_AsVal_int(obj4, &val5);
47767 if (!SWIG_IsOK(ecode5)) {
47768 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47769 }
47770 arg5 = static_cast< int >(val5);
47771 }
47772 if (obj5) {
47773 ecode6 = SWIG_AsVal_int(obj5, &val6);
47774 if (!SWIG_IsOK(ecode6)) {
47775 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47776 }
47777 arg6 = static_cast< int >(val6);
47778 }
47779 if (obj6) {
47780 arg7 = obj6;
47781 }
47782 {
47783 PyThreadState* __tstate = wxPyBeginAllowThreads();
47784 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47785 wxPyEndAllowThreads(__tstate);
47786 if (PyErr_Occurred()) SWIG_fail;
47787 }
47788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47789 return resultobj;
47790 fail:
47791 return NULL;
47792 }
47793
47794
47795 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47796 PyObject *resultobj = 0;
47797 wxSizer *arg1 = (wxSizer *) 0 ;
47798 PyObject *arg2 = (PyObject *) 0 ;
47799 int arg3 = (int) 0 ;
47800 int arg4 = (int) 0 ;
47801 int arg5 = (int) 0 ;
47802 PyObject *arg6 = (PyObject *) NULL ;
47803 wxSizerItem *result = 0 ;
47804 void *argp1 = 0 ;
47805 int res1 = 0 ;
47806 int val3 ;
47807 int ecode3 = 0 ;
47808 int val4 ;
47809 int ecode4 = 0 ;
47810 int val5 ;
47811 int ecode5 = 0 ;
47812 PyObject * obj0 = 0 ;
47813 PyObject * obj1 = 0 ;
47814 PyObject * obj2 = 0 ;
47815 PyObject * obj3 = 0 ;
47816 PyObject * obj4 = 0 ;
47817 PyObject * obj5 = 0 ;
47818 char * kwnames[] = {
47819 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47820 };
47821
47822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47824 if (!SWIG_IsOK(res1)) {
47825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47826 }
47827 arg1 = reinterpret_cast< wxSizer * >(argp1);
47828 arg2 = obj1;
47829 if (obj2) {
47830 ecode3 = SWIG_AsVal_int(obj2, &val3);
47831 if (!SWIG_IsOK(ecode3)) {
47832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47833 }
47834 arg3 = static_cast< int >(val3);
47835 }
47836 if (obj3) {
47837 ecode4 = SWIG_AsVal_int(obj3, &val4);
47838 if (!SWIG_IsOK(ecode4)) {
47839 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47840 }
47841 arg4 = static_cast< int >(val4);
47842 }
47843 if (obj4) {
47844 ecode5 = SWIG_AsVal_int(obj4, &val5);
47845 if (!SWIG_IsOK(ecode5)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47847 }
47848 arg5 = static_cast< int >(val5);
47849 }
47850 if (obj5) {
47851 arg6 = obj5;
47852 }
47853 {
47854 PyThreadState* __tstate = wxPyBeginAllowThreads();
47855 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47856 wxPyEndAllowThreads(__tstate);
47857 if (PyErr_Occurred()) SWIG_fail;
47858 }
47859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47860 return resultobj;
47861 fail:
47862 return NULL;
47863 }
47864
47865
47866 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47867 PyObject *resultobj = 0;
47868 wxSizer *arg1 = (wxSizer *) 0 ;
47869 PyObject *arg2 = (PyObject *) 0 ;
47870 bool result;
47871 void *argp1 = 0 ;
47872 int res1 = 0 ;
47873 PyObject * obj0 = 0 ;
47874 PyObject * obj1 = 0 ;
47875 char * kwnames[] = {
47876 (char *) "self",(char *) "item", NULL
47877 };
47878
47879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47881 if (!SWIG_IsOK(res1)) {
47882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47883 }
47884 arg1 = reinterpret_cast< wxSizer * >(argp1);
47885 arg2 = obj1;
47886 {
47887 PyThreadState* __tstate = wxPyBeginAllowThreads();
47888 result = (bool)wxSizer_Remove(arg1,arg2);
47889 wxPyEndAllowThreads(__tstate);
47890 if (PyErr_Occurred()) SWIG_fail;
47891 }
47892 {
47893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47894 }
47895 return resultobj;
47896 fail:
47897 return NULL;
47898 }
47899
47900
47901 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47902 PyObject *resultobj = 0;
47903 wxSizer *arg1 = (wxSizer *) 0 ;
47904 PyObject *arg2 = (PyObject *) 0 ;
47905 bool result;
47906 void *argp1 = 0 ;
47907 int res1 = 0 ;
47908 PyObject * obj0 = 0 ;
47909 PyObject * obj1 = 0 ;
47910 char * kwnames[] = {
47911 (char *) "self",(char *) "item", NULL
47912 };
47913
47914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47916 if (!SWIG_IsOK(res1)) {
47917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47918 }
47919 arg1 = reinterpret_cast< wxSizer * >(argp1);
47920 arg2 = obj1;
47921 {
47922 PyThreadState* __tstate = wxPyBeginAllowThreads();
47923 result = (bool)wxSizer_Detach(arg1,arg2);
47924 wxPyEndAllowThreads(__tstate);
47925 if (PyErr_Occurred()) SWIG_fail;
47926 }
47927 {
47928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47929 }
47930 return resultobj;
47931 fail:
47932 return NULL;
47933 }
47934
47935
47936 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47937 PyObject *resultobj = 0;
47938 wxSizer *arg1 = (wxSizer *) 0 ;
47939 PyObject *arg2 = (PyObject *) 0 ;
47940 wxSizerItem *result = 0 ;
47941 void *argp1 = 0 ;
47942 int res1 = 0 ;
47943 PyObject * obj0 = 0 ;
47944 PyObject * obj1 = 0 ;
47945 char * kwnames[] = {
47946 (char *) "self",(char *) "item", NULL
47947 };
47948
47949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47951 if (!SWIG_IsOK(res1)) {
47952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47953 }
47954 arg1 = reinterpret_cast< wxSizer * >(argp1);
47955 arg2 = obj1;
47956 {
47957 PyThreadState* __tstate = wxPyBeginAllowThreads();
47958 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47959 wxPyEndAllowThreads(__tstate);
47960 if (PyErr_Occurred()) SWIG_fail;
47961 }
47962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47963 return resultobj;
47964 fail:
47965 return NULL;
47966 }
47967
47968
47969 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47970 PyObject *resultobj = 0;
47971 wxSizer *arg1 = (wxSizer *) 0 ;
47972 PyObject *arg2 = (PyObject *) 0 ;
47973 wxSize *arg3 = 0 ;
47974 void *argp1 = 0 ;
47975 int res1 = 0 ;
47976 wxSize temp3 ;
47977 PyObject * obj0 = 0 ;
47978 PyObject * obj1 = 0 ;
47979 PyObject * obj2 = 0 ;
47980 char * kwnames[] = {
47981 (char *) "self",(char *) "item",(char *) "size", NULL
47982 };
47983
47984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47986 if (!SWIG_IsOK(res1)) {
47987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47988 }
47989 arg1 = reinterpret_cast< wxSizer * >(argp1);
47990 arg2 = obj1;
47991 {
47992 arg3 = &temp3;
47993 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47994 }
47995 {
47996 PyThreadState* __tstate = wxPyBeginAllowThreads();
47997 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47998 wxPyEndAllowThreads(__tstate);
47999 if (PyErr_Occurred()) SWIG_fail;
48000 }
48001 resultobj = SWIG_Py_Void();
48002 return resultobj;
48003 fail:
48004 return NULL;
48005 }
48006
48007
48008 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48009 PyObject *resultobj = 0;
48010 wxSizer *arg1 = (wxSizer *) 0 ;
48011 wxWindow *arg2 = (wxWindow *) 0 ;
48012 wxWindow *arg3 = (wxWindow *) 0 ;
48013 bool arg4 = (bool) false ;
48014 bool result;
48015 void *argp1 = 0 ;
48016 int res1 = 0 ;
48017 void *argp2 = 0 ;
48018 int res2 = 0 ;
48019 void *argp3 = 0 ;
48020 int res3 = 0 ;
48021 bool val4 ;
48022 int ecode4 = 0 ;
48023 PyObject * obj0 = 0 ;
48024 PyObject * obj1 = 0 ;
48025 PyObject * obj2 = 0 ;
48026 PyObject * obj3 = 0 ;
48027 char * kwnames[] = {
48028 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48029 };
48030
48031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48033 if (!SWIG_IsOK(res1)) {
48034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48035 }
48036 arg1 = reinterpret_cast< wxSizer * >(argp1);
48037 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48038 if (!SWIG_IsOK(res2)) {
48039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48040 }
48041 arg2 = reinterpret_cast< wxWindow * >(argp2);
48042 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48043 if (!SWIG_IsOK(res3)) {
48044 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48045 }
48046 arg3 = reinterpret_cast< wxWindow * >(argp3);
48047 if (obj3) {
48048 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48049 if (!SWIG_IsOK(ecode4)) {
48050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48051 }
48052 arg4 = static_cast< bool >(val4);
48053 }
48054 {
48055 PyThreadState* __tstate = wxPyBeginAllowThreads();
48056 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48057 wxPyEndAllowThreads(__tstate);
48058 if (PyErr_Occurred()) SWIG_fail;
48059 }
48060 {
48061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48062 }
48063 return resultobj;
48064 fail:
48065 return NULL;
48066 }
48067
48068
48069 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48070 PyObject *resultobj = 0;
48071 wxSizer *arg1 = (wxSizer *) 0 ;
48072 wxSizer *arg2 = (wxSizer *) 0 ;
48073 wxSizer *arg3 = (wxSizer *) 0 ;
48074 bool arg4 = (bool) false ;
48075 bool result;
48076 void *argp1 = 0 ;
48077 int res1 = 0 ;
48078 void *argp2 = 0 ;
48079 int res2 = 0 ;
48080 void *argp3 = 0 ;
48081 int res3 = 0 ;
48082 bool val4 ;
48083 int ecode4 = 0 ;
48084 PyObject * obj0 = 0 ;
48085 PyObject * obj1 = 0 ;
48086 PyObject * obj2 = 0 ;
48087 PyObject * obj3 = 0 ;
48088 char * kwnames[] = {
48089 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48090 };
48091
48092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48094 if (!SWIG_IsOK(res1)) {
48095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48096 }
48097 arg1 = reinterpret_cast< wxSizer * >(argp1);
48098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48099 if (!SWIG_IsOK(res2)) {
48100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48101 }
48102 arg2 = reinterpret_cast< wxSizer * >(argp2);
48103 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48104 if (!SWIG_IsOK(res3)) {
48105 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48106 }
48107 arg3 = reinterpret_cast< wxSizer * >(argp3);
48108 if (obj3) {
48109 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48110 if (!SWIG_IsOK(ecode4)) {
48111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48112 }
48113 arg4 = static_cast< bool >(val4);
48114 }
48115 {
48116 PyThreadState* __tstate = wxPyBeginAllowThreads();
48117 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48118 wxPyEndAllowThreads(__tstate);
48119 if (PyErr_Occurred()) SWIG_fail;
48120 }
48121 {
48122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48123 }
48124 return resultobj;
48125 fail:
48126 return NULL;
48127 }
48128
48129
48130 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48131 PyObject *resultobj = 0;
48132 wxSizer *arg1 = (wxSizer *) 0 ;
48133 size_t arg2 ;
48134 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48135 bool result;
48136 void *argp1 = 0 ;
48137 int res1 = 0 ;
48138 size_t val2 ;
48139 int ecode2 = 0 ;
48140 void *argp3 = 0 ;
48141 int res3 = 0 ;
48142 PyObject * obj0 = 0 ;
48143 PyObject * obj1 = 0 ;
48144 PyObject * obj2 = 0 ;
48145 char * kwnames[] = {
48146 (char *) "self",(char *) "index",(char *) "newitem", NULL
48147 };
48148
48149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48151 if (!SWIG_IsOK(res1)) {
48152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48153 }
48154 arg1 = reinterpret_cast< wxSizer * >(argp1);
48155 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48156 if (!SWIG_IsOK(ecode2)) {
48157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48158 }
48159 arg2 = static_cast< size_t >(val2);
48160 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48161 if (!SWIG_IsOK(res3)) {
48162 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48163 }
48164 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48165 {
48166 PyThreadState* __tstate = wxPyBeginAllowThreads();
48167 result = (bool)(arg1)->Replace(arg2,arg3);
48168 wxPyEndAllowThreads(__tstate);
48169 if (PyErr_Occurred()) SWIG_fail;
48170 }
48171 {
48172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48173 }
48174 return resultobj;
48175 fail:
48176 return NULL;
48177 }
48178
48179
48180 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48181 PyObject *resultobj = 0;
48182 wxSizer *arg1 = (wxSizer *) 0 ;
48183 wxWindow *arg2 = (wxWindow *) 0 ;
48184 void *argp1 = 0 ;
48185 int res1 = 0 ;
48186 void *argp2 = 0 ;
48187 int res2 = 0 ;
48188 PyObject * obj0 = 0 ;
48189 PyObject * obj1 = 0 ;
48190 char * kwnames[] = {
48191 (char *) "self",(char *) "window", NULL
48192 };
48193
48194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48196 if (!SWIG_IsOK(res1)) {
48197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48198 }
48199 arg1 = reinterpret_cast< wxSizer * >(argp1);
48200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48201 if (!SWIG_IsOK(res2)) {
48202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48203 }
48204 arg2 = reinterpret_cast< wxWindow * >(argp2);
48205 {
48206 PyThreadState* __tstate = wxPyBeginAllowThreads();
48207 (arg1)->SetContainingWindow(arg2);
48208 wxPyEndAllowThreads(__tstate);
48209 if (PyErr_Occurred()) SWIG_fail;
48210 }
48211 resultobj = SWIG_Py_Void();
48212 return resultobj;
48213 fail:
48214 return NULL;
48215 }
48216
48217
48218 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48219 PyObject *resultobj = 0;
48220 wxSizer *arg1 = (wxSizer *) 0 ;
48221 wxWindow *result = 0 ;
48222 void *argp1 = 0 ;
48223 int res1 = 0 ;
48224 PyObject *swig_obj[1] ;
48225
48226 if (!args) SWIG_fail;
48227 swig_obj[0] = args;
48228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48231 }
48232 arg1 = reinterpret_cast< wxSizer * >(argp1);
48233 {
48234 PyThreadState* __tstate = wxPyBeginAllowThreads();
48235 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48236 wxPyEndAllowThreads(__tstate);
48237 if (PyErr_Occurred()) SWIG_fail;
48238 }
48239 {
48240 resultobj = wxPyMake_wxObject(result, 0);
48241 }
48242 return resultobj;
48243 fail:
48244 return NULL;
48245 }
48246
48247
48248 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48249 PyObject *resultobj = 0;
48250 wxSizer *arg1 = (wxSizer *) 0 ;
48251 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48252 wxSizerItem *result = 0 ;
48253 void *argp1 = 0 ;
48254 int res1 = 0 ;
48255 int res2 = 0 ;
48256 PyObject * obj0 = 0 ;
48257 PyObject * obj1 = 0 ;
48258 char * kwnames[] = {
48259 (char *) "self",(char *) "item", NULL
48260 };
48261
48262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48264 if (!SWIG_IsOK(res1)) {
48265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48266 }
48267 arg1 = reinterpret_cast< wxSizer * >(argp1);
48268 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48269 if (!SWIG_IsOK(res2)) {
48270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48271 }
48272 {
48273 PyThreadState* __tstate = wxPyBeginAllowThreads();
48274 result = (wxSizerItem *)(arg1)->Add(arg2);
48275 wxPyEndAllowThreads(__tstate);
48276 if (PyErr_Occurred()) SWIG_fail;
48277 }
48278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48279 return resultobj;
48280 fail:
48281 return NULL;
48282 }
48283
48284
48285 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48286 PyObject *resultobj = 0;
48287 wxSizer *arg1 = (wxSizer *) 0 ;
48288 size_t arg2 ;
48289 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48290 wxSizerItem *result = 0 ;
48291 void *argp1 = 0 ;
48292 int res1 = 0 ;
48293 size_t val2 ;
48294 int ecode2 = 0 ;
48295 int res3 = 0 ;
48296 PyObject * obj0 = 0 ;
48297 PyObject * obj1 = 0 ;
48298 PyObject * obj2 = 0 ;
48299 char * kwnames[] = {
48300 (char *) "self",(char *) "index",(char *) "item", NULL
48301 };
48302
48303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48305 if (!SWIG_IsOK(res1)) {
48306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48307 }
48308 arg1 = reinterpret_cast< wxSizer * >(argp1);
48309 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48310 if (!SWIG_IsOK(ecode2)) {
48311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48312 }
48313 arg2 = static_cast< size_t >(val2);
48314 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48315 if (!SWIG_IsOK(res3)) {
48316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48317 }
48318 {
48319 PyThreadState* __tstate = wxPyBeginAllowThreads();
48320 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48321 wxPyEndAllowThreads(__tstate);
48322 if (PyErr_Occurred()) SWIG_fail;
48323 }
48324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48332 PyObject *resultobj = 0;
48333 wxSizer *arg1 = (wxSizer *) 0 ;
48334 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48335 wxSizerItem *result = 0 ;
48336 void *argp1 = 0 ;
48337 int res1 = 0 ;
48338 int res2 = 0 ;
48339 PyObject * obj0 = 0 ;
48340 PyObject * obj1 = 0 ;
48341 char * kwnames[] = {
48342 (char *) "self",(char *) "item", NULL
48343 };
48344
48345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48347 if (!SWIG_IsOK(res1)) {
48348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48349 }
48350 arg1 = reinterpret_cast< wxSizer * >(argp1);
48351 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48352 if (!SWIG_IsOK(res2)) {
48353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48354 }
48355 {
48356 PyThreadState* __tstate = wxPyBeginAllowThreads();
48357 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48358 wxPyEndAllowThreads(__tstate);
48359 if (PyErr_Occurred()) SWIG_fail;
48360 }
48361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48362 return resultobj;
48363 fail:
48364 return NULL;
48365 }
48366
48367
48368 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48369 PyObject *resultobj = 0;
48370 wxSizer *arg1 = (wxSizer *) 0 ;
48371 int arg2 ;
48372 int arg3 ;
48373 int arg4 ;
48374 int arg5 ;
48375 void *argp1 = 0 ;
48376 int res1 = 0 ;
48377 int val2 ;
48378 int ecode2 = 0 ;
48379 int val3 ;
48380 int ecode3 = 0 ;
48381 int val4 ;
48382 int ecode4 = 0 ;
48383 int val5 ;
48384 int ecode5 = 0 ;
48385 PyObject * obj0 = 0 ;
48386 PyObject * obj1 = 0 ;
48387 PyObject * obj2 = 0 ;
48388 PyObject * obj3 = 0 ;
48389 PyObject * obj4 = 0 ;
48390 char * kwnames[] = {
48391 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48392 };
48393
48394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48396 if (!SWIG_IsOK(res1)) {
48397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48398 }
48399 arg1 = reinterpret_cast< wxSizer * >(argp1);
48400 ecode2 = SWIG_AsVal_int(obj1, &val2);
48401 if (!SWIG_IsOK(ecode2)) {
48402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48403 }
48404 arg2 = static_cast< int >(val2);
48405 ecode3 = SWIG_AsVal_int(obj2, &val3);
48406 if (!SWIG_IsOK(ecode3)) {
48407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48408 }
48409 arg3 = static_cast< int >(val3);
48410 ecode4 = SWIG_AsVal_int(obj3, &val4);
48411 if (!SWIG_IsOK(ecode4)) {
48412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48413 }
48414 arg4 = static_cast< int >(val4);
48415 ecode5 = SWIG_AsVal_int(obj4, &val5);
48416 if (!SWIG_IsOK(ecode5)) {
48417 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48418 }
48419 arg5 = static_cast< int >(val5);
48420 {
48421 PyThreadState* __tstate = wxPyBeginAllowThreads();
48422 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48423 wxPyEndAllowThreads(__tstate);
48424 if (PyErr_Occurred()) SWIG_fail;
48425 }
48426 resultobj = SWIG_Py_Void();
48427 return resultobj;
48428 fail:
48429 return NULL;
48430 }
48431
48432
48433 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48434 PyObject *resultobj = 0;
48435 wxSizer *arg1 = (wxSizer *) 0 ;
48436 wxSize *arg2 = 0 ;
48437 void *argp1 = 0 ;
48438 int res1 = 0 ;
48439 wxSize temp2 ;
48440 PyObject * obj0 = 0 ;
48441 PyObject * obj1 = 0 ;
48442 char * kwnames[] = {
48443 (char *) "self",(char *) "size", NULL
48444 };
48445
48446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48448 if (!SWIG_IsOK(res1)) {
48449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48450 }
48451 arg1 = reinterpret_cast< wxSizer * >(argp1);
48452 {
48453 arg2 = &temp2;
48454 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48455 }
48456 {
48457 PyThreadState* __tstate = wxPyBeginAllowThreads();
48458 (arg1)->SetMinSize((wxSize const &)*arg2);
48459 wxPyEndAllowThreads(__tstate);
48460 if (PyErr_Occurred()) SWIG_fail;
48461 }
48462 resultobj = SWIG_Py_Void();
48463 return resultobj;
48464 fail:
48465 return NULL;
48466 }
48467
48468
48469 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48470 PyObject *resultobj = 0;
48471 wxSizer *arg1 = (wxSizer *) 0 ;
48472 wxSize result;
48473 void *argp1 = 0 ;
48474 int res1 = 0 ;
48475 PyObject *swig_obj[1] ;
48476
48477 if (!args) SWIG_fail;
48478 swig_obj[0] = args;
48479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48480 if (!SWIG_IsOK(res1)) {
48481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48482 }
48483 arg1 = reinterpret_cast< wxSizer * >(argp1);
48484 {
48485 PyThreadState* __tstate = wxPyBeginAllowThreads();
48486 result = (arg1)->GetSize();
48487 wxPyEndAllowThreads(__tstate);
48488 if (PyErr_Occurred()) SWIG_fail;
48489 }
48490 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48491 return resultobj;
48492 fail:
48493 return NULL;
48494 }
48495
48496
48497 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48498 PyObject *resultobj = 0;
48499 wxSizer *arg1 = (wxSizer *) 0 ;
48500 wxPoint result;
48501 void *argp1 = 0 ;
48502 int res1 = 0 ;
48503 PyObject *swig_obj[1] ;
48504
48505 if (!args) SWIG_fail;
48506 swig_obj[0] = args;
48507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48508 if (!SWIG_IsOK(res1)) {
48509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48510 }
48511 arg1 = reinterpret_cast< wxSizer * >(argp1);
48512 {
48513 PyThreadState* __tstate = wxPyBeginAllowThreads();
48514 result = (arg1)->GetPosition();
48515 wxPyEndAllowThreads(__tstate);
48516 if (PyErr_Occurred()) SWIG_fail;
48517 }
48518 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48519 return resultobj;
48520 fail:
48521 return NULL;
48522 }
48523
48524
48525 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48526 PyObject *resultobj = 0;
48527 wxSizer *arg1 = (wxSizer *) 0 ;
48528 wxSize result;
48529 void *argp1 = 0 ;
48530 int res1 = 0 ;
48531 PyObject *swig_obj[1] ;
48532
48533 if (!args) SWIG_fail;
48534 swig_obj[0] = args;
48535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48536 if (!SWIG_IsOK(res1)) {
48537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48538 }
48539 arg1 = reinterpret_cast< wxSizer * >(argp1);
48540 {
48541 PyThreadState* __tstate = wxPyBeginAllowThreads();
48542 result = (arg1)->GetMinSize();
48543 wxPyEndAllowThreads(__tstate);
48544 if (PyErr_Occurred()) SWIG_fail;
48545 }
48546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48547 return resultobj;
48548 fail:
48549 return NULL;
48550 }
48551
48552
48553 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48554 PyObject *resultobj = 0;
48555 wxSizer *arg1 = (wxSizer *) 0 ;
48556 void *argp1 = 0 ;
48557 int res1 = 0 ;
48558 PyObject *swig_obj[1] ;
48559
48560 if (!args) SWIG_fail;
48561 swig_obj[0] = args;
48562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48563 if (!SWIG_IsOK(res1)) {
48564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48565 }
48566 arg1 = reinterpret_cast< wxSizer * >(argp1);
48567 {
48568 PyThreadState* __tstate = wxPyBeginAllowThreads();
48569 (arg1)->RecalcSizes();
48570 wxPyEndAllowThreads(__tstate);
48571 if (PyErr_Occurred()) SWIG_fail;
48572 }
48573 resultobj = SWIG_Py_Void();
48574 return resultobj;
48575 fail:
48576 return NULL;
48577 }
48578
48579
48580 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48581 PyObject *resultobj = 0;
48582 wxSizer *arg1 = (wxSizer *) 0 ;
48583 wxSize result;
48584 void *argp1 = 0 ;
48585 int res1 = 0 ;
48586 PyObject *swig_obj[1] ;
48587
48588 if (!args) SWIG_fail;
48589 swig_obj[0] = args;
48590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48591 if (!SWIG_IsOK(res1)) {
48592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48593 }
48594 arg1 = reinterpret_cast< wxSizer * >(argp1);
48595 {
48596 PyThreadState* __tstate = wxPyBeginAllowThreads();
48597 result = (arg1)->CalcMin();
48598 wxPyEndAllowThreads(__tstate);
48599 if (PyErr_Occurred()) SWIG_fail;
48600 }
48601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48602 return resultobj;
48603 fail:
48604 return NULL;
48605 }
48606
48607
48608 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48609 PyObject *resultobj = 0;
48610 wxSizer *arg1 = (wxSizer *) 0 ;
48611 void *argp1 = 0 ;
48612 int res1 = 0 ;
48613 PyObject *swig_obj[1] ;
48614
48615 if (!args) SWIG_fail;
48616 swig_obj[0] = args;
48617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48618 if (!SWIG_IsOK(res1)) {
48619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48620 }
48621 arg1 = reinterpret_cast< wxSizer * >(argp1);
48622 {
48623 PyThreadState* __tstate = wxPyBeginAllowThreads();
48624 (arg1)->Layout();
48625 wxPyEndAllowThreads(__tstate);
48626 if (PyErr_Occurred()) SWIG_fail;
48627 }
48628 resultobj = SWIG_Py_Void();
48629 return resultobj;
48630 fail:
48631 return NULL;
48632 }
48633
48634
48635 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48636 PyObject *resultobj = 0;
48637 wxSizer *arg1 = (wxSizer *) 0 ;
48638 wxWindow *arg2 = (wxWindow *) 0 ;
48639 wxSize result;
48640 void *argp1 = 0 ;
48641 int res1 = 0 ;
48642 void *argp2 = 0 ;
48643 int res2 = 0 ;
48644 PyObject * obj0 = 0 ;
48645 PyObject * obj1 = 0 ;
48646 char * kwnames[] = {
48647 (char *) "self",(char *) "window", NULL
48648 };
48649
48650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48652 if (!SWIG_IsOK(res1)) {
48653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48654 }
48655 arg1 = reinterpret_cast< wxSizer * >(argp1);
48656 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48657 if (!SWIG_IsOK(res2)) {
48658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48659 }
48660 arg2 = reinterpret_cast< wxWindow * >(argp2);
48661 {
48662 PyThreadState* __tstate = wxPyBeginAllowThreads();
48663 result = (arg1)->Fit(arg2);
48664 wxPyEndAllowThreads(__tstate);
48665 if (PyErr_Occurred()) SWIG_fail;
48666 }
48667 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48668 return resultobj;
48669 fail:
48670 return NULL;
48671 }
48672
48673
48674 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48675 PyObject *resultobj = 0;
48676 wxSizer *arg1 = (wxSizer *) 0 ;
48677 wxWindow *arg2 = (wxWindow *) 0 ;
48678 void *argp1 = 0 ;
48679 int res1 = 0 ;
48680 void *argp2 = 0 ;
48681 int res2 = 0 ;
48682 PyObject * obj0 = 0 ;
48683 PyObject * obj1 = 0 ;
48684 char * kwnames[] = {
48685 (char *) "self",(char *) "window", NULL
48686 };
48687
48688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48690 if (!SWIG_IsOK(res1)) {
48691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48692 }
48693 arg1 = reinterpret_cast< wxSizer * >(argp1);
48694 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48695 if (!SWIG_IsOK(res2)) {
48696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48697 }
48698 arg2 = reinterpret_cast< wxWindow * >(argp2);
48699 {
48700 PyThreadState* __tstate = wxPyBeginAllowThreads();
48701 (arg1)->FitInside(arg2);
48702 wxPyEndAllowThreads(__tstate);
48703 if (PyErr_Occurred()) SWIG_fail;
48704 }
48705 resultobj = SWIG_Py_Void();
48706 return resultobj;
48707 fail:
48708 return NULL;
48709 }
48710
48711
48712 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48713 PyObject *resultobj = 0;
48714 wxSizer *arg1 = (wxSizer *) 0 ;
48715 wxWindow *arg2 = (wxWindow *) 0 ;
48716 void *argp1 = 0 ;
48717 int res1 = 0 ;
48718 void *argp2 = 0 ;
48719 int res2 = 0 ;
48720 PyObject * obj0 = 0 ;
48721 PyObject * obj1 = 0 ;
48722 char * kwnames[] = {
48723 (char *) "self",(char *) "window", NULL
48724 };
48725
48726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48728 if (!SWIG_IsOK(res1)) {
48729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48730 }
48731 arg1 = reinterpret_cast< wxSizer * >(argp1);
48732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48733 if (!SWIG_IsOK(res2)) {
48734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48735 }
48736 arg2 = reinterpret_cast< wxWindow * >(argp2);
48737 {
48738 PyThreadState* __tstate = wxPyBeginAllowThreads();
48739 (arg1)->SetSizeHints(arg2);
48740 wxPyEndAllowThreads(__tstate);
48741 if (PyErr_Occurred()) SWIG_fail;
48742 }
48743 resultobj = SWIG_Py_Void();
48744 return resultobj;
48745 fail:
48746 return NULL;
48747 }
48748
48749
48750 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48751 PyObject *resultobj = 0;
48752 wxSizer *arg1 = (wxSizer *) 0 ;
48753 wxWindow *arg2 = (wxWindow *) 0 ;
48754 void *argp1 = 0 ;
48755 int res1 = 0 ;
48756 void *argp2 = 0 ;
48757 int res2 = 0 ;
48758 PyObject * obj0 = 0 ;
48759 PyObject * obj1 = 0 ;
48760 char * kwnames[] = {
48761 (char *) "self",(char *) "window", NULL
48762 };
48763
48764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48766 if (!SWIG_IsOK(res1)) {
48767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48768 }
48769 arg1 = reinterpret_cast< wxSizer * >(argp1);
48770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48771 if (!SWIG_IsOK(res2)) {
48772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48773 }
48774 arg2 = reinterpret_cast< wxWindow * >(argp2);
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 (arg1)->SetVirtualSizeHints(arg2);
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 resultobj = SWIG_Py_Void();
48782 return resultobj;
48783 fail:
48784 return NULL;
48785 }
48786
48787
48788 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48789 PyObject *resultobj = 0;
48790 wxSizer *arg1 = (wxSizer *) 0 ;
48791 bool arg2 = (bool) false ;
48792 void *argp1 = 0 ;
48793 int res1 = 0 ;
48794 bool val2 ;
48795 int ecode2 = 0 ;
48796 PyObject * obj0 = 0 ;
48797 PyObject * obj1 = 0 ;
48798 char * kwnames[] = {
48799 (char *) "self",(char *) "deleteWindows", NULL
48800 };
48801
48802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48804 if (!SWIG_IsOK(res1)) {
48805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48806 }
48807 arg1 = reinterpret_cast< wxSizer * >(argp1);
48808 if (obj1) {
48809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48810 if (!SWIG_IsOK(ecode2)) {
48811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48812 }
48813 arg2 = static_cast< bool >(val2);
48814 }
48815 {
48816 PyThreadState* __tstate = wxPyBeginAllowThreads();
48817 (arg1)->Clear(arg2);
48818 wxPyEndAllowThreads(__tstate);
48819 if (PyErr_Occurred()) SWIG_fail;
48820 }
48821 resultobj = SWIG_Py_Void();
48822 return resultobj;
48823 fail:
48824 return NULL;
48825 }
48826
48827
48828 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48829 PyObject *resultobj = 0;
48830 wxSizer *arg1 = (wxSizer *) 0 ;
48831 void *argp1 = 0 ;
48832 int res1 = 0 ;
48833 PyObject *swig_obj[1] ;
48834
48835 if (!args) SWIG_fail;
48836 swig_obj[0] = args;
48837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48838 if (!SWIG_IsOK(res1)) {
48839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48840 }
48841 arg1 = reinterpret_cast< wxSizer * >(argp1);
48842 {
48843 PyThreadState* __tstate = wxPyBeginAllowThreads();
48844 (arg1)->DeleteWindows();
48845 wxPyEndAllowThreads(__tstate);
48846 if (PyErr_Occurred()) SWIG_fail;
48847 }
48848 resultobj = SWIG_Py_Void();
48849 return resultobj;
48850 fail:
48851 return NULL;
48852 }
48853
48854
48855 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48856 PyObject *resultobj = 0;
48857 wxSizer *arg1 = (wxSizer *) 0 ;
48858 PyObject *result = 0 ;
48859 void *argp1 = 0 ;
48860 int res1 = 0 ;
48861 PyObject *swig_obj[1] ;
48862
48863 if (!args) SWIG_fail;
48864 swig_obj[0] = args;
48865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48866 if (!SWIG_IsOK(res1)) {
48867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48868 }
48869 arg1 = reinterpret_cast< wxSizer * >(argp1);
48870 {
48871 PyThreadState* __tstate = wxPyBeginAllowThreads();
48872 result = (PyObject *)wxSizer_GetChildren(arg1);
48873 wxPyEndAllowThreads(__tstate);
48874 if (PyErr_Occurred()) SWIG_fail;
48875 }
48876 resultobj = result;
48877 return resultobj;
48878 fail:
48879 return NULL;
48880 }
48881
48882
48883 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48884 PyObject *resultobj = 0;
48885 wxSizer *arg1 = (wxSizer *) 0 ;
48886 PyObject *arg2 = (PyObject *) 0 ;
48887 bool arg3 = (bool) true ;
48888 bool arg4 = (bool) false ;
48889 bool result;
48890 void *argp1 = 0 ;
48891 int res1 = 0 ;
48892 bool val3 ;
48893 int ecode3 = 0 ;
48894 bool val4 ;
48895 int ecode4 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 PyObject * obj2 = 0 ;
48899 PyObject * obj3 = 0 ;
48900 char * kwnames[] = {
48901 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48902 };
48903
48904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48906 if (!SWIG_IsOK(res1)) {
48907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48908 }
48909 arg1 = reinterpret_cast< wxSizer * >(argp1);
48910 arg2 = obj1;
48911 if (obj2) {
48912 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48913 if (!SWIG_IsOK(ecode3)) {
48914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48915 }
48916 arg3 = static_cast< bool >(val3);
48917 }
48918 if (obj3) {
48919 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48920 if (!SWIG_IsOK(ecode4)) {
48921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48922 }
48923 arg4 = static_cast< bool >(val4);
48924 }
48925 {
48926 PyThreadState* __tstate = wxPyBeginAllowThreads();
48927 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48928 wxPyEndAllowThreads(__tstate);
48929 if (PyErr_Occurred()) SWIG_fail;
48930 }
48931 {
48932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48933 }
48934 return resultobj;
48935 fail:
48936 return NULL;
48937 }
48938
48939
48940 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48941 PyObject *resultobj = 0;
48942 wxSizer *arg1 = (wxSizer *) 0 ;
48943 PyObject *arg2 = (PyObject *) 0 ;
48944 bool result;
48945 void *argp1 = 0 ;
48946 int res1 = 0 ;
48947 PyObject * obj0 = 0 ;
48948 PyObject * obj1 = 0 ;
48949 char * kwnames[] = {
48950 (char *) "self",(char *) "item", NULL
48951 };
48952
48953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48955 if (!SWIG_IsOK(res1)) {
48956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48957 }
48958 arg1 = reinterpret_cast< wxSizer * >(argp1);
48959 arg2 = obj1;
48960 {
48961 PyThreadState* __tstate = wxPyBeginAllowThreads();
48962 result = (bool)wxSizer_IsShown(arg1,arg2);
48963 wxPyEndAllowThreads(__tstate);
48964 if (PyErr_Occurred()) SWIG_fail;
48965 }
48966 {
48967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48968 }
48969 return resultobj;
48970 fail:
48971 return NULL;
48972 }
48973
48974
48975 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48976 PyObject *resultobj = 0;
48977 wxSizer *arg1 = (wxSizer *) 0 ;
48978 bool arg2 ;
48979 void *argp1 = 0 ;
48980 int res1 = 0 ;
48981 bool val2 ;
48982 int ecode2 = 0 ;
48983 PyObject * obj0 = 0 ;
48984 PyObject * obj1 = 0 ;
48985 char * kwnames[] = {
48986 (char *) "self",(char *) "show", NULL
48987 };
48988
48989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48991 if (!SWIG_IsOK(res1)) {
48992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48993 }
48994 arg1 = reinterpret_cast< wxSizer * >(argp1);
48995 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48996 if (!SWIG_IsOK(ecode2)) {
48997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48998 }
48999 arg2 = static_cast< bool >(val2);
49000 {
49001 PyThreadState* __tstate = wxPyBeginAllowThreads();
49002 (arg1)->ShowItems(arg2);
49003 wxPyEndAllowThreads(__tstate);
49004 if (PyErr_Occurred()) SWIG_fail;
49005 }
49006 resultobj = SWIG_Py_Void();
49007 return resultobj;
49008 fail:
49009 return NULL;
49010 }
49011
49012
49013 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49014 PyObject *obj;
49015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49016 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49017 return SWIG_Py_Void();
49018 }
49019
49020 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49021 PyObject *resultobj = 0;
49022 wxPySizer *result = 0 ;
49023
49024 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 result = (wxPySizer *)new wxPySizer();
49028 wxPyEndAllowThreads(__tstate);
49029 if (PyErr_Occurred()) SWIG_fail;
49030 }
49031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49039 PyObject *resultobj = 0;
49040 wxPySizer *arg1 = (wxPySizer *) 0 ;
49041 PyObject *arg2 = (PyObject *) 0 ;
49042 PyObject *arg3 = (PyObject *) 0 ;
49043 void *argp1 = 0 ;
49044 int res1 = 0 ;
49045 PyObject * obj0 = 0 ;
49046 PyObject * obj1 = 0 ;
49047 PyObject * obj2 = 0 ;
49048 char * kwnames[] = {
49049 (char *) "self",(char *) "self",(char *) "_class", NULL
49050 };
49051
49052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49054 if (!SWIG_IsOK(res1)) {
49055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49056 }
49057 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49058 arg2 = obj1;
49059 arg3 = obj2;
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 (arg1)->_setCallbackInfo(arg2,arg3);
49063 wxPyEndAllowThreads(__tstate);
49064 if (PyErr_Occurred()) SWIG_fail;
49065 }
49066 resultobj = SWIG_Py_Void();
49067 return resultobj;
49068 fail:
49069 return NULL;
49070 }
49071
49072
49073 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49074 PyObject *obj;
49075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49077 return SWIG_Py_Void();
49078 }
49079
49080 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49081 return SWIG_Python_InitShadowInstance(args);
49082 }
49083
49084 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49085 PyObject *resultobj = 0;
49086 int arg1 = (int) wxHORIZONTAL ;
49087 wxBoxSizer *result = 0 ;
49088 int val1 ;
49089 int ecode1 = 0 ;
49090 PyObject * obj0 = 0 ;
49091 char * kwnames[] = {
49092 (char *) "orient", NULL
49093 };
49094
49095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49096 if (obj0) {
49097 ecode1 = SWIG_AsVal_int(obj0, &val1);
49098 if (!SWIG_IsOK(ecode1)) {
49099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49100 }
49101 arg1 = static_cast< int >(val1);
49102 }
49103 {
49104 PyThreadState* __tstate = wxPyBeginAllowThreads();
49105 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49117 PyObject *resultobj = 0;
49118 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49119 int result;
49120 void *argp1 = 0 ;
49121 int res1 = 0 ;
49122 PyObject *swig_obj[1] ;
49123
49124 if (!args) SWIG_fail;
49125 swig_obj[0] = args;
49126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49127 if (!SWIG_IsOK(res1)) {
49128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49129 }
49130 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49131 {
49132 PyThreadState* __tstate = wxPyBeginAllowThreads();
49133 result = (int)(arg1)->GetOrientation();
49134 wxPyEndAllowThreads(__tstate);
49135 if (PyErr_Occurred()) SWIG_fail;
49136 }
49137 resultobj = SWIG_From_int(static_cast< int >(result));
49138 return resultobj;
49139 fail:
49140 return NULL;
49141 }
49142
49143
49144 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49145 PyObject *resultobj = 0;
49146 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49147 int arg2 ;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 int val2 ;
49151 int ecode2 = 0 ;
49152 PyObject * obj0 = 0 ;
49153 PyObject * obj1 = 0 ;
49154 char * kwnames[] = {
49155 (char *) "self",(char *) "orient", NULL
49156 };
49157
49158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49160 if (!SWIG_IsOK(res1)) {
49161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49162 }
49163 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49164 ecode2 = SWIG_AsVal_int(obj1, &val2);
49165 if (!SWIG_IsOK(ecode2)) {
49166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49167 }
49168 arg2 = static_cast< int >(val2);
49169 {
49170 PyThreadState* __tstate = wxPyBeginAllowThreads();
49171 (arg1)->SetOrientation(arg2);
49172 wxPyEndAllowThreads(__tstate);
49173 if (PyErr_Occurred()) SWIG_fail;
49174 }
49175 resultobj = SWIG_Py_Void();
49176 return resultobj;
49177 fail:
49178 return NULL;
49179 }
49180
49181
49182 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49183 PyObject *obj;
49184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49185 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49186 return SWIG_Py_Void();
49187 }
49188
49189 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49190 return SWIG_Python_InitShadowInstance(args);
49191 }
49192
49193 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49194 PyObject *resultobj = 0;
49195 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49196 int arg2 = (int) wxHORIZONTAL ;
49197 wxStaticBoxSizer *result = 0 ;
49198 void *argp1 = 0 ;
49199 int res1 = 0 ;
49200 int val2 ;
49201 int ecode2 = 0 ;
49202 PyObject * obj0 = 0 ;
49203 PyObject * obj1 = 0 ;
49204 char * kwnames[] = {
49205 (char *) "box",(char *) "orient", NULL
49206 };
49207
49208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49210 if (!SWIG_IsOK(res1)) {
49211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49212 }
49213 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49214 if (obj1) {
49215 ecode2 = SWIG_AsVal_int(obj1, &val2);
49216 if (!SWIG_IsOK(ecode2)) {
49217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49218 }
49219 arg2 = static_cast< int >(val2);
49220 }
49221 {
49222 PyThreadState* __tstate = wxPyBeginAllowThreads();
49223 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49224 wxPyEndAllowThreads(__tstate);
49225 if (PyErr_Occurred()) SWIG_fail;
49226 }
49227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49228 return resultobj;
49229 fail:
49230 return NULL;
49231 }
49232
49233
49234 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49235 PyObject *resultobj = 0;
49236 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49237 wxStaticBox *result = 0 ;
49238 void *argp1 = 0 ;
49239 int res1 = 0 ;
49240 PyObject *swig_obj[1] ;
49241
49242 if (!args) SWIG_fail;
49243 swig_obj[0] = args;
49244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49245 if (!SWIG_IsOK(res1)) {
49246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49247 }
49248 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49249 {
49250 PyThreadState* __tstate = wxPyBeginAllowThreads();
49251 result = (wxStaticBox *)(arg1)->GetStaticBox();
49252 wxPyEndAllowThreads(__tstate);
49253 if (PyErr_Occurred()) SWIG_fail;
49254 }
49255 {
49256 resultobj = wxPyMake_wxObject(result, (bool)0);
49257 }
49258 return resultobj;
49259 fail:
49260 return NULL;
49261 }
49262
49263
49264 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49265 PyObject *obj;
49266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49267 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49268 return SWIG_Py_Void();
49269 }
49270
49271 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49272 return SWIG_Python_InitShadowInstance(args);
49273 }
49274
49275 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49276 PyObject *resultobj = 0;
49277 int arg1 = (int) 1 ;
49278 int arg2 = (int) 0 ;
49279 int arg3 = (int) 0 ;
49280 int arg4 = (int) 0 ;
49281 wxGridSizer *result = 0 ;
49282 int val1 ;
49283 int ecode1 = 0 ;
49284 int val2 ;
49285 int ecode2 = 0 ;
49286 int val3 ;
49287 int ecode3 = 0 ;
49288 int val4 ;
49289 int ecode4 = 0 ;
49290 PyObject * obj0 = 0 ;
49291 PyObject * obj1 = 0 ;
49292 PyObject * obj2 = 0 ;
49293 PyObject * obj3 = 0 ;
49294 char * kwnames[] = {
49295 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49296 };
49297
49298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49299 if (obj0) {
49300 ecode1 = SWIG_AsVal_int(obj0, &val1);
49301 if (!SWIG_IsOK(ecode1)) {
49302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49303 }
49304 arg1 = static_cast< int >(val1);
49305 }
49306 if (obj1) {
49307 ecode2 = SWIG_AsVal_int(obj1, &val2);
49308 if (!SWIG_IsOK(ecode2)) {
49309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49310 }
49311 arg2 = static_cast< int >(val2);
49312 }
49313 if (obj2) {
49314 ecode3 = SWIG_AsVal_int(obj2, &val3);
49315 if (!SWIG_IsOK(ecode3)) {
49316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49317 }
49318 arg3 = static_cast< int >(val3);
49319 }
49320 if (obj3) {
49321 ecode4 = SWIG_AsVal_int(obj3, &val4);
49322 if (!SWIG_IsOK(ecode4)) {
49323 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49324 }
49325 arg4 = static_cast< int >(val4);
49326 }
49327 {
49328 PyThreadState* __tstate = wxPyBeginAllowThreads();
49329 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49330 wxPyEndAllowThreads(__tstate);
49331 if (PyErr_Occurred()) SWIG_fail;
49332 }
49333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49334 return resultobj;
49335 fail:
49336 return NULL;
49337 }
49338
49339
49340 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49341 PyObject *resultobj = 0;
49342 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49343 int arg2 ;
49344 void *argp1 = 0 ;
49345 int res1 = 0 ;
49346 int val2 ;
49347 int ecode2 = 0 ;
49348 PyObject * obj0 = 0 ;
49349 PyObject * obj1 = 0 ;
49350 char * kwnames[] = {
49351 (char *) "self",(char *) "cols", NULL
49352 };
49353
49354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49356 if (!SWIG_IsOK(res1)) {
49357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49358 }
49359 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49360 ecode2 = SWIG_AsVal_int(obj1, &val2);
49361 if (!SWIG_IsOK(ecode2)) {
49362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49363 }
49364 arg2 = static_cast< int >(val2);
49365 {
49366 PyThreadState* __tstate = wxPyBeginAllowThreads();
49367 (arg1)->SetCols(arg2);
49368 wxPyEndAllowThreads(__tstate);
49369 if (PyErr_Occurred()) SWIG_fail;
49370 }
49371 resultobj = SWIG_Py_Void();
49372 return resultobj;
49373 fail:
49374 return NULL;
49375 }
49376
49377
49378 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49379 PyObject *resultobj = 0;
49380 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49381 int arg2 ;
49382 void *argp1 = 0 ;
49383 int res1 = 0 ;
49384 int val2 ;
49385 int ecode2 = 0 ;
49386 PyObject * obj0 = 0 ;
49387 PyObject * obj1 = 0 ;
49388 char * kwnames[] = {
49389 (char *) "self",(char *) "rows", NULL
49390 };
49391
49392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49394 if (!SWIG_IsOK(res1)) {
49395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49396 }
49397 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49398 ecode2 = SWIG_AsVal_int(obj1, &val2);
49399 if (!SWIG_IsOK(ecode2)) {
49400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49401 }
49402 arg2 = static_cast< int >(val2);
49403 {
49404 PyThreadState* __tstate = wxPyBeginAllowThreads();
49405 (arg1)->SetRows(arg2);
49406 wxPyEndAllowThreads(__tstate);
49407 if (PyErr_Occurred()) SWIG_fail;
49408 }
49409 resultobj = SWIG_Py_Void();
49410 return resultobj;
49411 fail:
49412 return NULL;
49413 }
49414
49415
49416 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49417 PyObject *resultobj = 0;
49418 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49419 int arg2 ;
49420 void *argp1 = 0 ;
49421 int res1 = 0 ;
49422 int val2 ;
49423 int ecode2 = 0 ;
49424 PyObject * obj0 = 0 ;
49425 PyObject * obj1 = 0 ;
49426 char * kwnames[] = {
49427 (char *) "self",(char *) "gap", NULL
49428 };
49429
49430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49432 if (!SWIG_IsOK(res1)) {
49433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49434 }
49435 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49436 ecode2 = SWIG_AsVal_int(obj1, &val2);
49437 if (!SWIG_IsOK(ecode2)) {
49438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49439 }
49440 arg2 = static_cast< int >(val2);
49441 {
49442 PyThreadState* __tstate = wxPyBeginAllowThreads();
49443 (arg1)->SetVGap(arg2);
49444 wxPyEndAllowThreads(__tstate);
49445 if (PyErr_Occurred()) SWIG_fail;
49446 }
49447 resultobj = SWIG_Py_Void();
49448 return resultobj;
49449 fail:
49450 return NULL;
49451 }
49452
49453
49454 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49455 PyObject *resultobj = 0;
49456 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49457 int arg2 ;
49458 void *argp1 = 0 ;
49459 int res1 = 0 ;
49460 int val2 ;
49461 int ecode2 = 0 ;
49462 PyObject * obj0 = 0 ;
49463 PyObject * obj1 = 0 ;
49464 char * kwnames[] = {
49465 (char *) "self",(char *) "gap", NULL
49466 };
49467
49468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49470 if (!SWIG_IsOK(res1)) {
49471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49472 }
49473 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49474 ecode2 = SWIG_AsVal_int(obj1, &val2);
49475 if (!SWIG_IsOK(ecode2)) {
49476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49477 }
49478 arg2 = static_cast< int >(val2);
49479 {
49480 PyThreadState* __tstate = wxPyBeginAllowThreads();
49481 (arg1)->SetHGap(arg2);
49482 wxPyEndAllowThreads(__tstate);
49483 if (PyErr_Occurred()) SWIG_fail;
49484 }
49485 resultobj = SWIG_Py_Void();
49486 return resultobj;
49487 fail:
49488 return NULL;
49489 }
49490
49491
49492 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49493 PyObject *resultobj = 0;
49494 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49495 int result;
49496 void *argp1 = 0 ;
49497 int res1 = 0 ;
49498 PyObject *swig_obj[1] ;
49499
49500 if (!args) SWIG_fail;
49501 swig_obj[0] = args;
49502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49503 if (!SWIG_IsOK(res1)) {
49504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49505 }
49506 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49507 {
49508 PyThreadState* __tstate = wxPyBeginAllowThreads();
49509 result = (int)(arg1)->GetCols();
49510 wxPyEndAllowThreads(__tstate);
49511 if (PyErr_Occurred()) SWIG_fail;
49512 }
49513 resultobj = SWIG_From_int(static_cast< int >(result));
49514 return resultobj;
49515 fail:
49516 return NULL;
49517 }
49518
49519
49520 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49521 PyObject *resultobj = 0;
49522 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49523 int result;
49524 void *argp1 = 0 ;
49525 int res1 = 0 ;
49526 PyObject *swig_obj[1] ;
49527
49528 if (!args) SWIG_fail;
49529 swig_obj[0] = args;
49530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49531 if (!SWIG_IsOK(res1)) {
49532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49533 }
49534 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49535 {
49536 PyThreadState* __tstate = wxPyBeginAllowThreads();
49537 result = (int)(arg1)->GetRows();
49538 wxPyEndAllowThreads(__tstate);
49539 if (PyErr_Occurred()) SWIG_fail;
49540 }
49541 resultobj = SWIG_From_int(static_cast< int >(result));
49542 return resultobj;
49543 fail:
49544 return NULL;
49545 }
49546
49547
49548 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49549 PyObject *resultobj = 0;
49550 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49551 int result;
49552 void *argp1 = 0 ;
49553 int res1 = 0 ;
49554 PyObject *swig_obj[1] ;
49555
49556 if (!args) SWIG_fail;
49557 swig_obj[0] = args;
49558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49559 if (!SWIG_IsOK(res1)) {
49560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49561 }
49562 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49563 {
49564 PyThreadState* __tstate = wxPyBeginAllowThreads();
49565 result = (int)(arg1)->GetVGap();
49566 wxPyEndAllowThreads(__tstate);
49567 if (PyErr_Occurred()) SWIG_fail;
49568 }
49569 resultobj = SWIG_From_int(static_cast< int >(result));
49570 return resultobj;
49571 fail:
49572 return NULL;
49573 }
49574
49575
49576 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49577 PyObject *resultobj = 0;
49578 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49579 int result;
49580 void *argp1 = 0 ;
49581 int res1 = 0 ;
49582 PyObject *swig_obj[1] ;
49583
49584 if (!args) SWIG_fail;
49585 swig_obj[0] = args;
49586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49587 if (!SWIG_IsOK(res1)) {
49588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49589 }
49590 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49591 {
49592 PyThreadState* __tstate = wxPyBeginAllowThreads();
49593 result = (int)(arg1)->GetHGap();
49594 wxPyEndAllowThreads(__tstate);
49595 if (PyErr_Occurred()) SWIG_fail;
49596 }
49597 resultobj = SWIG_From_int(static_cast< int >(result));
49598 return resultobj;
49599 fail:
49600 return NULL;
49601 }
49602
49603
49604 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49605 PyObject *obj;
49606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49607 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49608 return SWIG_Py_Void();
49609 }
49610
49611 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49612 return SWIG_Python_InitShadowInstance(args);
49613 }
49614
49615 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49616 PyObject *resultobj = 0;
49617 int arg1 = (int) 1 ;
49618 int arg2 = (int) 0 ;
49619 int arg3 = (int) 0 ;
49620 int arg4 = (int) 0 ;
49621 wxFlexGridSizer *result = 0 ;
49622 int val1 ;
49623 int ecode1 = 0 ;
49624 int val2 ;
49625 int ecode2 = 0 ;
49626 int val3 ;
49627 int ecode3 = 0 ;
49628 int val4 ;
49629 int ecode4 = 0 ;
49630 PyObject * obj0 = 0 ;
49631 PyObject * obj1 = 0 ;
49632 PyObject * obj2 = 0 ;
49633 PyObject * obj3 = 0 ;
49634 char * kwnames[] = {
49635 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49636 };
49637
49638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49639 if (obj0) {
49640 ecode1 = SWIG_AsVal_int(obj0, &val1);
49641 if (!SWIG_IsOK(ecode1)) {
49642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49643 }
49644 arg1 = static_cast< int >(val1);
49645 }
49646 if (obj1) {
49647 ecode2 = SWIG_AsVal_int(obj1, &val2);
49648 if (!SWIG_IsOK(ecode2)) {
49649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49650 }
49651 arg2 = static_cast< int >(val2);
49652 }
49653 if (obj2) {
49654 ecode3 = SWIG_AsVal_int(obj2, &val3);
49655 if (!SWIG_IsOK(ecode3)) {
49656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49657 }
49658 arg3 = static_cast< int >(val3);
49659 }
49660 if (obj3) {
49661 ecode4 = SWIG_AsVal_int(obj3, &val4);
49662 if (!SWIG_IsOK(ecode4)) {
49663 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49664 }
49665 arg4 = static_cast< int >(val4);
49666 }
49667 {
49668 PyThreadState* __tstate = wxPyBeginAllowThreads();
49669 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49670 wxPyEndAllowThreads(__tstate);
49671 if (PyErr_Occurred()) SWIG_fail;
49672 }
49673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49674 return resultobj;
49675 fail:
49676 return NULL;
49677 }
49678
49679
49680 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49681 PyObject *resultobj = 0;
49682 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49683 size_t arg2 ;
49684 int arg3 = (int) 0 ;
49685 void *argp1 = 0 ;
49686 int res1 = 0 ;
49687 size_t val2 ;
49688 int ecode2 = 0 ;
49689 int val3 ;
49690 int ecode3 = 0 ;
49691 PyObject * obj0 = 0 ;
49692 PyObject * obj1 = 0 ;
49693 PyObject * obj2 = 0 ;
49694 char * kwnames[] = {
49695 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49696 };
49697
49698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49700 if (!SWIG_IsOK(res1)) {
49701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49702 }
49703 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49704 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49705 if (!SWIG_IsOK(ecode2)) {
49706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49707 }
49708 arg2 = static_cast< size_t >(val2);
49709 if (obj2) {
49710 ecode3 = SWIG_AsVal_int(obj2, &val3);
49711 if (!SWIG_IsOK(ecode3)) {
49712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49713 }
49714 arg3 = static_cast< int >(val3);
49715 }
49716 {
49717 PyThreadState* __tstate = wxPyBeginAllowThreads();
49718 (arg1)->AddGrowableRow(arg2,arg3);
49719 wxPyEndAllowThreads(__tstate);
49720 if (PyErr_Occurred()) SWIG_fail;
49721 }
49722 resultobj = SWIG_Py_Void();
49723 return resultobj;
49724 fail:
49725 return NULL;
49726 }
49727
49728
49729 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49730 PyObject *resultobj = 0;
49731 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49732 size_t arg2 ;
49733 void *argp1 = 0 ;
49734 int res1 = 0 ;
49735 size_t val2 ;
49736 int ecode2 = 0 ;
49737 PyObject * obj0 = 0 ;
49738 PyObject * obj1 = 0 ;
49739 char * kwnames[] = {
49740 (char *) "self",(char *) "idx", NULL
49741 };
49742
49743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49745 if (!SWIG_IsOK(res1)) {
49746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49747 }
49748 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49749 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49750 if (!SWIG_IsOK(ecode2)) {
49751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49752 }
49753 arg2 = static_cast< size_t >(val2);
49754 {
49755 PyThreadState* __tstate = wxPyBeginAllowThreads();
49756 (arg1)->RemoveGrowableRow(arg2);
49757 wxPyEndAllowThreads(__tstate);
49758 if (PyErr_Occurred()) SWIG_fail;
49759 }
49760 resultobj = SWIG_Py_Void();
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49768 PyObject *resultobj = 0;
49769 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49770 size_t arg2 ;
49771 int arg3 = (int) 0 ;
49772 void *argp1 = 0 ;
49773 int res1 = 0 ;
49774 size_t val2 ;
49775 int ecode2 = 0 ;
49776 int val3 ;
49777 int ecode3 = 0 ;
49778 PyObject * obj0 = 0 ;
49779 PyObject * obj1 = 0 ;
49780 PyObject * obj2 = 0 ;
49781 char * kwnames[] = {
49782 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49783 };
49784
49785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49787 if (!SWIG_IsOK(res1)) {
49788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49789 }
49790 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49791 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49792 if (!SWIG_IsOK(ecode2)) {
49793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49794 }
49795 arg2 = static_cast< size_t >(val2);
49796 if (obj2) {
49797 ecode3 = SWIG_AsVal_int(obj2, &val3);
49798 if (!SWIG_IsOK(ecode3)) {
49799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49800 }
49801 arg3 = static_cast< int >(val3);
49802 }
49803 {
49804 PyThreadState* __tstate = wxPyBeginAllowThreads();
49805 (arg1)->AddGrowableCol(arg2,arg3);
49806 wxPyEndAllowThreads(__tstate);
49807 if (PyErr_Occurred()) SWIG_fail;
49808 }
49809 resultobj = SWIG_Py_Void();
49810 return resultobj;
49811 fail:
49812 return NULL;
49813 }
49814
49815
49816 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49817 PyObject *resultobj = 0;
49818 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49819 size_t arg2 ;
49820 void *argp1 = 0 ;
49821 int res1 = 0 ;
49822 size_t val2 ;
49823 int ecode2 = 0 ;
49824 PyObject * obj0 = 0 ;
49825 PyObject * obj1 = 0 ;
49826 char * kwnames[] = {
49827 (char *) "self",(char *) "idx", NULL
49828 };
49829
49830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49832 if (!SWIG_IsOK(res1)) {
49833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49834 }
49835 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49836 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49837 if (!SWIG_IsOK(ecode2)) {
49838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49839 }
49840 arg2 = static_cast< size_t >(val2);
49841 {
49842 PyThreadState* __tstate = wxPyBeginAllowThreads();
49843 (arg1)->RemoveGrowableCol(arg2);
49844 wxPyEndAllowThreads(__tstate);
49845 if (PyErr_Occurred()) SWIG_fail;
49846 }
49847 resultobj = SWIG_Py_Void();
49848 return resultobj;
49849 fail:
49850 return NULL;
49851 }
49852
49853
49854 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49855 PyObject *resultobj = 0;
49856 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49857 int arg2 ;
49858 void *argp1 = 0 ;
49859 int res1 = 0 ;
49860 int val2 ;
49861 int ecode2 = 0 ;
49862 PyObject * obj0 = 0 ;
49863 PyObject * obj1 = 0 ;
49864 char * kwnames[] = {
49865 (char *) "self",(char *) "direction", NULL
49866 };
49867
49868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49870 if (!SWIG_IsOK(res1)) {
49871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49872 }
49873 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49874 ecode2 = SWIG_AsVal_int(obj1, &val2);
49875 if (!SWIG_IsOK(ecode2)) {
49876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49877 }
49878 arg2 = static_cast< int >(val2);
49879 {
49880 PyThreadState* __tstate = wxPyBeginAllowThreads();
49881 (arg1)->SetFlexibleDirection(arg2);
49882 wxPyEndAllowThreads(__tstate);
49883 if (PyErr_Occurred()) SWIG_fail;
49884 }
49885 resultobj = SWIG_Py_Void();
49886 return resultobj;
49887 fail:
49888 return NULL;
49889 }
49890
49891
49892 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49893 PyObject *resultobj = 0;
49894 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49895 int result;
49896 void *argp1 = 0 ;
49897 int res1 = 0 ;
49898 PyObject *swig_obj[1] ;
49899
49900 if (!args) SWIG_fail;
49901 swig_obj[0] = args;
49902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49903 if (!SWIG_IsOK(res1)) {
49904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49905 }
49906 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49907 {
49908 PyThreadState* __tstate = wxPyBeginAllowThreads();
49909 result = (int)(arg1)->GetFlexibleDirection();
49910 wxPyEndAllowThreads(__tstate);
49911 if (PyErr_Occurred()) SWIG_fail;
49912 }
49913 resultobj = SWIG_From_int(static_cast< int >(result));
49914 return resultobj;
49915 fail:
49916 return NULL;
49917 }
49918
49919
49920 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49921 PyObject *resultobj = 0;
49922 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49923 wxFlexSizerGrowMode arg2 ;
49924 void *argp1 = 0 ;
49925 int res1 = 0 ;
49926 int val2 ;
49927 int ecode2 = 0 ;
49928 PyObject * obj0 = 0 ;
49929 PyObject * obj1 = 0 ;
49930 char * kwnames[] = {
49931 (char *) "self",(char *) "mode", NULL
49932 };
49933
49934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49936 if (!SWIG_IsOK(res1)) {
49937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49938 }
49939 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49940 ecode2 = SWIG_AsVal_int(obj1, &val2);
49941 if (!SWIG_IsOK(ecode2)) {
49942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49943 }
49944 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49945 {
49946 PyThreadState* __tstate = wxPyBeginAllowThreads();
49947 (arg1)->SetNonFlexibleGrowMode(arg2);
49948 wxPyEndAllowThreads(__tstate);
49949 if (PyErr_Occurred()) SWIG_fail;
49950 }
49951 resultobj = SWIG_Py_Void();
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49959 PyObject *resultobj = 0;
49960 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49961 wxFlexSizerGrowMode 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_wxFlexGridSizer, 0 | 0 );
49969 if (!SWIG_IsOK(res1)) {
49970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49971 }
49972 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49973 {
49974 PyThreadState* __tstate = wxPyBeginAllowThreads();
49975 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49976 wxPyEndAllowThreads(__tstate);
49977 if (PyErr_Occurred()) SWIG_fail;
49978 }
49979 resultobj = SWIG_From_int(static_cast< int >(result));
49980 return resultobj;
49981 fail:
49982 return NULL;
49983 }
49984
49985
49986 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49987 PyObject *resultobj = 0;
49988 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49989 wxArrayInt *result = 0 ;
49990 void *argp1 = 0 ;
49991 int res1 = 0 ;
49992 PyObject *swig_obj[1] ;
49993
49994 if (!args) SWIG_fail;
49995 swig_obj[0] = args;
49996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49997 if (!SWIG_IsOK(res1)) {
49998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49999 }
50000 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50001 {
50002 PyThreadState* __tstate = wxPyBeginAllowThreads();
50003 {
50004 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50005 result = (wxArrayInt *) &_result_ref;
50006 }
50007 wxPyEndAllowThreads(__tstate);
50008 if (PyErr_Occurred()) SWIG_fail;
50009 }
50010 {
50011 resultobj = wxArrayInt2PyList_helper(*result);
50012 }
50013 return resultobj;
50014 fail:
50015 return NULL;
50016 }
50017
50018
50019 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50020 PyObject *resultobj = 0;
50021 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50022 wxArrayInt *result = 0 ;
50023 void *argp1 = 0 ;
50024 int res1 = 0 ;
50025 PyObject *swig_obj[1] ;
50026
50027 if (!args) SWIG_fail;
50028 swig_obj[0] = args;
50029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50030 if (!SWIG_IsOK(res1)) {
50031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50032 }
50033 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50034 {
50035 PyThreadState* __tstate = wxPyBeginAllowThreads();
50036 {
50037 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50038 result = (wxArrayInt *) &_result_ref;
50039 }
50040 wxPyEndAllowThreads(__tstate);
50041 if (PyErr_Occurred()) SWIG_fail;
50042 }
50043 {
50044 resultobj = wxArrayInt2PyList_helper(*result);
50045 }
50046 return resultobj;
50047 fail:
50048 return NULL;
50049 }
50050
50051
50052 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50053 PyObject *obj;
50054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50055 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50056 return SWIG_Py_Void();
50057 }
50058
50059 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50060 return SWIG_Python_InitShadowInstance(args);
50061 }
50062
50063 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50064 PyObject *resultobj = 0;
50065 wxStdDialogButtonSizer *result = 0 ;
50066
50067 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50068 {
50069 PyThreadState* __tstate = wxPyBeginAllowThreads();
50070 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50071 wxPyEndAllowThreads(__tstate);
50072 if (PyErr_Occurred()) SWIG_fail;
50073 }
50074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50075 return resultobj;
50076 fail:
50077 return NULL;
50078 }
50079
50080
50081 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50082 PyObject *resultobj = 0;
50083 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50084 wxButton *arg2 = (wxButton *) 0 ;
50085 void *argp1 = 0 ;
50086 int res1 = 0 ;
50087 void *argp2 = 0 ;
50088 int res2 = 0 ;
50089 PyObject * obj0 = 0 ;
50090 PyObject * obj1 = 0 ;
50091 char * kwnames[] = {
50092 (char *) "self",(char *) "button", NULL
50093 };
50094
50095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50097 if (!SWIG_IsOK(res1)) {
50098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50099 }
50100 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50102 if (!SWIG_IsOK(res2)) {
50103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50104 }
50105 arg2 = reinterpret_cast< wxButton * >(argp2);
50106 {
50107 PyThreadState* __tstate = wxPyBeginAllowThreads();
50108 (arg1)->AddButton(arg2);
50109 wxPyEndAllowThreads(__tstate);
50110 if (PyErr_Occurred()) SWIG_fail;
50111 }
50112 resultobj = SWIG_Py_Void();
50113 return resultobj;
50114 fail:
50115 return NULL;
50116 }
50117
50118
50119 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50120 PyObject *resultobj = 0;
50121 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50122 void *argp1 = 0 ;
50123 int res1 = 0 ;
50124 PyObject *swig_obj[1] ;
50125
50126 if (!args) SWIG_fail;
50127 swig_obj[0] = args;
50128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50129 if (!SWIG_IsOK(res1)) {
50130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50131 }
50132 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50133 {
50134 PyThreadState* __tstate = wxPyBeginAllowThreads();
50135 (arg1)->Realize();
50136 wxPyEndAllowThreads(__tstate);
50137 if (PyErr_Occurred()) SWIG_fail;
50138 }
50139 resultobj = SWIG_Py_Void();
50140 return resultobj;
50141 fail:
50142 return NULL;
50143 }
50144
50145
50146 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50147 PyObject *resultobj = 0;
50148 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50149 wxButton *arg2 = (wxButton *) 0 ;
50150 void *argp1 = 0 ;
50151 int res1 = 0 ;
50152 void *argp2 = 0 ;
50153 int res2 = 0 ;
50154 PyObject * obj0 = 0 ;
50155 PyObject * obj1 = 0 ;
50156 char * kwnames[] = {
50157 (char *) "self",(char *) "button", NULL
50158 };
50159
50160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50162 if (!SWIG_IsOK(res1)) {
50163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50164 }
50165 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50167 if (!SWIG_IsOK(res2)) {
50168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50169 }
50170 arg2 = reinterpret_cast< wxButton * >(argp2);
50171 {
50172 PyThreadState* __tstate = wxPyBeginAllowThreads();
50173 (arg1)->SetAffirmativeButton(arg2);
50174 wxPyEndAllowThreads(__tstate);
50175 if (PyErr_Occurred()) SWIG_fail;
50176 }
50177 resultobj = SWIG_Py_Void();
50178 return resultobj;
50179 fail:
50180 return NULL;
50181 }
50182
50183
50184 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50185 PyObject *resultobj = 0;
50186 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50187 wxButton *arg2 = (wxButton *) 0 ;
50188 void *argp1 = 0 ;
50189 int res1 = 0 ;
50190 void *argp2 = 0 ;
50191 int res2 = 0 ;
50192 PyObject * obj0 = 0 ;
50193 PyObject * obj1 = 0 ;
50194 char * kwnames[] = {
50195 (char *) "self",(char *) "button", NULL
50196 };
50197
50198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50200 if (!SWIG_IsOK(res1)) {
50201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50202 }
50203 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50205 if (!SWIG_IsOK(res2)) {
50206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50207 }
50208 arg2 = reinterpret_cast< wxButton * >(argp2);
50209 {
50210 PyThreadState* __tstate = wxPyBeginAllowThreads();
50211 (arg1)->SetNegativeButton(arg2);
50212 wxPyEndAllowThreads(__tstate);
50213 if (PyErr_Occurred()) SWIG_fail;
50214 }
50215 resultobj = SWIG_Py_Void();
50216 return resultobj;
50217 fail:
50218 return NULL;
50219 }
50220
50221
50222 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50223 PyObject *resultobj = 0;
50224 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50225 wxButton *arg2 = (wxButton *) 0 ;
50226 void *argp1 = 0 ;
50227 int res1 = 0 ;
50228 void *argp2 = 0 ;
50229 int res2 = 0 ;
50230 PyObject * obj0 = 0 ;
50231 PyObject * obj1 = 0 ;
50232 char * kwnames[] = {
50233 (char *) "self",(char *) "button", NULL
50234 };
50235
50236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50238 if (!SWIG_IsOK(res1)) {
50239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50240 }
50241 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50243 if (!SWIG_IsOK(res2)) {
50244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50245 }
50246 arg2 = reinterpret_cast< wxButton * >(argp2);
50247 {
50248 PyThreadState* __tstate = wxPyBeginAllowThreads();
50249 (arg1)->SetCancelButton(arg2);
50250 wxPyEndAllowThreads(__tstate);
50251 if (PyErr_Occurred()) SWIG_fail;
50252 }
50253 resultobj = SWIG_Py_Void();
50254 return resultobj;
50255 fail:
50256 return NULL;
50257 }
50258
50259
50260 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50261 PyObject *resultobj = 0;
50262 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50263 wxButton *result = 0 ;
50264 void *argp1 = 0 ;
50265 int res1 = 0 ;
50266 PyObject *swig_obj[1] ;
50267
50268 if (!args) SWIG_fail;
50269 swig_obj[0] = args;
50270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50271 if (!SWIG_IsOK(res1)) {
50272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50273 }
50274 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50275 {
50276 PyThreadState* __tstate = wxPyBeginAllowThreads();
50277 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50278 wxPyEndAllowThreads(__tstate);
50279 if (PyErr_Occurred()) SWIG_fail;
50280 }
50281 {
50282 resultobj = wxPyMake_wxObject(result, (bool)0);
50283 }
50284 return resultobj;
50285 fail:
50286 return NULL;
50287 }
50288
50289
50290 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50291 PyObject *resultobj = 0;
50292 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50293 wxButton *result = 0 ;
50294 void *argp1 = 0 ;
50295 int res1 = 0 ;
50296 PyObject *swig_obj[1] ;
50297
50298 if (!args) SWIG_fail;
50299 swig_obj[0] = args;
50300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50301 if (!SWIG_IsOK(res1)) {
50302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50303 }
50304 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50305 {
50306 PyThreadState* __tstate = wxPyBeginAllowThreads();
50307 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50308 wxPyEndAllowThreads(__tstate);
50309 if (PyErr_Occurred()) SWIG_fail;
50310 }
50311 {
50312 resultobj = wxPyMake_wxObject(result, (bool)0);
50313 }
50314 return resultobj;
50315 fail:
50316 return NULL;
50317 }
50318
50319
50320 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50321 PyObject *resultobj = 0;
50322 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50323 wxButton *result = 0 ;
50324 void *argp1 = 0 ;
50325 int res1 = 0 ;
50326 PyObject *swig_obj[1] ;
50327
50328 if (!args) SWIG_fail;
50329 swig_obj[0] = args;
50330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50331 if (!SWIG_IsOK(res1)) {
50332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50333 }
50334 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50335 {
50336 PyThreadState* __tstate = wxPyBeginAllowThreads();
50337 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50338 wxPyEndAllowThreads(__tstate);
50339 if (PyErr_Occurred()) SWIG_fail;
50340 }
50341 {
50342 resultobj = wxPyMake_wxObject(result, (bool)0);
50343 }
50344 return resultobj;
50345 fail:
50346 return NULL;
50347 }
50348
50349
50350 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50351 PyObject *resultobj = 0;
50352 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50353 wxButton *result = 0 ;
50354 void *argp1 = 0 ;
50355 int res1 = 0 ;
50356 PyObject *swig_obj[1] ;
50357
50358 if (!args) SWIG_fail;
50359 swig_obj[0] = args;
50360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50361 if (!SWIG_IsOK(res1)) {
50362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50363 }
50364 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50365 {
50366 PyThreadState* __tstate = wxPyBeginAllowThreads();
50367 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50368 wxPyEndAllowThreads(__tstate);
50369 if (PyErr_Occurred()) SWIG_fail;
50370 }
50371 {
50372 resultobj = wxPyMake_wxObject(result, (bool)0);
50373 }
50374 return resultobj;
50375 fail:
50376 return NULL;
50377 }
50378
50379
50380 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50381 PyObject *resultobj = 0;
50382 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50383 wxButton *result = 0 ;
50384 void *argp1 = 0 ;
50385 int res1 = 0 ;
50386 PyObject *swig_obj[1] ;
50387
50388 if (!args) SWIG_fail;
50389 swig_obj[0] = args;
50390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50391 if (!SWIG_IsOK(res1)) {
50392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50393 }
50394 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50395 {
50396 PyThreadState* __tstate = wxPyBeginAllowThreads();
50397 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50398 wxPyEndAllowThreads(__tstate);
50399 if (PyErr_Occurred()) SWIG_fail;
50400 }
50401 {
50402 resultobj = wxPyMake_wxObject(result, (bool)0);
50403 }
50404 return resultobj;
50405 fail:
50406 return NULL;
50407 }
50408
50409
50410 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50411 PyObject *obj;
50412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50413 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50414 return SWIG_Py_Void();
50415 }
50416
50417 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50418 return SWIG_Python_InitShadowInstance(args);
50419 }
50420
50421 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50422 PyObject *resultobj = 0;
50423 int arg1 = (int) 0 ;
50424 int arg2 = (int) 0 ;
50425 wxGBPosition *result = 0 ;
50426 int val1 ;
50427 int ecode1 = 0 ;
50428 int val2 ;
50429 int ecode2 = 0 ;
50430 PyObject * obj0 = 0 ;
50431 PyObject * obj1 = 0 ;
50432 char * kwnames[] = {
50433 (char *) "row",(char *) "col", NULL
50434 };
50435
50436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50437 if (obj0) {
50438 ecode1 = SWIG_AsVal_int(obj0, &val1);
50439 if (!SWIG_IsOK(ecode1)) {
50440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50441 }
50442 arg1 = static_cast< int >(val1);
50443 }
50444 if (obj1) {
50445 ecode2 = SWIG_AsVal_int(obj1, &val2);
50446 if (!SWIG_IsOK(ecode2)) {
50447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50448 }
50449 arg2 = static_cast< int >(val2);
50450 }
50451 {
50452 PyThreadState* __tstate = wxPyBeginAllowThreads();
50453 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50454 wxPyEndAllowThreads(__tstate);
50455 if (PyErr_Occurred()) SWIG_fail;
50456 }
50457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50458 return resultobj;
50459 fail:
50460 return NULL;
50461 }
50462
50463
50464 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50465 PyObject *resultobj = 0;
50466 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50467 void *argp1 = 0 ;
50468 int res1 = 0 ;
50469 PyObject *swig_obj[1] ;
50470
50471 if (!args) SWIG_fail;
50472 swig_obj[0] = args;
50473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50474 if (!SWIG_IsOK(res1)) {
50475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50476 }
50477 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50478 {
50479 PyThreadState* __tstate = wxPyBeginAllowThreads();
50480 delete arg1;
50481
50482 wxPyEndAllowThreads(__tstate);
50483 if (PyErr_Occurred()) SWIG_fail;
50484 }
50485 resultobj = SWIG_Py_Void();
50486 return resultobj;
50487 fail:
50488 return NULL;
50489 }
50490
50491
50492 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50493 PyObject *resultobj = 0;
50494 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50495 int result;
50496 void *argp1 = 0 ;
50497 int res1 = 0 ;
50498 PyObject *swig_obj[1] ;
50499
50500 if (!args) SWIG_fail;
50501 swig_obj[0] = args;
50502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50503 if (!SWIG_IsOK(res1)) {
50504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50505 }
50506 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50507 {
50508 PyThreadState* __tstate = wxPyBeginAllowThreads();
50509 result = (int)((wxGBPosition const *)arg1)->GetRow();
50510 wxPyEndAllowThreads(__tstate);
50511 if (PyErr_Occurred()) SWIG_fail;
50512 }
50513 resultobj = SWIG_From_int(static_cast< int >(result));
50514 return resultobj;
50515 fail:
50516 return NULL;
50517 }
50518
50519
50520 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50521 PyObject *resultobj = 0;
50522 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50523 int result;
50524 void *argp1 = 0 ;
50525 int res1 = 0 ;
50526 PyObject *swig_obj[1] ;
50527
50528 if (!args) SWIG_fail;
50529 swig_obj[0] = args;
50530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50531 if (!SWIG_IsOK(res1)) {
50532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50533 }
50534 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50535 {
50536 PyThreadState* __tstate = wxPyBeginAllowThreads();
50537 result = (int)((wxGBPosition const *)arg1)->GetCol();
50538 wxPyEndAllowThreads(__tstate);
50539 if (PyErr_Occurred()) SWIG_fail;
50540 }
50541 resultobj = SWIG_From_int(static_cast< int >(result));
50542 return resultobj;
50543 fail:
50544 return NULL;
50545 }
50546
50547
50548 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50549 PyObject *resultobj = 0;
50550 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50551 int arg2 ;
50552 void *argp1 = 0 ;
50553 int res1 = 0 ;
50554 int val2 ;
50555 int ecode2 = 0 ;
50556 PyObject * obj0 = 0 ;
50557 PyObject * obj1 = 0 ;
50558 char * kwnames[] = {
50559 (char *) "self",(char *) "row", NULL
50560 };
50561
50562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50564 if (!SWIG_IsOK(res1)) {
50565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50566 }
50567 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50568 ecode2 = SWIG_AsVal_int(obj1, &val2);
50569 if (!SWIG_IsOK(ecode2)) {
50570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50571 }
50572 arg2 = static_cast< int >(val2);
50573 {
50574 PyThreadState* __tstate = wxPyBeginAllowThreads();
50575 (arg1)->SetRow(arg2);
50576 wxPyEndAllowThreads(__tstate);
50577 if (PyErr_Occurred()) SWIG_fail;
50578 }
50579 resultobj = SWIG_Py_Void();
50580 return resultobj;
50581 fail:
50582 return NULL;
50583 }
50584
50585
50586 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50587 PyObject *resultobj = 0;
50588 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50589 int arg2 ;
50590 void *argp1 = 0 ;
50591 int res1 = 0 ;
50592 int val2 ;
50593 int ecode2 = 0 ;
50594 PyObject * obj0 = 0 ;
50595 PyObject * obj1 = 0 ;
50596 char * kwnames[] = {
50597 (char *) "self",(char *) "col", NULL
50598 };
50599
50600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50604 }
50605 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50606 ecode2 = SWIG_AsVal_int(obj1, &val2);
50607 if (!SWIG_IsOK(ecode2)) {
50608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50609 }
50610 arg2 = static_cast< int >(val2);
50611 {
50612 PyThreadState* __tstate = wxPyBeginAllowThreads();
50613 (arg1)->SetCol(arg2);
50614 wxPyEndAllowThreads(__tstate);
50615 if (PyErr_Occurred()) SWIG_fail;
50616 }
50617 resultobj = SWIG_Py_Void();
50618 return resultobj;
50619 fail:
50620 return NULL;
50621 }
50622
50623
50624 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50625 PyObject *resultobj = 0;
50626 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50627 PyObject *arg2 = (PyObject *) 0 ;
50628 bool result;
50629 void *argp1 = 0 ;
50630 int res1 = 0 ;
50631 PyObject * obj0 = 0 ;
50632 PyObject * obj1 = 0 ;
50633 char * kwnames[] = {
50634 (char *) "self",(char *) "other", NULL
50635 };
50636
50637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50639 if (!SWIG_IsOK(res1)) {
50640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50641 }
50642 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50643 arg2 = obj1;
50644 {
50645 result = (bool)wxGBPosition___eq__(arg1,arg2);
50646 if (PyErr_Occurred()) SWIG_fail;
50647 }
50648 {
50649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50650 }
50651 return resultobj;
50652 fail:
50653 return NULL;
50654 }
50655
50656
50657 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50658 PyObject *resultobj = 0;
50659 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50660 PyObject *arg2 = (PyObject *) 0 ;
50661 bool result;
50662 void *argp1 = 0 ;
50663 int res1 = 0 ;
50664 PyObject * obj0 = 0 ;
50665 PyObject * obj1 = 0 ;
50666 char * kwnames[] = {
50667 (char *) "self",(char *) "other", NULL
50668 };
50669
50670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50672 if (!SWIG_IsOK(res1)) {
50673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50674 }
50675 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50676 arg2 = obj1;
50677 {
50678 result = (bool)wxGBPosition___ne__(arg1,arg2);
50679 if (PyErr_Occurred()) SWIG_fail;
50680 }
50681 {
50682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50683 }
50684 return resultobj;
50685 fail:
50686 return NULL;
50687 }
50688
50689
50690 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50691 PyObject *resultobj = 0;
50692 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50693 int arg2 = (int) 0 ;
50694 int arg3 = (int) 0 ;
50695 void *argp1 = 0 ;
50696 int res1 = 0 ;
50697 int val2 ;
50698 int ecode2 = 0 ;
50699 int val3 ;
50700 int ecode3 = 0 ;
50701 PyObject * obj0 = 0 ;
50702 PyObject * obj1 = 0 ;
50703 PyObject * obj2 = 0 ;
50704 char * kwnames[] = {
50705 (char *) "self",(char *) "row",(char *) "col", NULL
50706 };
50707
50708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50710 if (!SWIG_IsOK(res1)) {
50711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50712 }
50713 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50714 if (obj1) {
50715 ecode2 = SWIG_AsVal_int(obj1, &val2);
50716 if (!SWIG_IsOK(ecode2)) {
50717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50718 }
50719 arg2 = static_cast< int >(val2);
50720 }
50721 if (obj2) {
50722 ecode3 = SWIG_AsVal_int(obj2, &val3);
50723 if (!SWIG_IsOK(ecode3)) {
50724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50725 }
50726 arg3 = static_cast< int >(val3);
50727 }
50728 {
50729 PyThreadState* __tstate = wxPyBeginAllowThreads();
50730 wxGBPosition_Set(arg1,arg2,arg3);
50731 wxPyEndAllowThreads(__tstate);
50732 if (PyErr_Occurred()) SWIG_fail;
50733 }
50734 resultobj = SWIG_Py_Void();
50735 return resultobj;
50736 fail:
50737 return NULL;
50738 }
50739
50740
50741 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50742 PyObject *resultobj = 0;
50743 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50744 PyObject *result = 0 ;
50745 void *argp1 = 0 ;
50746 int res1 = 0 ;
50747 PyObject *swig_obj[1] ;
50748
50749 if (!args) SWIG_fail;
50750 swig_obj[0] = args;
50751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50752 if (!SWIG_IsOK(res1)) {
50753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50754 }
50755 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50756 {
50757 PyThreadState* __tstate = wxPyBeginAllowThreads();
50758 result = (PyObject *)wxGBPosition_Get(arg1);
50759 wxPyEndAllowThreads(__tstate);
50760 if (PyErr_Occurred()) SWIG_fail;
50761 }
50762 resultobj = result;
50763 return resultobj;
50764 fail:
50765 return NULL;
50766 }
50767
50768
50769 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50770 PyObject *obj;
50771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50772 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50773 return SWIG_Py_Void();
50774 }
50775
50776 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50777 return SWIG_Python_InitShadowInstance(args);
50778 }
50779
50780 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50781 PyObject *resultobj = 0;
50782 int arg1 = (int) 1 ;
50783 int arg2 = (int) 1 ;
50784 wxGBSpan *result = 0 ;
50785 int val1 ;
50786 int ecode1 = 0 ;
50787 int val2 ;
50788 int ecode2 = 0 ;
50789 PyObject * obj0 = 0 ;
50790 PyObject * obj1 = 0 ;
50791 char * kwnames[] = {
50792 (char *) "rowspan",(char *) "colspan", NULL
50793 };
50794
50795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50796 if (obj0) {
50797 ecode1 = SWIG_AsVal_int(obj0, &val1);
50798 if (!SWIG_IsOK(ecode1)) {
50799 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50800 }
50801 arg1 = static_cast< int >(val1);
50802 }
50803 if (obj1) {
50804 ecode2 = SWIG_AsVal_int(obj1, &val2);
50805 if (!SWIG_IsOK(ecode2)) {
50806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50807 }
50808 arg2 = static_cast< int >(val2);
50809 }
50810 {
50811 PyThreadState* __tstate = wxPyBeginAllowThreads();
50812 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50813 wxPyEndAllowThreads(__tstate);
50814 if (PyErr_Occurred()) SWIG_fail;
50815 }
50816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50817 return resultobj;
50818 fail:
50819 return NULL;
50820 }
50821
50822
50823 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50824 PyObject *resultobj = 0;
50825 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50826 void *argp1 = 0 ;
50827 int res1 = 0 ;
50828 PyObject *swig_obj[1] ;
50829
50830 if (!args) SWIG_fail;
50831 swig_obj[0] = args;
50832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50833 if (!SWIG_IsOK(res1)) {
50834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50835 }
50836 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50837 {
50838 PyThreadState* __tstate = wxPyBeginAllowThreads();
50839 delete arg1;
50840
50841 wxPyEndAllowThreads(__tstate);
50842 if (PyErr_Occurred()) SWIG_fail;
50843 }
50844 resultobj = SWIG_Py_Void();
50845 return resultobj;
50846 fail:
50847 return NULL;
50848 }
50849
50850
50851 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50852 PyObject *resultobj = 0;
50853 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50854 int result;
50855 void *argp1 = 0 ;
50856 int res1 = 0 ;
50857 PyObject *swig_obj[1] ;
50858
50859 if (!args) SWIG_fail;
50860 swig_obj[0] = args;
50861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50862 if (!SWIG_IsOK(res1)) {
50863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50864 }
50865 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50866 {
50867 PyThreadState* __tstate = wxPyBeginAllowThreads();
50868 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50869 wxPyEndAllowThreads(__tstate);
50870 if (PyErr_Occurred()) SWIG_fail;
50871 }
50872 resultobj = SWIG_From_int(static_cast< int >(result));
50873 return resultobj;
50874 fail:
50875 return NULL;
50876 }
50877
50878
50879 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50880 PyObject *resultobj = 0;
50881 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50882 int result;
50883 void *argp1 = 0 ;
50884 int res1 = 0 ;
50885 PyObject *swig_obj[1] ;
50886
50887 if (!args) SWIG_fail;
50888 swig_obj[0] = args;
50889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50890 if (!SWIG_IsOK(res1)) {
50891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50892 }
50893 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50894 {
50895 PyThreadState* __tstate = wxPyBeginAllowThreads();
50896 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50897 wxPyEndAllowThreads(__tstate);
50898 if (PyErr_Occurred()) SWIG_fail;
50899 }
50900 resultobj = SWIG_From_int(static_cast< int >(result));
50901 return resultobj;
50902 fail:
50903 return NULL;
50904 }
50905
50906
50907 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50908 PyObject *resultobj = 0;
50909 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50910 int arg2 ;
50911 void *argp1 = 0 ;
50912 int res1 = 0 ;
50913 int val2 ;
50914 int ecode2 = 0 ;
50915 PyObject * obj0 = 0 ;
50916 PyObject * obj1 = 0 ;
50917 char * kwnames[] = {
50918 (char *) "self",(char *) "rowspan", NULL
50919 };
50920
50921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50923 if (!SWIG_IsOK(res1)) {
50924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50925 }
50926 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50927 ecode2 = SWIG_AsVal_int(obj1, &val2);
50928 if (!SWIG_IsOK(ecode2)) {
50929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50930 }
50931 arg2 = static_cast< int >(val2);
50932 {
50933 PyThreadState* __tstate = wxPyBeginAllowThreads();
50934 (arg1)->SetRowspan(arg2);
50935 wxPyEndAllowThreads(__tstate);
50936 if (PyErr_Occurred()) SWIG_fail;
50937 }
50938 resultobj = SWIG_Py_Void();
50939 return resultobj;
50940 fail:
50941 return NULL;
50942 }
50943
50944
50945 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50946 PyObject *resultobj = 0;
50947 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50948 int arg2 ;
50949 void *argp1 = 0 ;
50950 int res1 = 0 ;
50951 int val2 ;
50952 int ecode2 = 0 ;
50953 PyObject * obj0 = 0 ;
50954 PyObject * obj1 = 0 ;
50955 char * kwnames[] = {
50956 (char *) "self",(char *) "colspan", NULL
50957 };
50958
50959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50961 if (!SWIG_IsOK(res1)) {
50962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50963 }
50964 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50965 ecode2 = SWIG_AsVal_int(obj1, &val2);
50966 if (!SWIG_IsOK(ecode2)) {
50967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50968 }
50969 arg2 = static_cast< int >(val2);
50970 {
50971 PyThreadState* __tstate = wxPyBeginAllowThreads();
50972 (arg1)->SetColspan(arg2);
50973 wxPyEndAllowThreads(__tstate);
50974 if (PyErr_Occurred()) SWIG_fail;
50975 }
50976 resultobj = SWIG_Py_Void();
50977 return resultobj;
50978 fail:
50979 return NULL;
50980 }
50981
50982
50983 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50984 PyObject *resultobj = 0;
50985 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50986 PyObject *arg2 = (PyObject *) 0 ;
50987 bool result;
50988 void *argp1 = 0 ;
50989 int res1 = 0 ;
50990 PyObject * obj0 = 0 ;
50991 PyObject * obj1 = 0 ;
50992 char * kwnames[] = {
50993 (char *) "self",(char *) "other", NULL
50994 };
50995
50996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50998 if (!SWIG_IsOK(res1)) {
50999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51000 }
51001 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51002 arg2 = obj1;
51003 {
51004 result = (bool)wxGBSpan___eq__(arg1,arg2);
51005 if (PyErr_Occurred()) SWIG_fail;
51006 }
51007 {
51008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51009 }
51010 return resultobj;
51011 fail:
51012 return NULL;
51013 }
51014
51015
51016 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51017 PyObject *resultobj = 0;
51018 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51019 PyObject *arg2 = (PyObject *) 0 ;
51020 bool result;
51021 void *argp1 = 0 ;
51022 int res1 = 0 ;
51023 PyObject * obj0 = 0 ;
51024 PyObject * obj1 = 0 ;
51025 char * kwnames[] = {
51026 (char *) "self",(char *) "other", NULL
51027 };
51028
51029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51031 if (!SWIG_IsOK(res1)) {
51032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51033 }
51034 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51035 arg2 = obj1;
51036 {
51037 result = (bool)wxGBSpan___ne__(arg1,arg2);
51038 if (PyErr_Occurred()) SWIG_fail;
51039 }
51040 {
51041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51042 }
51043 return resultobj;
51044 fail:
51045 return NULL;
51046 }
51047
51048
51049 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51050 PyObject *resultobj = 0;
51051 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51052 int arg2 = (int) 1 ;
51053 int arg3 = (int) 1 ;
51054 void *argp1 = 0 ;
51055 int res1 = 0 ;
51056 int val2 ;
51057 int ecode2 = 0 ;
51058 int val3 ;
51059 int ecode3 = 0 ;
51060 PyObject * obj0 = 0 ;
51061 PyObject * obj1 = 0 ;
51062 PyObject * obj2 = 0 ;
51063 char * kwnames[] = {
51064 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51065 };
51066
51067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51069 if (!SWIG_IsOK(res1)) {
51070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51071 }
51072 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51073 if (obj1) {
51074 ecode2 = SWIG_AsVal_int(obj1, &val2);
51075 if (!SWIG_IsOK(ecode2)) {
51076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51077 }
51078 arg2 = static_cast< int >(val2);
51079 }
51080 if (obj2) {
51081 ecode3 = SWIG_AsVal_int(obj2, &val3);
51082 if (!SWIG_IsOK(ecode3)) {
51083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51084 }
51085 arg3 = static_cast< int >(val3);
51086 }
51087 {
51088 PyThreadState* __tstate = wxPyBeginAllowThreads();
51089 wxGBSpan_Set(arg1,arg2,arg3);
51090 wxPyEndAllowThreads(__tstate);
51091 if (PyErr_Occurred()) SWIG_fail;
51092 }
51093 resultobj = SWIG_Py_Void();
51094 return resultobj;
51095 fail:
51096 return NULL;
51097 }
51098
51099
51100 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51101 PyObject *resultobj = 0;
51102 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51103 PyObject *result = 0 ;
51104 void *argp1 = 0 ;
51105 int res1 = 0 ;
51106 PyObject *swig_obj[1] ;
51107
51108 if (!args) SWIG_fail;
51109 swig_obj[0] = args;
51110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51111 if (!SWIG_IsOK(res1)) {
51112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51113 }
51114 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51115 {
51116 PyThreadState* __tstate = wxPyBeginAllowThreads();
51117 result = (PyObject *)wxGBSpan_Get(arg1);
51118 wxPyEndAllowThreads(__tstate);
51119 if (PyErr_Occurred()) SWIG_fail;
51120 }
51121 resultobj = result;
51122 return resultobj;
51123 fail:
51124 return NULL;
51125 }
51126
51127
51128 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51129 PyObject *obj;
51130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51131 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51132 return SWIG_Py_Void();
51133 }
51134
51135 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51136 return SWIG_Python_InitShadowInstance(args);
51137 }
51138
51139 SWIGINTERN int DefaultSpan_set(PyObject *) {
51140 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51141 return 1;
51142 }
51143
51144
51145 SWIGINTERN PyObject *DefaultSpan_get(void) {
51146 PyObject *pyobj = 0;
51147
51148 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51149 return pyobj;
51150 }
51151
51152
51153 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51154 PyObject *resultobj = 0;
51155 wxGBSizerItem *result = 0 ;
51156
51157 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51158 {
51159 PyThreadState* __tstate = wxPyBeginAllowThreads();
51160 result = (wxGBSizerItem *)new wxGBSizerItem();
51161 wxPyEndAllowThreads(__tstate);
51162 if (PyErr_Occurred()) SWIG_fail;
51163 }
51164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51165 return resultobj;
51166 fail:
51167 return NULL;
51168 }
51169
51170
51171 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51172 PyObject *resultobj = 0;
51173 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51174 void *argp1 = 0 ;
51175 int res1 = 0 ;
51176 PyObject *swig_obj[1] ;
51177
51178 if (!args) SWIG_fail;
51179 swig_obj[0] = args;
51180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51181 if (!SWIG_IsOK(res1)) {
51182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51183 }
51184 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51185 {
51186 PyThreadState* __tstate = wxPyBeginAllowThreads();
51187 delete arg1;
51188
51189 wxPyEndAllowThreads(__tstate);
51190 if (PyErr_Occurred()) SWIG_fail;
51191 }
51192 resultobj = SWIG_Py_Void();
51193 return resultobj;
51194 fail:
51195 return NULL;
51196 }
51197
51198
51199 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51200 PyObject *resultobj = 0;
51201 wxWindow *arg1 = (wxWindow *) 0 ;
51202 wxGBPosition *arg2 = 0 ;
51203 wxGBSpan *arg3 = 0 ;
51204 int arg4 ;
51205 int arg5 ;
51206 PyObject *arg6 = (PyObject *) NULL ;
51207 wxGBSizerItem *result = 0 ;
51208 void *argp1 = 0 ;
51209 int res1 = 0 ;
51210 wxGBPosition temp2 ;
51211 wxGBSpan temp3 ;
51212 int val4 ;
51213 int ecode4 = 0 ;
51214 int val5 ;
51215 int ecode5 = 0 ;
51216 PyObject * obj0 = 0 ;
51217 PyObject * obj1 = 0 ;
51218 PyObject * obj2 = 0 ;
51219 PyObject * obj3 = 0 ;
51220 PyObject * obj4 = 0 ;
51221 PyObject * obj5 = 0 ;
51222 char * kwnames[] = {
51223 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51224 };
51225
51226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51228 if (!SWIG_IsOK(res1)) {
51229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51230 }
51231 arg1 = reinterpret_cast< wxWindow * >(argp1);
51232 {
51233 arg2 = &temp2;
51234 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51235 }
51236 {
51237 arg3 = &temp3;
51238 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51239 }
51240 ecode4 = SWIG_AsVal_int(obj3, &val4);
51241 if (!SWIG_IsOK(ecode4)) {
51242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51243 }
51244 arg4 = static_cast< int >(val4);
51245 ecode5 = SWIG_AsVal_int(obj4, &val5);
51246 if (!SWIG_IsOK(ecode5)) {
51247 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51248 }
51249 arg5 = static_cast< int >(val5);
51250 if (obj5) {
51251 arg6 = obj5;
51252 }
51253 {
51254 PyThreadState* __tstate = wxPyBeginAllowThreads();
51255 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51256 wxPyEndAllowThreads(__tstate);
51257 if (PyErr_Occurred()) SWIG_fail;
51258 }
51259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51260 return resultobj;
51261 fail:
51262 return NULL;
51263 }
51264
51265
51266 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51267 PyObject *resultobj = 0;
51268 wxSizer *arg1 = (wxSizer *) 0 ;
51269 wxGBPosition *arg2 = 0 ;
51270 wxGBSpan *arg3 = 0 ;
51271 int arg4 ;
51272 int arg5 ;
51273 PyObject *arg6 = (PyObject *) NULL ;
51274 wxGBSizerItem *result = 0 ;
51275 int res1 = 0 ;
51276 wxGBPosition temp2 ;
51277 wxGBSpan temp3 ;
51278 int val4 ;
51279 int ecode4 = 0 ;
51280 int val5 ;
51281 int ecode5 = 0 ;
51282 PyObject * obj0 = 0 ;
51283 PyObject * obj1 = 0 ;
51284 PyObject * obj2 = 0 ;
51285 PyObject * obj3 = 0 ;
51286 PyObject * obj4 = 0 ;
51287 PyObject * obj5 = 0 ;
51288 char * kwnames[] = {
51289 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51290 };
51291
51292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51293 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51294 if (!SWIG_IsOK(res1)) {
51295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51296 }
51297 {
51298 arg2 = &temp2;
51299 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51300 }
51301 {
51302 arg3 = &temp3;
51303 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51304 }
51305 ecode4 = SWIG_AsVal_int(obj3, &val4);
51306 if (!SWIG_IsOK(ecode4)) {
51307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51308 }
51309 arg4 = static_cast< int >(val4);
51310 ecode5 = SWIG_AsVal_int(obj4, &val5);
51311 if (!SWIG_IsOK(ecode5)) {
51312 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51313 }
51314 arg5 = static_cast< int >(val5);
51315 if (obj5) {
51316 arg6 = obj5;
51317 }
51318 {
51319 PyThreadState* __tstate = wxPyBeginAllowThreads();
51320 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51321 wxPyEndAllowThreads(__tstate);
51322 if (PyErr_Occurred()) SWIG_fail;
51323 }
51324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51325 return resultobj;
51326 fail:
51327 return NULL;
51328 }
51329
51330
51331 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51332 PyObject *resultobj = 0;
51333 int arg1 ;
51334 int arg2 ;
51335 wxGBPosition *arg3 = 0 ;
51336 wxGBSpan *arg4 = 0 ;
51337 int arg5 ;
51338 int arg6 ;
51339 PyObject *arg7 = (PyObject *) NULL ;
51340 wxGBSizerItem *result = 0 ;
51341 int val1 ;
51342 int ecode1 = 0 ;
51343 int val2 ;
51344 int ecode2 = 0 ;
51345 wxGBPosition temp3 ;
51346 wxGBSpan temp4 ;
51347 int val5 ;
51348 int ecode5 = 0 ;
51349 int val6 ;
51350 int ecode6 = 0 ;
51351 PyObject * obj0 = 0 ;
51352 PyObject * obj1 = 0 ;
51353 PyObject * obj2 = 0 ;
51354 PyObject * obj3 = 0 ;
51355 PyObject * obj4 = 0 ;
51356 PyObject * obj5 = 0 ;
51357 PyObject * obj6 = 0 ;
51358 char * kwnames[] = {
51359 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51360 };
51361
51362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51363 ecode1 = SWIG_AsVal_int(obj0, &val1);
51364 if (!SWIG_IsOK(ecode1)) {
51365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51366 }
51367 arg1 = static_cast< int >(val1);
51368 ecode2 = SWIG_AsVal_int(obj1, &val2);
51369 if (!SWIG_IsOK(ecode2)) {
51370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51371 }
51372 arg2 = static_cast< int >(val2);
51373 {
51374 arg3 = &temp3;
51375 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51376 }
51377 {
51378 arg4 = &temp4;
51379 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51380 }
51381 ecode5 = SWIG_AsVal_int(obj4, &val5);
51382 if (!SWIG_IsOK(ecode5)) {
51383 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51384 }
51385 arg5 = static_cast< int >(val5);
51386 ecode6 = SWIG_AsVal_int(obj5, &val6);
51387 if (!SWIG_IsOK(ecode6)) {
51388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51389 }
51390 arg6 = static_cast< int >(val6);
51391 if (obj6) {
51392 arg7 = obj6;
51393 }
51394 {
51395 PyThreadState* __tstate = wxPyBeginAllowThreads();
51396 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51397 wxPyEndAllowThreads(__tstate);
51398 if (PyErr_Occurred()) SWIG_fail;
51399 }
51400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51401 return resultobj;
51402 fail:
51403 return NULL;
51404 }
51405
51406
51407 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51408 PyObject *resultobj = 0;
51409 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51410 wxGBPosition result;
51411 void *argp1 = 0 ;
51412 int res1 = 0 ;
51413 PyObject *swig_obj[1] ;
51414
51415 if (!args) SWIG_fail;
51416 swig_obj[0] = args;
51417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51418 if (!SWIG_IsOK(res1)) {
51419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51420 }
51421 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51422 {
51423 PyThreadState* __tstate = wxPyBeginAllowThreads();
51424 result = ((wxGBSizerItem const *)arg1)->GetPos();
51425 wxPyEndAllowThreads(__tstate);
51426 if (PyErr_Occurred()) SWIG_fail;
51427 }
51428 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51429 return resultobj;
51430 fail:
51431 return NULL;
51432 }
51433
51434
51435 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51436 PyObject *resultobj = 0;
51437 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51438 wxGBSpan result;
51439 void *argp1 = 0 ;
51440 int res1 = 0 ;
51441 PyObject *swig_obj[1] ;
51442
51443 if (!args) SWIG_fail;
51444 swig_obj[0] = args;
51445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51446 if (!SWIG_IsOK(res1)) {
51447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51448 }
51449 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51450 {
51451 PyThreadState* __tstate = wxPyBeginAllowThreads();
51452 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51453 wxPyEndAllowThreads(__tstate);
51454 if (PyErr_Occurred()) SWIG_fail;
51455 }
51456 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51457 return resultobj;
51458 fail:
51459 return NULL;
51460 }
51461
51462
51463 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51464 PyObject *resultobj = 0;
51465 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51466 wxGBPosition *arg2 = 0 ;
51467 bool result;
51468 void *argp1 = 0 ;
51469 int res1 = 0 ;
51470 wxGBPosition temp2 ;
51471 PyObject * obj0 = 0 ;
51472 PyObject * obj1 = 0 ;
51473 char * kwnames[] = {
51474 (char *) "self",(char *) "pos", NULL
51475 };
51476
51477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51479 if (!SWIG_IsOK(res1)) {
51480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51481 }
51482 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51483 {
51484 arg2 = &temp2;
51485 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51486 }
51487 {
51488 PyThreadState* __tstate = wxPyBeginAllowThreads();
51489 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51490 wxPyEndAllowThreads(__tstate);
51491 if (PyErr_Occurred()) SWIG_fail;
51492 }
51493 {
51494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51495 }
51496 return resultobj;
51497 fail:
51498 return NULL;
51499 }
51500
51501
51502 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51503 PyObject *resultobj = 0;
51504 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51505 wxGBSpan *arg2 = 0 ;
51506 bool result;
51507 void *argp1 = 0 ;
51508 int res1 = 0 ;
51509 wxGBSpan temp2 ;
51510 PyObject * obj0 = 0 ;
51511 PyObject * obj1 = 0 ;
51512 char * kwnames[] = {
51513 (char *) "self",(char *) "span", NULL
51514 };
51515
51516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51518 if (!SWIG_IsOK(res1)) {
51519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51520 }
51521 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51522 {
51523 arg2 = &temp2;
51524 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51525 }
51526 {
51527 PyThreadState* __tstate = wxPyBeginAllowThreads();
51528 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51529 wxPyEndAllowThreads(__tstate);
51530 if (PyErr_Occurred()) SWIG_fail;
51531 }
51532 {
51533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51534 }
51535 return resultobj;
51536 fail:
51537 return NULL;
51538 }
51539
51540
51541 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51542 PyObject *resultobj = 0;
51543 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51544 wxGBSizerItem *arg2 = 0 ;
51545 bool result;
51546 void *argp1 = 0 ;
51547 int res1 = 0 ;
51548 void *argp2 = 0 ;
51549 int res2 = 0 ;
51550 PyObject * obj0 = 0 ;
51551 PyObject * obj1 = 0 ;
51552 char * kwnames[] = {
51553 (char *) "self",(char *) "other", NULL
51554 };
51555
51556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51558 if (!SWIG_IsOK(res1)) {
51559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51560 }
51561 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51563 if (!SWIG_IsOK(res2)) {
51564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51565 }
51566 if (!argp2) {
51567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51568 }
51569 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51570 {
51571 PyThreadState* __tstate = wxPyBeginAllowThreads();
51572 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51573 wxPyEndAllowThreads(__tstate);
51574 if (PyErr_Occurred()) SWIG_fail;
51575 }
51576 {
51577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51578 }
51579 return resultobj;
51580 fail:
51581 return NULL;
51582 }
51583
51584
51585 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51586 PyObject *resultobj = 0;
51587 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51588 wxGBPosition *arg2 = 0 ;
51589 wxGBSpan *arg3 = 0 ;
51590 bool result;
51591 void *argp1 = 0 ;
51592 int res1 = 0 ;
51593 wxGBPosition temp2 ;
51594 wxGBSpan temp3 ;
51595 PyObject * obj0 = 0 ;
51596 PyObject * obj1 = 0 ;
51597 PyObject * obj2 = 0 ;
51598 char * kwnames[] = {
51599 (char *) "self",(char *) "pos",(char *) "span", NULL
51600 };
51601
51602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51604 if (!SWIG_IsOK(res1)) {
51605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51606 }
51607 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51608 {
51609 arg2 = &temp2;
51610 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51611 }
51612 {
51613 arg3 = &temp3;
51614 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51615 }
51616 {
51617 PyThreadState* __tstate = wxPyBeginAllowThreads();
51618 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51619 wxPyEndAllowThreads(__tstate);
51620 if (PyErr_Occurred()) SWIG_fail;
51621 }
51622 {
51623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51624 }
51625 return resultobj;
51626 fail:
51627 return NULL;
51628 }
51629
51630
51631 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51632 PyObject *resultobj = 0;
51633 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51634 wxGBPosition result;
51635 void *argp1 = 0 ;
51636 int res1 = 0 ;
51637 PyObject *swig_obj[1] ;
51638
51639 if (!args) SWIG_fail;
51640 swig_obj[0] = args;
51641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51642 if (!SWIG_IsOK(res1)) {
51643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51644 }
51645 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51646 {
51647 PyThreadState* __tstate = wxPyBeginAllowThreads();
51648 result = wxGBSizerItem_GetEndPos(arg1);
51649 wxPyEndAllowThreads(__tstate);
51650 if (PyErr_Occurred()) SWIG_fail;
51651 }
51652 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51653 return resultobj;
51654 fail:
51655 return NULL;
51656 }
51657
51658
51659 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51660 PyObject *resultobj = 0;
51661 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51662 wxGridBagSizer *result = 0 ;
51663 void *argp1 = 0 ;
51664 int res1 = 0 ;
51665 PyObject *swig_obj[1] ;
51666
51667 if (!args) SWIG_fail;
51668 swig_obj[0] = args;
51669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51670 if (!SWIG_IsOK(res1)) {
51671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51672 }
51673 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51674 {
51675 PyThreadState* __tstate = wxPyBeginAllowThreads();
51676 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51677 wxPyEndAllowThreads(__tstate);
51678 if (PyErr_Occurred()) SWIG_fail;
51679 }
51680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51681 return resultobj;
51682 fail:
51683 return NULL;
51684 }
51685
51686
51687 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51688 PyObject *resultobj = 0;
51689 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51690 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51691 void *argp1 = 0 ;
51692 int res1 = 0 ;
51693 void *argp2 = 0 ;
51694 int res2 = 0 ;
51695 PyObject * obj0 = 0 ;
51696 PyObject * obj1 = 0 ;
51697 char * kwnames[] = {
51698 (char *) "self",(char *) "sizer", NULL
51699 };
51700
51701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51703 if (!SWIG_IsOK(res1)) {
51704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51705 }
51706 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51708 if (!SWIG_IsOK(res2)) {
51709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51710 }
51711 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51712 {
51713 PyThreadState* __tstate = wxPyBeginAllowThreads();
51714 (arg1)->SetGBSizer(arg2);
51715 wxPyEndAllowThreads(__tstate);
51716 if (PyErr_Occurred()) SWIG_fail;
51717 }
51718 resultobj = SWIG_Py_Void();
51719 return resultobj;
51720 fail:
51721 return NULL;
51722 }
51723
51724
51725 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51726 PyObject *obj;
51727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51728 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51729 return SWIG_Py_Void();
51730 }
51731
51732 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51733 return SWIG_Python_InitShadowInstance(args);
51734 }
51735
51736 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51737 PyObject *resultobj = 0;
51738 int arg1 = (int) 0 ;
51739 int arg2 = (int) 0 ;
51740 wxGridBagSizer *result = 0 ;
51741 int val1 ;
51742 int ecode1 = 0 ;
51743 int val2 ;
51744 int ecode2 = 0 ;
51745 PyObject * obj0 = 0 ;
51746 PyObject * obj1 = 0 ;
51747 char * kwnames[] = {
51748 (char *) "vgap",(char *) "hgap", NULL
51749 };
51750
51751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51752 if (obj0) {
51753 ecode1 = SWIG_AsVal_int(obj0, &val1);
51754 if (!SWIG_IsOK(ecode1)) {
51755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51756 }
51757 arg1 = static_cast< int >(val1);
51758 }
51759 if (obj1) {
51760 ecode2 = SWIG_AsVal_int(obj1, &val2);
51761 if (!SWIG_IsOK(ecode2)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51763 }
51764 arg2 = static_cast< int >(val2);
51765 }
51766 {
51767 PyThreadState* __tstate = wxPyBeginAllowThreads();
51768 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51769 wxPyEndAllowThreads(__tstate);
51770 if (PyErr_Occurred()) SWIG_fail;
51771 }
51772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51773 return resultobj;
51774 fail:
51775 return NULL;
51776 }
51777
51778
51779 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51780 PyObject *resultobj = 0;
51781 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51782 PyObject *arg2 = (PyObject *) 0 ;
51783 wxGBPosition *arg3 = 0 ;
51784 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51785 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51786 int arg5 = (int) 0 ;
51787 int arg6 = (int) 0 ;
51788 PyObject *arg7 = (PyObject *) NULL ;
51789 wxGBSizerItem *result = 0 ;
51790 void *argp1 = 0 ;
51791 int res1 = 0 ;
51792 wxGBPosition temp3 ;
51793 wxGBSpan temp4 ;
51794 int val5 ;
51795 int ecode5 = 0 ;
51796 int val6 ;
51797 int ecode6 = 0 ;
51798 PyObject * obj0 = 0 ;
51799 PyObject * obj1 = 0 ;
51800 PyObject * obj2 = 0 ;
51801 PyObject * obj3 = 0 ;
51802 PyObject * obj4 = 0 ;
51803 PyObject * obj5 = 0 ;
51804 PyObject * obj6 = 0 ;
51805 char * kwnames[] = {
51806 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51807 };
51808
51809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51811 if (!SWIG_IsOK(res1)) {
51812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51813 }
51814 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51815 arg2 = obj1;
51816 {
51817 arg3 = &temp3;
51818 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51819 }
51820 if (obj3) {
51821 {
51822 arg4 = &temp4;
51823 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51824 }
51825 }
51826 if (obj4) {
51827 ecode5 = SWIG_AsVal_int(obj4, &val5);
51828 if (!SWIG_IsOK(ecode5)) {
51829 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51830 }
51831 arg5 = static_cast< int >(val5);
51832 }
51833 if (obj5) {
51834 ecode6 = SWIG_AsVal_int(obj5, &val6);
51835 if (!SWIG_IsOK(ecode6)) {
51836 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51837 }
51838 arg6 = static_cast< int >(val6);
51839 }
51840 if (obj6) {
51841 arg7 = obj6;
51842 }
51843 {
51844 PyThreadState* __tstate = wxPyBeginAllowThreads();
51845 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51846 wxPyEndAllowThreads(__tstate);
51847 if (PyErr_Occurred()) SWIG_fail;
51848 }
51849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51850 return resultobj;
51851 fail:
51852 return NULL;
51853 }
51854
51855
51856 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51857 PyObject *resultobj = 0;
51858 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51859 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51860 wxGBSizerItem *result = 0 ;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 int res2 = 0 ;
51864 PyObject * obj0 = 0 ;
51865 PyObject * obj1 = 0 ;
51866 char * kwnames[] = {
51867 (char *) "self",(char *) "item", NULL
51868 };
51869
51870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51872 if (!SWIG_IsOK(res1)) {
51873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51874 }
51875 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51876 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51877 if (!SWIG_IsOK(res2)) {
51878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51879 }
51880 {
51881 PyThreadState* __tstate = wxPyBeginAllowThreads();
51882 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51883 wxPyEndAllowThreads(__tstate);
51884 if (PyErr_Occurred()) SWIG_fail;
51885 }
51886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51887 return resultobj;
51888 fail:
51889 return NULL;
51890 }
51891
51892
51893 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51894 PyObject *resultobj = 0;
51895 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51896 int arg2 ;
51897 int arg3 ;
51898 wxSize result;
51899 void *argp1 = 0 ;
51900 int res1 = 0 ;
51901 int val2 ;
51902 int ecode2 = 0 ;
51903 int val3 ;
51904 int ecode3 = 0 ;
51905 PyObject * obj0 = 0 ;
51906 PyObject * obj1 = 0 ;
51907 PyObject * obj2 = 0 ;
51908 char * kwnames[] = {
51909 (char *) "self",(char *) "row",(char *) "col", NULL
51910 };
51911
51912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51914 if (!SWIG_IsOK(res1)) {
51915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51916 }
51917 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51918 ecode2 = SWIG_AsVal_int(obj1, &val2);
51919 if (!SWIG_IsOK(ecode2)) {
51920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51921 }
51922 arg2 = static_cast< int >(val2);
51923 ecode3 = SWIG_AsVal_int(obj2, &val3);
51924 if (!SWIG_IsOK(ecode3)) {
51925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51926 }
51927 arg3 = static_cast< int >(val3);
51928 {
51929 PyThreadState* __tstate = wxPyBeginAllowThreads();
51930 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51931 wxPyEndAllowThreads(__tstate);
51932 if (PyErr_Occurred()) SWIG_fail;
51933 }
51934 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51935 return resultobj;
51936 fail:
51937 return NULL;
51938 }
51939
51940
51941 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51942 PyObject *resultobj = 0;
51943 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51944 wxSize result;
51945 void *argp1 = 0 ;
51946 int res1 = 0 ;
51947 PyObject *swig_obj[1] ;
51948
51949 if (!args) SWIG_fail;
51950 swig_obj[0] = args;
51951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51952 if (!SWIG_IsOK(res1)) {
51953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51954 }
51955 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51956 {
51957 PyThreadState* __tstate = wxPyBeginAllowThreads();
51958 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51959 wxPyEndAllowThreads(__tstate);
51960 if (PyErr_Occurred()) SWIG_fail;
51961 }
51962 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51963 return resultobj;
51964 fail:
51965 return NULL;
51966 }
51967
51968
51969 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51970 PyObject *resultobj = 0;
51971 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51972 wxSize *arg2 = 0 ;
51973 void *argp1 = 0 ;
51974 int res1 = 0 ;
51975 wxSize temp2 ;
51976 PyObject * obj0 = 0 ;
51977 PyObject * obj1 = 0 ;
51978 char * kwnames[] = {
51979 (char *) "self",(char *) "sz", NULL
51980 };
51981
51982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51984 if (!SWIG_IsOK(res1)) {
51985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51986 }
51987 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51988 {
51989 arg2 = &temp2;
51990 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51991 }
51992 {
51993 PyThreadState* __tstate = wxPyBeginAllowThreads();
51994 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51995 wxPyEndAllowThreads(__tstate);
51996 if (PyErr_Occurred()) SWIG_fail;
51997 }
51998 resultobj = SWIG_Py_Void();
51999 return resultobj;
52000 fail:
52001 return NULL;
52002 }
52003
52004
52005 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52006 PyObject *resultobj = 0;
52007 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52008 wxWindow *arg2 = (wxWindow *) 0 ;
52009 wxGBPosition result;
52010 void *argp1 = 0 ;
52011 int res1 = 0 ;
52012 void *argp2 = 0 ;
52013 int res2 = 0 ;
52014
52015 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52017 if (!SWIG_IsOK(res1)) {
52018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52019 }
52020 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52021 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52022 if (!SWIG_IsOK(res2)) {
52023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52024 }
52025 arg2 = reinterpret_cast< wxWindow * >(argp2);
52026 {
52027 PyThreadState* __tstate = wxPyBeginAllowThreads();
52028 result = (arg1)->GetItemPosition(arg2);
52029 wxPyEndAllowThreads(__tstate);
52030 if (PyErr_Occurred()) SWIG_fail;
52031 }
52032 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52033 return resultobj;
52034 fail:
52035 return NULL;
52036 }
52037
52038
52039 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52040 PyObject *resultobj = 0;
52041 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52042 wxSizer *arg2 = (wxSizer *) 0 ;
52043 wxGBPosition result;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 void *argp2 = 0 ;
52047 int res2 = 0 ;
52048
52049 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52051 if (!SWIG_IsOK(res1)) {
52052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52053 }
52054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52055 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52056 if (!SWIG_IsOK(res2)) {
52057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52058 }
52059 arg2 = reinterpret_cast< wxSizer * >(argp2);
52060 {
52061 PyThreadState* __tstate = wxPyBeginAllowThreads();
52062 result = (arg1)->GetItemPosition(arg2);
52063 wxPyEndAllowThreads(__tstate);
52064 if (PyErr_Occurred()) SWIG_fail;
52065 }
52066 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52067 return resultobj;
52068 fail:
52069 return NULL;
52070 }
52071
52072
52073 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52074 PyObject *resultobj = 0;
52075 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52076 size_t arg2 ;
52077 wxGBPosition result;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 size_t val2 ;
52081 int ecode2 = 0 ;
52082
52083 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52085 if (!SWIG_IsOK(res1)) {
52086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52087 }
52088 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52089 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52090 if (!SWIG_IsOK(ecode2)) {
52091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52092 }
52093 arg2 = static_cast< size_t >(val2);
52094 {
52095 PyThreadState* __tstate = wxPyBeginAllowThreads();
52096 result = (arg1)->GetItemPosition(arg2);
52097 wxPyEndAllowThreads(__tstate);
52098 if (PyErr_Occurred()) SWIG_fail;
52099 }
52100 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52101 return resultobj;
52102 fail:
52103 return NULL;
52104 }
52105
52106
52107 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52108 int argc;
52109 PyObject *argv[3];
52110
52111 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52112 --argc;
52113 if (argc == 2) {
52114 int _v = 0;
52115 {
52116 void *vptr = 0;
52117 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52118 _v = SWIG_CheckState(res);
52119 }
52120 if (!_v) goto check_1;
52121 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52122 }
52123 check_1:
52124
52125 if (argc == 2) {
52126 int _v = 0;
52127 {
52128 void *vptr = 0;
52129 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52130 _v = SWIG_CheckState(res);
52131 }
52132 if (!_v) goto check_2;
52133 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52134 }
52135 check_2:
52136
52137 if (argc == 2) {
52138 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52139 }
52140
52141 fail:
52142 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52143 return NULL;
52144 }
52145
52146
52147 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52148 PyObject *resultobj = 0;
52149 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52150 wxWindow *arg2 = (wxWindow *) 0 ;
52151 wxGBPosition *arg3 = 0 ;
52152 bool result;
52153 void *argp1 = 0 ;
52154 int res1 = 0 ;
52155 void *argp2 = 0 ;
52156 int res2 = 0 ;
52157 wxGBPosition temp3 ;
52158
52159 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52161 if (!SWIG_IsOK(res1)) {
52162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52163 }
52164 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52165 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52166 if (!SWIG_IsOK(res2)) {
52167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52168 }
52169 arg2 = reinterpret_cast< wxWindow * >(argp2);
52170 {
52171 arg3 = &temp3;
52172 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52173 }
52174 {
52175 PyThreadState* __tstate = wxPyBeginAllowThreads();
52176 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52177 wxPyEndAllowThreads(__tstate);
52178 if (PyErr_Occurred()) SWIG_fail;
52179 }
52180 {
52181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52182 }
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52190 PyObject *resultobj = 0;
52191 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52192 wxSizer *arg2 = (wxSizer *) 0 ;
52193 wxGBPosition *arg3 = 0 ;
52194 bool result;
52195 void *argp1 = 0 ;
52196 int res1 = 0 ;
52197 void *argp2 = 0 ;
52198 int res2 = 0 ;
52199 wxGBPosition temp3 ;
52200
52201 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52203 if (!SWIG_IsOK(res1)) {
52204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52205 }
52206 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52208 if (!SWIG_IsOK(res2)) {
52209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52210 }
52211 arg2 = reinterpret_cast< wxSizer * >(argp2);
52212 {
52213 arg3 = &temp3;
52214 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52215 }
52216 {
52217 PyThreadState* __tstate = wxPyBeginAllowThreads();
52218 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52219 wxPyEndAllowThreads(__tstate);
52220 if (PyErr_Occurred()) SWIG_fail;
52221 }
52222 {
52223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52224 }
52225 return resultobj;
52226 fail:
52227 return NULL;
52228 }
52229
52230
52231 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52232 PyObject *resultobj = 0;
52233 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52234 size_t arg2 ;
52235 wxGBPosition *arg3 = 0 ;
52236 bool result;
52237 void *argp1 = 0 ;
52238 int res1 = 0 ;
52239 size_t val2 ;
52240 int ecode2 = 0 ;
52241 wxGBPosition temp3 ;
52242
52243 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52245 if (!SWIG_IsOK(res1)) {
52246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52247 }
52248 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52249 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52250 if (!SWIG_IsOK(ecode2)) {
52251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52252 }
52253 arg2 = static_cast< size_t >(val2);
52254 {
52255 arg3 = &temp3;
52256 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52257 }
52258 {
52259 PyThreadState* __tstate = wxPyBeginAllowThreads();
52260 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52261 wxPyEndAllowThreads(__tstate);
52262 if (PyErr_Occurred()) SWIG_fail;
52263 }
52264 {
52265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52266 }
52267 return resultobj;
52268 fail:
52269 return NULL;
52270 }
52271
52272
52273 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52274 int argc;
52275 PyObject *argv[4];
52276
52277 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52278 --argc;
52279 if (argc == 3) {
52280 int _v = 0;
52281 {
52282 void *vptr = 0;
52283 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52284 _v = SWIG_CheckState(res);
52285 }
52286 if (!_v) goto check_1;
52287 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52288 }
52289 check_1:
52290
52291 if (argc == 3) {
52292 int _v = 0;
52293 {
52294 void *vptr = 0;
52295 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52296 _v = SWIG_CheckState(res);
52297 }
52298 if (!_v) goto check_2;
52299 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52300 }
52301 check_2:
52302
52303 if (argc == 3) {
52304 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52305 }
52306
52307 fail:
52308 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52309 return NULL;
52310 }
52311
52312
52313 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52314 PyObject *resultobj = 0;
52315 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52316 wxWindow *arg2 = (wxWindow *) 0 ;
52317 wxGBSpan result;
52318 void *argp1 = 0 ;
52319 int res1 = 0 ;
52320 void *argp2 = 0 ;
52321 int res2 = 0 ;
52322
52323 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52325 if (!SWIG_IsOK(res1)) {
52326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52327 }
52328 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52329 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52330 if (!SWIG_IsOK(res2)) {
52331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52332 }
52333 arg2 = reinterpret_cast< wxWindow * >(argp2);
52334 {
52335 PyThreadState* __tstate = wxPyBeginAllowThreads();
52336 result = (arg1)->GetItemSpan(arg2);
52337 wxPyEndAllowThreads(__tstate);
52338 if (PyErr_Occurred()) SWIG_fail;
52339 }
52340 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52341 return resultobj;
52342 fail:
52343 return NULL;
52344 }
52345
52346
52347 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52348 PyObject *resultobj = 0;
52349 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52350 wxSizer *arg2 = (wxSizer *) 0 ;
52351 wxGBSpan result;
52352 void *argp1 = 0 ;
52353 int res1 = 0 ;
52354 void *argp2 = 0 ;
52355 int res2 = 0 ;
52356
52357 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52359 if (!SWIG_IsOK(res1)) {
52360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52361 }
52362 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52363 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52364 if (!SWIG_IsOK(res2)) {
52365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52366 }
52367 arg2 = reinterpret_cast< wxSizer * >(argp2);
52368 {
52369 PyThreadState* __tstate = wxPyBeginAllowThreads();
52370 result = (arg1)->GetItemSpan(arg2);
52371 wxPyEndAllowThreads(__tstate);
52372 if (PyErr_Occurred()) SWIG_fail;
52373 }
52374 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52375 return resultobj;
52376 fail:
52377 return NULL;
52378 }
52379
52380
52381 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52382 PyObject *resultobj = 0;
52383 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52384 size_t arg2 ;
52385 wxGBSpan result;
52386 void *argp1 = 0 ;
52387 int res1 = 0 ;
52388 size_t val2 ;
52389 int ecode2 = 0 ;
52390
52391 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52395 }
52396 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52397 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52398 if (!SWIG_IsOK(ecode2)) {
52399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52400 }
52401 arg2 = static_cast< size_t >(val2);
52402 {
52403 PyThreadState* __tstate = wxPyBeginAllowThreads();
52404 result = (arg1)->GetItemSpan(arg2);
52405 wxPyEndAllowThreads(__tstate);
52406 if (PyErr_Occurred()) SWIG_fail;
52407 }
52408 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52409 return resultobj;
52410 fail:
52411 return NULL;
52412 }
52413
52414
52415 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52416 int argc;
52417 PyObject *argv[3];
52418
52419 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52420 --argc;
52421 if (argc == 2) {
52422 int _v = 0;
52423 {
52424 void *vptr = 0;
52425 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52426 _v = SWIG_CheckState(res);
52427 }
52428 if (!_v) goto check_1;
52429 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52430 }
52431 check_1:
52432
52433 if (argc == 2) {
52434 int _v = 0;
52435 {
52436 void *vptr = 0;
52437 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52438 _v = SWIG_CheckState(res);
52439 }
52440 if (!_v) goto check_2;
52441 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52442 }
52443 check_2:
52444
52445 if (argc == 2) {
52446 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52447 }
52448
52449 fail:
52450 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52451 return NULL;
52452 }
52453
52454
52455 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52456 PyObject *resultobj = 0;
52457 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52458 wxWindow *arg2 = (wxWindow *) 0 ;
52459 wxGBSpan *arg3 = 0 ;
52460 bool result;
52461 void *argp1 = 0 ;
52462 int res1 = 0 ;
52463 void *argp2 = 0 ;
52464 int res2 = 0 ;
52465 wxGBSpan temp3 ;
52466
52467 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52469 if (!SWIG_IsOK(res1)) {
52470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52471 }
52472 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52473 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52474 if (!SWIG_IsOK(res2)) {
52475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52476 }
52477 arg2 = reinterpret_cast< wxWindow * >(argp2);
52478 {
52479 arg3 = &temp3;
52480 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52481 }
52482 {
52483 PyThreadState* __tstate = wxPyBeginAllowThreads();
52484 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52485 wxPyEndAllowThreads(__tstate);
52486 if (PyErr_Occurred()) SWIG_fail;
52487 }
52488 {
52489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52490 }
52491 return resultobj;
52492 fail:
52493 return NULL;
52494 }
52495
52496
52497 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52498 PyObject *resultobj = 0;
52499 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52500 wxSizer *arg2 = (wxSizer *) 0 ;
52501 wxGBSpan *arg3 = 0 ;
52502 bool result;
52503 void *argp1 = 0 ;
52504 int res1 = 0 ;
52505 void *argp2 = 0 ;
52506 int res2 = 0 ;
52507 wxGBSpan temp3 ;
52508
52509 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52511 if (!SWIG_IsOK(res1)) {
52512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52513 }
52514 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52515 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52516 if (!SWIG_IsOK(res2)) {
52517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52518 }
52519 arg2 = reinterpret_cast< wxSizer * >(argp2);
52520 {
52521 arg3 = &temp3;
52522 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52523 }
52524 {
52525 PyThreadState* __tstate = wxPyBeginAllowThreads();
52526 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52527 wxPyEndAllowThreads(__tstate);
52528 if (PyErr_Occurred()) SWIG_fail;
52529 }
52530 {
52531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52532 }
52533 return resultobj;
52534 fail:
52535 return NULL;
52536 }
52537
52538
52539 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52540 PyObject *resultobj = 0;
52541 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52542 size_t arg2 ;
52543 wxGBSpan *arg3 = 0 ;
52544 bool result;
52545 void *argp1 = 0 ;
52546 int res1 = 0 ;
52547 size_t val2 ;
52548 int ecode2 = 0 ;
52549 wxGBSpan temp3 ;
52550
52551 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52553 if (!SWIG_IsOK(res1)) {
52554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52555 }
52556 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52557 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52558 if (!SWIG_IsOK(ecode2)) {
52559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52560 }
52561 arg2 = static_cast< size_t >(val2);
52562 {
52563 arg3 = &temp3;
52564 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52565 }
52566 {
52567 PyThreadState* __tstate = wxPyBeginAllowThreads();
52568 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52569 wxPyEndAllowThreads(__tstate);
52570 if (PyErr_Occurred()) SWIG_fail;
52571 }
52572 {
52573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52574 }
52575 return resultobj;
52576 fail:
52577 return NULL;
52578 }
52579
52580
52581 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52582 int argc;
52583 PyObject *argv[4];
52584
52585 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52586 --argc;
52587 if (argc == 3) {
52588 int _v = 0;
52589 {
52590 void *vptr = 0;
52591 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52592 _v = SWIG_CheckState(res);
52593 }
52594 if (!_v) goto check_1;
52595 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52596 }
52597 check_1:
52598
52599 if (argc == 3) {
52600 int _v = 0;
52601 {
52602 void *vptr = 0;
52603 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52604 _v = SWIG_CheckState(res);
52605 }
52606 if (!_v) goto check_2;
52607 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52608 }
52609 check_2:
52610
52611 if (argc == 3) {
52612 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52613 }
52614
52615 fail:
52616 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52617 return NULL;
52618 }
52619
52620
52621 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52622 PyObject *resultobj = 0;
52623 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52624 wxWindow *arg2 = (wxWindow *) 0 ;
52625 wxGBSizerItem *result = 0 ;
52626 void *argp1 = 0 ;
52627 int res1 = 0 ;
52628 void *argp2 = 0 ;
52629 int res2 = 0 ;
52630
52631 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52633 if (!SWIG_IsOK(res1)) {
52634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52635 }
52636 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52637 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52638 if (!SWIG_IsOK(res2)) {
52639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52640 }
52641 arg2 = reinterpret_cast< wxWindow * >(argp2);
52642 {
52643 PyThreadState* __tstate = wxPyBeginAllowThreads();
52644 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52645 wxPyEndAllowThreads(__tstate);
52646 if (PyErr_Occurred()) SWIG_fail;
52647 }
52648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52649 return resultobj;
52650 fail:
52651 return NULL;
52652 }
52653
52654
52655 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52656 PyObject *resultobj = 0;
52657 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52658 wxSizer *arg2 = (wxSizer *) 0 ;
52659 wxGBSizerItem *result = 0 ;
52660 void *argp1 = 0 ;
52661 int res1 = 0 ;
52662 void *argp2 = 0 ;
52663 int res2 = 0 ;
52664
52665 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52667 if (!SWIG_IsOK(res1)) {
52668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52669 }
52670 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52671 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52672 if (!SWIG_IsOK(res2)) {
52673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52674 }
52675 arg2 = reinterpret_cast< wxSizer * >(argp2);
52676 {
52677 PyThreadState* __tstate = wxPyBeginAllowThreads();
52678 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52679 wxPyEndAllowThreads(__tstate);
52680 if (PyErr_Occurred()) SWIG_fail;
52681 }
52682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52683 return resultobj;
52684 fail:
52685 return NULL;
52686 }
52687
52688
52689 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52690 int argc;
52691 PyObject *argv[3];
52692
52693 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52694 --argc;
52695 if (argc == 2) {
52696 int _v = 0;
52697 {
52698 void *vptr = 0;
52699 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52700 _v = SWIG_CheckState(res);
52701 }
52702 if (!_v) goto check_1;
52703 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52704 }
52705 check_1:
52706
52707 if (argc == 2) {
52708 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52709 }
52710
52711 fail:
52712 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52713 return NULL;
52714 }
52715
52716
52717 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52718 PyObject *resultobj = 0;
52719 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52720 wxGBPosition *arg2 = 0 ;
52721 wxGBSizerItem *result = 0 ;
52722 void *argp1 = 0 ;
52723 int res1 = 0 ;
52724 wxGBPosition temp2 ;
52725 PyObject * obj0 = 0 ;
52726 PyObject * obj1 = 0 ;
52727 char * kwnames[] = {
52728 (char *) "self",(char *) "pos", NULL
52729 };
52730
52731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52733 if (!SWIG_IsOK(res1)) {
52734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52735 }
52736 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52737 {
52738 arg2 = &temp2;
52739 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52740 }
52741 {
52742 PyThreadState* __tstate = wxPyBeginAllowThreads();
52743 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52744 wxPyEndAllowThreads(__tstate);
52745 if (PyErr_Occurred()) SWIG_fail;
52746 }
52747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52748 return resultobj;
52749 fail:
52750 return NULL;
52751 }
52752
52753
52754 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52755 PyObject *resultobj = 0;
52756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52757 wxPoint *arg2 = 0 ;
52758 wxGBSizerItem *result = 0 ;
52759 void *argp1 = 0 ;
52760 int res1 = 0 ;
52761 wxPoint temp2 ;
52762 PyObject * obj0 = 0 ;
52763 PyObject * obj1 = 0 ;
52764 char * kwnames[] = {
52765 (char *) "self",(char *) "pt", NULL
52766 };
52767
52768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52770 if (!SWIG_IsOK(res1)) {
52771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52772 }
52773 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52774 {
52775 arg2 = &temp2;
52776 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52777 }
52778 {
52779 PyThreadState* __tstate = wxPyBeginAllowThreads();
52780 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52781 wxPyEndAllowThreads(__tstate);
52782 if (PyErr_Occurred()) SWIG_fail;
52783 }
52784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52785 return resultobj;
52786 fail:
52787 return NULL;
52788 }
52789
52790
52791 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52792 PyObject *resultobj = 0;
52793 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52794 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52795 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52796 bool result;
52797 void *argp1 = 0 ;
52798 int res1 = 0 ;
52799 void *argp2 = 0 ;
52800 int res2 = 0 ;
52801 void *argp3 = 0 ;
52802 int res3 = 0 ;
52803 PyObject * obj0 = 0 ;
52804 PyObject * obj1 = 0 ;
52805 PyObject * obj2 = 0 ;
52806 char * kwnames[] = {
52807 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52808 };
52809
52810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52812 if (!SWIG_IsOK(res1)) {
52813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52814 }
52815 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52817 if (!SWIG_IsOK(res2)) {
52818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52819 }
52820 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52821 if (obj2) {
52822 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52823 if (!SWIG_IsOK(res3)) {
52824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52825 }
52826 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52827 }
52828 {
52829 PyThreadState* __tstate = wxPyBeginAllowThreads();
52830 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52831 wxPyEndAllowThreads(__tstate);
52832 if (PyErr_Occurred()) SWIG_fail;
52833 }
52834 {
52835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52836 }
52837 return resultobj;
52838 fail:
52839 return NULL;
52840 }
52841
52842
52843 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52844 PyObject *resultobj = 0;
52845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52846 wxGBPosition *arg2 = 0 ;
52847 wxGBSpan *arg3 = 0 ;
52848 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52849 bool result;
52850 void *argp1 = 0 ;
52851 int res1 = 0 ;
52852 wxGBPosition temp2 ;
52853 wxGBSpan temp3 ;
52854 void *argp4 = 0 ;
52855 int res4 = 0 ;
52856 PyObject * obj0 = 0 ;
52857 PyObject * obj1 = 0 ;
52858 PyObject * obj2 = 0 ;
52859 PyObject * obj3 = 0 ;
52860 char * kwnames[] = {
52861 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52862 };
52863
52864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52866 if (!SWIG_IsOK(res1)) {
52867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52868 }
52869 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52870 {
52871 arg2 = &temp2;
52872 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52873 }
52874 {
52875 arg3 = &temp3;
52876 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52877 }
52878 if (obj3) {
52879 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52880 if (!SWIG_IsOK(res4)) {
52881 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52882 }
52883 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52884 }
52885 {
52886 PyThreadState* __tstate = wxPyBeginAllowThreads();
52887 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52888 wxPyEndAllowThreads(__tstate);
52889 if (PyErr_Occurred()) SWIG_fail;
52890 }
52891 {
52892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52893 }
52894 return resultobj;
52895 fail:
52896 return NULL;
52897 }
52898
52899
52900 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52901 PyObject *obj;
52902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52903 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52904 return SWIG_Py_Void();
52905 }
52906
52907 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52908 return SWIG_Python_InitShadowInstance(args);
52909 }
52910
52911 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52912 PyObject *resultobj = 0;
52913 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52914 wxRelationship arg2 ;
52915 wxWindow *arg3 = (wxWindow *) 0 ;
52916 wxEdge arg4 ;
52917 int arg5 = (int) 0 ;
52918 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52919 void *argp1 = 0 ;
52920 int res1 = 0 ;
52921 int val2 ;
52922 int ecode2 = 0 ;
52923 void *argp3 = 0 ;
52924 int res3 = 0 ;
52925 int val4 ;
52926 int ecode4 = 0 ;
52927 int val5 ;
52928 int ecode5 = 0 ;
52929 int val6 ;
52930 int ecode6 = 0 ;
52931 PyObject * obj0 = 0 ;
52932 PyObject * obj1 = 0 ;
52933 PyObject * obj2 = 0 ;
52934 PyObject * obj3 = 0 ;
52935 PyObject * obj4 = 0 ;
52936 PyObject * obj5 = 0 ;
52937 char * kwnames[] = {
52938 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52939 };
52940
52941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52943 if (!SWIG_IsOK(res1)) {
52944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52945 }
52946 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52947 ecode2 = SWIG_AsVal_int(obj1, &val2);
52948 if (!SWIG_IsOK(ecode2)) {
52949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52950 }
52951 arg2 = static_cast< wxRelationship >(val2);
52952 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52953 if (!SWIG_IsOK(res3)) {
52954 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52955 }
52956 arg3 = reinterpret_cast< wxWindow * >(argp3);
52957 ecode4 = SWIG_AsVal_int(obj3, &val4);
52958 if (!SWIG_IsOK(ecode4)) {
52959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52960 }
52961 arg4 = static_cast< wxEdge >(val4);
52962 if (obj4) {
52963 ecode5 = SWIG_AsVal_int(obj4, &val5);
52964 if (!SWIG_IsOK(ecode5)) {
52965 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52966 }
52967 arg5 = static_cast< int >(val5);
52968 }
52969 if (obj5) {
52970 ecode6 = SWIG_AsVal_int(obj5, &val6);
52971 if (!SWIG_IsOK(ecode6)) {
52972 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52973 }
52974 arg6 = static_cast< int >(val6);
52975 }
52976 {
52977 PyThreadState* __tstate = wxPyBeginAllowThreads();
52978 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52979 wxPyEndAllowThreads(__tstate);
52980 if (PyErr_Occurred()) SWIG_fail;
52981 }
52982 resultobj = SWIG_Py_Void();
52983 return resultobj;
52984 fail:
52985 return NULL;
52986 }
52987
52988
52989 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52990 PyObject *resultobj = 0;
52991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52992 wxWindow *arg2 = (wxWindow *) 0 ;
52993 int arg3 = (int) 0 ;
52994 void *argp1 = 0 ;
52995 int res1 = 0 ;
52996 void *argp2 = 0 ;
52997 int res2 = 0 ;
52998 int val3 ;
52999 int ecode3 = 0 ;
53000 PyObject * obj0 = 0 ;
53001 PyObject * obj1 = 0 ;
53002 PyObject * obj2 = 0 ;
53003 char * kwnames[] = {
53004 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53005 };
53006
53007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53009 if (!SWIG_IsOK(res1)) {
53010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53011 }
53012 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53014 if (!SWIG_IsOK(res2)) {
53015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53016 }
53017 arg2 = reinterpret_cast< wxWindow * >(argp2);
53018 if (obj2) {
53019 ecode3 = SWIG_AsVal_int(obj2, &val3);
53020 if (!SWIG_IsOK(ecode3)) {
53021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53022 }
53023 arg3 = static_cast< int >(val3);
53024 }
53025 {
53026 PyThreadState* __tstate = wxPyBeginAllowThreads();
53027 (arg1)->LeftOf(arg2,arg3);
53028 wxPyEndAllowThreads(__tstate);
53029 if (PyErr_Occurred()) SWIG_fail;
53030 }
53031 resultobj = SWIG_Py_Void();
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53039 PyObject *resultobj = 0;
53040 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53041 wxWindow *arg2 = (wxWindow *) 0 ;
53042 int arg3 = (int) 0 ;
53043 void *argp1 = 0 ;
53044 int res1 = 0 ;
53045 void *argp2 = 0 ;
53046 int res2 = 0 ;
53047 int val3 ;
53048 int ecode3 = 0 ;
53049 PyObject * obj0 = 0 ;
53050 PyObject * obj1 = 0 ;
53051 PyObject * obj2 = 0 ;
53052 char * kwnames[] = {
53053 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53054 };
53055
53056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53058 if (!SWIG_IsOK(res1)) {
53059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53060 }
53061 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53063 if (!SWIG_IsOK(res2)) {
53064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53065 }
53066 arg2 = reinterpret_cast< wxWindow * >(argp2);
53067 if (obj2) {
53068 ecode3 = SWIG_AsVal_int(obj2, &val3);
53069 if (!SWIG_IsOK(ecode3)) {
53070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53071 }
53072 arg3 = static_cast< int >(val3);
53073 }
53074 {
53075 PyThreadState* __tstate = wxPyBeginAllowThreads();
53076 (arg1)->RightOf(arg2,arg3);
53077 wxPyEndAllowThreads(__tstate);
53078 if (PyErr_Occurred()) SWIG_fail;
53079 }
53080 resultobj = SWIG_Py_Void();
53081 return resultobj;
53082 fail:
53083 return NULL;
53084 }
53085
53086
53087 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53088 PyObject *resultobj = 0;
53089 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53090 wxWindow *arg2 = (wxWindow *) 0 ;
53091 int arg3 = (int) 0 ;
53092 void *argp1 = 0 ;
53093 int res1 = 0 ;
53094 void *argp2 = 0 ;
53095 int res2 = 0 ;
53096 int val3 ;
53097 int ecode3 = 0 ;
53098 PyObject * obj0 = 0 ;
53099 PyObject * obj1 = 0 ;
53100 PyObject * obj2 = 0 ;
53101 char * kwnames[] = {
53102 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53103 };
53104
53105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53107 if (!SWIG_IsOK(res1)) {
53108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53109 }
53110 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53112 if (!SWIG_IsOK(res2)) {
53113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53114 }
53115 arg2 = reinterpret_cast< wxWindow * >(argp2);
53116 if (obj2) {
53117 ecode3 = SWIG_AsVal_int(obj2, &val3);
53118 if (!SWIG_IsOK(ecode3)) {
53119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53120 }
53121 arg3 = static_cast< int >(val3);
53122 }
53123 {
53124 PyThreadState* __tstate = wxPyBeginAllowThreads();
53125 (arg1)->Above(arg2,arg3);
53126 wxPyEndAllowThreads(__tstate);
53127 if (PyErr_Occurred()) SWIG_fail;
53128 }
53129 resultobj = SWIG_Py_Void();
53130 return resultobj;
53131 fail:
53132 return NULL;
53133 }
53134
53135
53136 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53137 PyObject *resultobj = 0;
53138 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53139 wxWindow *arg2 = (wxWindow *) 0 ;
53140 int arg3 = (int) 0 ;
53141 void *argp1 = 0 ;
53142 int res1 = 0 ;
53143 void *argp2 = 0 ;
53144 int res2 = 0 ;
53145 int val3 ;
53146 int ecode3 = 0 ;
53147 PyObject * obj0 = 0 ;
53148 PyObject * obj1 = 0 ;
53149 PyObject * obj2 = 0 ;
53150 char * kwnames[] = {
53151 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53152 };
53153
53154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53156 if (!SWIG_IsOK(res1)) {
53157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53158 }
53159 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53161 if (!SWIG_IsOK(res2)) {
53162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53163 }
53164 arg2 = reinterpret_cast< wxWindow * >(argp2);
53165 if (obj2) {
53166 ecode3 = SWIG_AsVal_int(obj2, &val3);
53167 if (!SWIG_IsOK(ecode3)) {
53168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53169 }
53170 arg3 = static_cast< int >(val3);
53171 }
53172 {
53173 PyThreadState* __tstate = wxPyBeginAllowThreads();
53174 (arg1)->Below(arg2,arg3);
53175 wxPyEndAllowThreads(__tstate);
53176 if (PyErr_Occurred()) SWIG_fail;
53177 }
53178 resultobj = SWIG_Py_Void();
53179 return resultobj;
53180 fail:
53181 return NULL;
53182 }
53183
53184
53185 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53186 PyObject *resultobj = 0;
53187 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53188 wxWindow *arg2 = (wxWindow *) 0 ;
53189 wxEdge arg3 ;
53190 int arg4 = (int) 0 ;
53191 void *argp1 = 0 ;
53192 int res1 = 0 ;
53193 void *argp2 = 0 ;
53194 int res2 = 0 ;
53195 int val3 ;
53196 int ecode3 = 0 ;
53197 int val4 ;
53198 int ecode4 = 0 ;
53199 PyObject * obj0 = 0 ;
53200 PyObject * obj1 = 0 ;
53201 PyObject * obj2 = 0 ;
53202 PyObject * obj3 = 0 ;
53203 char * kwnames[] = {
53204 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53205 };
53206
53207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53209 if (!SWIG_IsOK(res1)) {
53210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53211 }
53212 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53214 if (!SWIG_IsOK(res2)) {
53215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53216 }
53217 arg2 = reinterpret_cast< wxWindow * >(argp2);
53218 ecode3 = SWIG_AsVal_int(obj2, &val3);
53219 if (!SWIG_IsOK(ecode3)) {
53220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53221 }
53222 arg3 = static_cast< wxEdge >(val3);
53223 if (obj3) {
53224 ecode4 = SWIG_AsVal_int(obj3, &val4);
53225 if (!SWIG_IsOK(ecode4)) {
53226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53227 }
53228 arg4 = static_cast< int >(val4);
53229 }
53230 {
53231 PyThreadState* __tstate = wxPyBeginAllowThreads();
53232 (arg1)->SameAs(arg2,arg3,arg4);
53233 wxPyEndAllowThreads(__tstate);
53234 if (PyErr_Occurred()) SWIG_fail;
53235 }
53236 resultobj = SWIG_Py_Void();
53237 return resultobj;
53238 fail:
53239 return NULL;
53240 }
53241
53242
53243 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53244 PyObject *resultobj = 0;
53245 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53246 wxWindow *arg2 = (wxWindow *) 0 ;
53247 wxEdge arg3 ;
53248 int arg4 ;
53249 void *argp1 = 0 ;
53250 int res1 = 0 ;
53251 void *argp2 = 0 ;
53252 int res2 = 0 ;
53253 int val3 ;
53254 int ecode3 = 0 ;
53255 int val4 ;
53256 int ecode4 = 0 ;
53257 PyObject * obj0 = 0 ;
53258 PyObject * obj1 = 0 ;
53259 PyObject * obj2 = 0 ;
53260 PyObject * obj3 = 0 ;
53261 char * kwnames[] = {
53262 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53263 };
53264
53265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53267 if (!SWIG_IsOK(res1)) {
53268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53269 }
53270 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53272 if (!SWIG_IsOK(res2)) {
53273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53274 }
53275 arg2 = reinterpret_cast< wxWindow * >(argp2);
53276 ecode3 = SWIG_AsVal_int(obj2, &val3);
53277 if (!SWIG_IsOK(ecode3)) {
53278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53279 }
53280 arg3 = static_cast< wxEdge >(val3);
53281 ecode4 = SWIG_AsVal_int(obj3, &val4);
53282 if (!SWIG_IsOK(ecode4)) {
53283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53284 }
53285 arg4 = static_cast< int >(val4);
53286 {
53287 PyThreadState* __tstate = wxPyBeginAllowThreads();
53288 (arg1)->PercentOf(arg2,arg3,arg4);
53289 wxPyEndAllowThreads(__tstate);
53290 if (PyErr_Occurred()) SWIG_fail;
53291 }
53292 resultobj = SWIG_Py_Void();
53293 return resultobj;
53294 fail:
53295 return NULL;
53296 }
53297
53298
53299 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53300 PyObject *resultobj = 0;
53301 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53302 int arg2 ;
53303 void *argp1 = 0 ;
53304 int res1 = 0 ;
53305 int val2 ;
53306 int ecode2 = 0 ;
53307 PyObject * obj0 = 0 ;
53308 PyObject * obj1 = 0 ;
53309 char * kwnames[] = {
53310 (char *) "self",(char *) "val", NULL
53311 };
53312
53313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53315 if (!SWIG_IsOK(res1)) {
53316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53317 }
53318 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53319 ecode2 = SWIG_AsVal_int(obj1, &val2);
53320 if (!SWIG_IsOK(ecode2)) {
53321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53322 }
53323 arg2 = static_cast< int >(val2);
53324 {
53325 PyThreadState* __tstate = wxPyBeginAllowThreads();
53326 (arg1)->Absolute(arg2);
53327 wxPyEndAllowThreads(__tstate);
53328 if (PyErr_Occurred()) SWIG_fail;
53329 }
53330 resultobj = SWIG_Py_Void();
53331 return resultobj;
53332 fail:
53333 return NULL;
53334 }
53335
53336
53337 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53338 PyObject *resultobj = 0;
53339 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53340 void *argp1 = 0 ;
53341 int res1 = 0 ;
53342 PyObject *swig_obj[1] ;
53343
53344 if (!args) SWIG_fail;
53345 swig_obj[0] = args;
53346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53347 if (!SWIG_IsOK(res1)) {
53348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53349 }
53350 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53351 {
53352 PyThreadState* __tstate = wxPyBeginAllowThreads();
53353 (arg1)->Unconstrained();
53354 wxPyEndAllowThreads(__tstate);
53355 if (PyErr_Occurred()) SWIG_fail;
53356 }
53357 resultobj = SWIG_Py_Void();
53358 return resultobj;
53359 fail:
53360 return NULL;
53361 }
53362
53363
53364 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53365 PyObject *resultobj = 0;
53366 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53367 void *argp1 = 0 ;
53368 int res1 = 0 ;
53369 PyObject *swig_obj[1] ;
53370
53371 if (!args) SWIG_fail;
53372 swig_obj[0] = args;
53373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53374 if (!SWIG_IsOK(res1)) {
53375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53376 }
53377 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53378 {
53379 PyThreadState* __tstate = wxPyBeginAllowThreads();
53380 (arg1)->AsIs();
53381 wxPyEndAllowThreads(__tstate);
53382 if (PyErr_Occurred()) SWIG_fail;
53383 }
53384 resultobj = SWIG_Py_Void();
53385 return resultobj;
53386 fail:
53387 return NULL;
53388 }
53389
53390
53391 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53392 PyObject *resultobj = 0;
53393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53394 wxWindow *result = 0 ;
53395 void *argp1 = 0 ;
53396 int res1 = 0 ;
53397 PyObject *swig_obj[1] ;
53398
53399 if (!args) SWIG_fail;
53400 swig_obj[0] = args;
53401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53402 if (!SWIG_IsOK(res1)) {
53403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53404 }
53405 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53406 {
53407 PyThreadState* __tstate = wxPyBeginAllowThreads();
53408 result = (wxWindow *)(arg1)->GetOtherWindow();
53409 wxPyEndAllowThreads(__tstate);
53410 if (PyErr_Occurred()) SWIG_fail;
53411 }
53412 {
53413 resultobj = wxPyMake_wxObject(result, 0);
53414 }
53415 return resultobj;
53416 fail:
53417 return NULL;
53418 }
53419
53420
53421 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53422 PyObject *resultobj = 0;
53423 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53424 wxEdge result;
53425 void *argp1 = 0 ;
53426 int res1 = 0 ;
53427 PyObject *swig_obj[1] ;
53428
53429 if (!args) SWIG_fail;
53430 swig_obj[0] = args;
53431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53432 if (!SWIG_IsOK(res1)) {
53433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53434 }
53435 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53436 {
53437 PyThreadState* __tstate = wxPyBeginAllowThreads();
53438 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53439 wxPyEndAllowThreads(__tstate);
53440 if (PyErr_Occurred()) SWIG_fail;
53441 }
53442 resultobj = SWIG_From_int(static_cast< int >(result));
53443 return resultobj;
53444 fail:
53445 return NULL;
53446 }
53447
53448
53449 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53450 PyObject *resultobj = 0;
53451 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53452 wxEdge arg2 ;
53453 void *argp1 = 0 ;
53454 int res1 = 0 ;
53455 int val2 ;
53456 int ecode2 = 0 ;
53457 PyObject * obj0 = 0 ;
53458 PyObject * obj1 = 0 ;
53459 char * kwnames[] = {
53460 (char *) "self",(char *) "which", NULL
53461 };
53462
53463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53465 if (!SWIG_IsOK(res1)) {
53466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53467 }
53468 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53469 ecode2 = SWIG_AsVal_int(obj1, &val2);
53470 if (!SWIG_IsOK(ecode2)) {
53471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53472 }
53473 arg2 = static_cast< wxEdge >(val2);
53474 {
53475 PyThreadState* __tstate = wxPyBeginAllowThreads();
53476 (arg1)->SetEdge(arg2);
53477 wxPyEndAllowThreads(__tstate);
53478 if (PyErr_Occurred()) SWIG_fail;
53479 }
53480 resultobj = SWIG_Py_Void();
53481 return resultobj;
53482 fail:
53483 return NULL;
53484 }
53485
53486
53487 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53488 PyObject *resultobj = 0;
53489 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53490 int arg2 ;
53491 void *argp1 = 0 ;
53492 int res1 = 0 ;
53493 int val2 ;
53494 int ecode2 = 0 ;
53495 PyObject * obj0 = 0 ;
53496 PyObject * obj1 = 0 ;
53497 char * kwnames[] = {
53498 (char *) "self",(char *) "v", NULL
53499 };
53500
53501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53503 if (!SWIG_IsOK(res1)) {
53504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53505 }
53506 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53507 ecode2 = SWIG_AsVal_int(obj1, &val2);
53508 if (!SWIG_IsOK(ecode2)) {
53509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53510 }
53511 arg2 = static_cast< int >(val2);
53512 {
53513 PyThreadState* __tstate = wxPyBeginAllowThreads();
53514 (arg1)->SetValue(arg2);
53515 wxPyEndAllowThreads(__tstate);
53516 if (PyErr_Occurred()) SWIG_fail;
53517 }
53518 resultobj = SWIG_Py_Void();
53519 return resultobj;
53520 fail:
53521 return NULL;
53522 }
53523
53524
53525 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53526 PyObject *resultobj = 0;
53527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53528 int result;
53529 void *argp1 = 0 ;
53530 int res1 = 0 ;
53531 PyObject *swig_obj[1] ;
53532
53533 if (!args) SWIG_fail;
53534 swig_obj[0] = args;
53535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53536 if (!SWIG_IsOK(res1)) {
53537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53538 }
53539 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53540 {
53541 PyThreadState* __tstate = wxPyBeginAllowThreads();
53542 result = (int)(arg1)->GetMargin();
53543 wxPyEndAllowThreads(__tstate);
53544 if (PyErr_Occurred()) SWIG_fail;
53545 }
53546 resultobj = SWIG_From_int(static_cast< int >(result));
53547 return resultobj;
53548 fail:
53549 return NULL;
53550 }
53551
53552
53553 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53554 PyObject *resultobj = 0;
53555 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53556 int arg2 ;
53557 void *argp1 = 0 ;
53558 int res1 = 0 ;
53559 int val2 ;
53560 int ecode2 = 0 ;
53561 PyObject * obj0 = 0 ;
53562 PyObject * obj1 = 0 ;
53563 char * kwnames[] = {
53564 (char *) "self",(char *) "m", NULL
53565 };
53566
53567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53569 if (!SWIG_IsOK(res1)) {
53570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53571 }
53572 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53573 ecode2 = SWIG_AsVal_int(obj1, &val2);
53574 if (!SWIG_IsOK(ecode2)) {
53575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53576 }
53577 arg2 = static_cast< int >(val2);
53578 {
53579 PyThreadState* __tstate = wxPyBeginAllowThreads();
53580 (arg1)->SetMargin(arg2);
53581 wxPyEndAllowThreads(__tstate);
53582 if (PyErr_Occurred()) SWIG_fail;
53583 }
53584 resultobj = SWIG_Py_Void();
53585 return resultobj;
53586 fail:
53587 return NULL;
53588 }
53589
53590
53591 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53592 PyObject *resultobj = 0;
53593 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53594 int result;
53595 void *argp1 = 0 ;
53596 int res1 = 0 ;
53597 PyObject *swig_obj[1] ;
53598
53599 if (!args) SWIG_fail;
53600 swig_obj[0] = args;
53601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53602 if (!SWIG_IsOK(res1)) {
53603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53604 }
53605 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53606 {
53607 PyThreadState* __tstate = wxPyBeginAllowThreads();
53608 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53609 wxPyEndAllowThreads(__tstate);
53610 if (PyErr_Occurred()) SWIG_fail;
53611 }
53612 resultobj = SWIG_From_int(static_cast< int >(result));
53613 return resultobj;
53614 fail:
53615 return NULL;
53616 }
53617
53618
53619 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53620 PyObject *resultobj = 0;
53621 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53622 int result;
53623 void *argp1 = 0 ;
53624 int res1 = 0 ;
53625 PyObject *swig_obj[1] ;
53626
53627 if (!args) SWIG_fail;
53628 swig_obj[0] = args;
53629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53630 if (!SWIG_IsOK(res1)) {
53631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53632 }
53633 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53634 {
53635 PyThreadState* __tstate = wxPyBeginAllowThreads();
53636 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53637 wxPyEndAllowThreads(__tstate);
53638 if (PyErr_Occurred()) SWIG_fail;
53639 }
53640 resultobj = SWIG_From_int(static_cast< int >(result));
53641 return resultobj;
53642 fail:
53643 return NULL;
53644 }
53645
53646
53647 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53648 PyObject *resultobj = 0;
53649 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53650 int result;
53651 void *argp1 = 0 ;
53652 int res1 = 0 ;
53653 PyObject *swig_obj[1] ;
53654
53655 if (!args) SWIG_fail;
53656 swig_obj[0] = args;
53657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53658 if (!SWIG_IsOK(res1)) {
53659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53660 }
53661 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53662 {
53663 PyThreadState* __tstate = wxPyBeginAllowThreads();
53664 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53665 wxPyEndAllowThreads(__tstate);
53666 if (PyErr_Occurred()) SWIG_fail;
53667 }
53668 resultobj = SWIG_From_int(static_cast< int >(result));
53669 return resultobj;
53670 fail:
53671 return NULL;
53672 }
53673
53674
53675 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53676 PyObject *resultobj = 0;
53677 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53678 bool result;
53679 void *argp1 = 0 ;
53680 int res1 = 0 ;
53681 PyObject *swig_obj[1] ;
53682
53683 if (!args) SWIG_fail;
53684 swig_obj[0] = args;
53685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53686 if (!SWIG_IsOK(res1)) {
53687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53688 }
53689 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53690 {
53691 PyThreadState* __tstate = wxPyBeginAllowThreads();
53692 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53693 wxPyEndAllowThreads(__tstate);
53694 if (PyErr_Occurred()) SWIG_fail;
53695 }
53696 {
53697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53698 }
53699 return resultobj;
53700 fail:
53701 return NULL;
53702 }
53703
53704
53705 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53706 PyObject *resultobj = 0;
53707 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53708 bool arg2 ;
53709 void *argp1 = 0 ;
53710 int res1 = 0 ;
53711 bool val2 ;
53712 int ecode2 = 0 ;
53713 PyObject * obj0 = 0 ;
53714 PyObject * obj1 = 0 ;
53715 char * kwnames[] = {
53716 (char *) "self",(char *) "d", NULL
53717 };
53718
53719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53721 if (!SWIG_IsOK(res1)) {
53722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53723 }
53724 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53725 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53726 if (!SWIG_IsOK(ecode2)) {
53727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53728 }
53729 arg2 = static_cast< bool >(val2);
53730 {
53731 PyThreadState* __tstate = wxPyBeginAllowThreads();
53732 (arg1)->SetDone(arg2);
53733 wxPyEndAllowThreads(__tstate);
53734 if (PyErr_Occurred()) SWIG_fail;
53735 }
53736 resultobj = SWIG_Py_Void();
53737 return resultobj;
53738 fail:
53739 return NULL;
53740 }
53741
53742
53743 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53744 PyObject *resultobj = 0;
53745 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53746 wxRelationship result;
53747 void *argp1 = 0 ;
53748 int res1 = 0 ;
53749 PyObject *swig_obj[1] ;
53750
53751 if (!args) SWIG_fail;
53752 swig_obj[0] = args;
53753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53754 if (!SWIG_IsOK(res1)) {
53755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53756 }
53757 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53758 {
53759 PyThreadState* __tstate = wxPyBeginAllowThreads();
53760 result = (wxRelationship)(arg1)->GetRelationship();
53761 wxPyEndAllowThreads(__tstate);
53762 if (PyErr_Occurred()) SWIG_fail;
53763 }
53764 resultobj = SWIG_From_int(static_cast< int >(result));
53765 return resultobj;
53766 fail:
53767 return NULL;
53768 }
53769
53770
53771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53772 PyObject *resultobj = 0;
53773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53774 wxRelationship arg2 ;
53775 void *argp1 = 0 ;
53776 int res1 = 0 ;
53777 int val2 ;
53778 int ecode2 = 0 ;
53779 PyObject * obj0 = 0 ;
53780 PyObject * obj1 = 0 ;
53781 char * kwnames[] = {
53782 (char *) "self",(char *) "r", NULL
53783 };
53784
53785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53787 if (!SWIG_IsOK(res1)) {
53788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53789 }
53790 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53791 ecode2 = SWIG_AsVal_int(obj1, &val2);
53792 if (!SWIG_IsOK(ecode2)) {
53793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53794 }
53795 arg2 = static_cast< wxRelationship >(val2);
53796 {
53797 PyThreadState* __tstate = wxPyBeginAllowThreads();
53798 (arg1)->SetRelationship(arg2);
53799 wxPyEndAllowThreads(__tstate);
53800 if (PyErr_Occurred()) SWIG_fail;
53801 }
53802 resultobj = SWIG_Py_Void();
53803 return resultobj;
53804 fail:
53805 return NULL;
53806 }
53807
53808
53809 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53810 PyObject *resultobj = 0;
53811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53812 wxWindow *arg2 = (wxWindow *) 0 ;
53813 bool result;
53814 void *argp1 = 0 ;
53815 int res1 = 0 ;
53816 void *argp2 = 0 ;
53817 int res2 = 0 ;
53818 PyObject * obj0 = 0 ;
53819 PyObject * obj1 = 0 ;
53820 char * kwnames[] = {
53821 (char *) "self",(char *) "otherW", NULL
53822 };
53823
53824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53826 if (!SWIG_IsOK(res1)) {
53827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53828 }
53829 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53831 if (!SWIG_IsOK(res2)) {
53832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53833 }
53834 arg2 = reinterpret_cast< wxWindow * >(argp2);
53835 {
53836 PyThreadState* __tstate = wxPyBeginAllowThreads();
53837 result = (bool)(arg1)->ResetIfWin(arg2);
53838 wxPyEndAllowThreads(__tstate);
53839 if (PyErr_Occurred()) SWIG_fail;
53840 }
53841 {
53842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53843 }
53844 return resultobj;
53845 fail:
53846 return NULL;
53847 }
53848
53849
53850 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53851 PyObject *resultobj = 0;
53852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53853 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53854 wxWindow *arg3 = (wxWindow *) 0 ;
53855 bool result;
53856 void *argp1 = 0 ;
53857 int res1 = 0 ;
53858 void *argp2 = 0 ;
53859 int res2 = 0 ;
53860 void *argp3 = 0 ;
53861 int res3 = 0 ;
53862 PyObject * obj0 = 0 ;
53863 PyObject * obj1 = 0 ;
53864 PyObject * obj2 = 0 ;
53865 char * kwnames[] = {
53866 (char *) "self",(char *) "constraints",(char *) "win", NULL
53867 };
53868
53869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53871 if (!SWIG_IsOK(res1)) {
53872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53873 }
53874 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53876 if (!SWIG_IsOK(res2)) {
53877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53878 }
53879 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53880 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53881 if (!SWIG_IsOK(res3)) {
53882 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53883 }
53884 arg3 = reinterpret_cast< wxWindow * >(argp3);
53885 {
53886 PyThreadState* __tstate = wxPyBeginAllowThreads();
53887 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53888 wxPyEndAllowThreads(__tstate);
53889 if (PyErr_Occurred()) SWIG_fail;
53890 }
53891 {
53892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53893 }
53894 return resultobj;
53895 fail:
53896 return NULL;
53897 }
53898
53899
53900 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53901 PyObject *resultobj = 0;
53902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53903 wxEdge arg2 ;
53904 wxWindow *arg3 = (wxWindow *) 0 ;
53905 wxWindow *arg4 = (wxWindow *) 0 ;
53906 int result;
53907 void *argp1 = 0 ;
53908 int res1 = 0 ;
53909 int val2 ;
53910 int ecode2 = 0 ;
53911 void *argp3 = 0 ;
53912 int res3 = 0 ;
53913 void *argp4 = 0 ;
53914 int res4 = 0 ;
53915 PyObject * obj0 = 0 ;
53916 PyObject * obj1 = 0 ;
53917 PyObject * obj2 = 0 ;
53918 PyObject * obj3 = 0 ;
53919 char * kwnames[] = {
53920 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53921 };
53922
53923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53925 if (!SWIG_IsOK(res1)) {
53926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53927 }
53928 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53929 ecode2 = SWIG_AsVal_int(obj1, &val2);
53930 if (!SWIG_IsOK(ecode2)) {
53931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53932 }
53933 arg2 = static_cast< wxEdge >(val2);
53934 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53935 if (!SWIG_IsOK(res3)) {
53936 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53937 }
53938 arg3 = reinterpret_cast< wxWindow * >(argp3);
53939 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53940 if (!SWIG_IsOK(res4)) {
53941 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53942 }
53943 arg4 = reinterpret_cast< wxWindow * >(argp4);
53944 {
53945 PyThreadState* __tstate = wxPyBeginAllowThreads();
53946 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53947 wxPyEndAllowThreads(__tstate);
53948 if (PyErr_Occurred()) SWIG_fail;
53949 }
53950 resultobj = SWIG_From_int(static_cast< int >(result));
53951 return resultobj;
53952 fail:
53953 return NULL;
53954 }
53955
53956
53957 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53958 PyObject *obj;
53959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53960 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53961 return SWIG_Py_Void();
53962 }
53963
53964 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53965 PyObject *resultobj = 0;
53966 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53967 wxIndividualLayoutConstraint *result = 0 ;
53968 void *argp1 = 0 ;
53969 int res1 = 0 ;
53970 PyObject *swig_obj[1] ;
53971
53972 if (!args) SWIG_fail;
53973 swig_obj[0] = args;
53974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53975 if (!SWIG_IsOK(res1)) {
53976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53977 }
53978 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53979 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53981 return resultobj;
53982 fail:
53983 return NULL;
53984 }
53985
53986
53987 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53988 PyObject *resultobj = 0;
53989 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53990 wxIndividualLayoutConstraint *result = 0 ;
53991 void *argp1 = 0 ;
53992 int res1 = 0 ;
53993 PyObject *swig_obj[1] ;
53994
53995 if (!args) SWIG_fail;
53996 swig_obj[0] = args;
53997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53998 if (!SWIG_IsOK(res1)) {
53999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54000 }
54001 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54002 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54004 return resultobj;
54005 fail:
54006 return NULL;
54007 }
54008
54009
54010 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54011 PyObject *resultobj = 0;
54012 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54013 wxIndividualLayoutConstraint *result = 0 ;
54014 void *argp1 = 0 ;
54015 int res1 = 0 ;
54016 PyObject *swig_obj[1] ;
54017
54018 if (!args) SWIG_fail;
54019 swig_obj[0] = args;
54020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54021 if (!SWIG_IsOK(res1)) {
54022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54023 }
54024 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54025 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54027 return resultobj;
54028 fail:
54029 return NULL;
54030 }
54031
54032
54033 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54034 PyObject *resultobj = 0;
54035 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54036 wxIndividualLayoutConstraint *result = 0 ;
54037 void *argp1 = 0 ;
54038 int res1 = 0 ;
54039 PyObject *swig_obj[1] ;
54040
54041 if (!args) SWIG_fail;
54042 swig_obj[0] = args;
54043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54044 if (!SWIG_IsOK(res1)) {
54045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54046 }
54047 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54048 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54050 return resultobj;
54051 fail:
54052 return NULL;
54053 }
54054
54055
54056 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54057 PyObject *resultobj = 0;
54058 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54059 wxIndividualLayoutConstraint *result = 0 ;
54060 void *argp1 = 0 ;
54061 int res1 = 0 ;
54062 PyObject *swig_obj[1] ;
54063
54064 if (!args) SWIG_fail;
54065 swig_obj[0] = args;
54066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54067 if (!SWIG_IsOK(res1)) {
54068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54069 }
54070 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54071 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54073 return resultobj;
54074 fail:
54075 return NULL;
54076 }
54077
54078
54079 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54080 PyObject *resultobj = 0;
54081 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54082 wxIndividualLayoutConstraint *result = 0 ;
54083 void *argp1 = 0 ;
54084 int res1 = 0 ;
54085 PyObject *swig_obj[1] ;
54086
54087 if (!args) SWIG_fail;
54088 swig_obj[0] = args;
54089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54090 if (!SWIG_IsOK(res1)) {
54091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54092 }
54093 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54094 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54096 return resultobj;
54097 fail:
54098 return NULL;
54099 }
54100
54101
54102 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54103 PyObject *resultobj = 0;
54104 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54105 wxIndividualLayoutConstraint *result = 0 ;
54106 void *argp1 = 0 ;
54107 int res1 = 0 ;
54108 PyObject *swig_obj[1] ;
54109
54110 if (!args) SWIG_fail;
54111 swig_obj[0] = args;
54112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54113 if (!SWIG_IsOK(res1)) {
54114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54115 }
54116 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54117 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54119 return resultobj;
54120 fail:
54121 return NULL;
54122 }
54123
54124
54125 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54126 PyObject *resultobj = 0;
54127 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54128 wxIndividualLayoutConstraint *result = 0 ;
54129 void *argp1 = 0 ;
54130 int res1 = 0 ;
54131 PyObject *swig_obj[1] ;
54132
54133 if (!args) SWIG_fail;
54134 swig_obj[0] = args;
54135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54136 if (!SWIG_IsOK(res1)) {
54137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54138 }
54139 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54140 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54142 return resultobj;
54143 fail:
54144 return NULL;
54145 }
54146
54147
54148 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54149 PyObject *resultobj = 0;
54150 wxLayoutConstraints *result = 0 ;
54151
54152 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54153 {
54154 PyThreadState* __tstate = wxPyBeginAllowThreads();
54155 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54156 wxPyEndAllowThreads(__tstate);
54157 if (PyErr_Occurred()) SWIG_fail;
54158 }
54159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54160 return resultobj;
54161 fail:
54162 return NULL;
54163 }
54164
54165
54166 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54167 PyObject *resultobj = 0;
54168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54169 void *argp1 = 0 ;
54170 int res1 = 0 ;
54171 PyObject *swig_obj[1] ;
54172
54173 if (!args) SWIG_fail;
54174 swig_obj[0] = args;
54175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54176 if (!SWIG_IsOK(res1)) {
54177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54178 }
54179 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54180 {
54181 PyThreadState* __tstate = wxPyBeginAllowThreads();
54182 delete arg1;
54183
54184 wxPyEndAllowThreads(__tstate);
54185 if (PyErr_Occurred()) SWIG_fail;
54186 }
54187 resultobj = SWIG_Py_Void();
54188 return resultobj;
54189 fail:
54190 return NULL;
54191 }
54192
54193
54194 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54195 PyObject *resultobj = 0;
54196 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54197 wxWindow *arg2 = (wxWindow *) 0 ;
54198 int *arg3 = (int *) 0 ;
54199 bool result;
54200 void *argp1 = 0 ;
54201 int res1 = 0 ;
54202 void *argp2 = 0 ;
54203 int res2 = 0 ;
54204 int temp3 ;
54205 int res3 = SWIG_TMPOBJ ;
54206 PyObject * obj0 = 0 ;
54207 PyObject * obj1 = 0 ;
54208 char * kwnames[] = {
54209 (char *) "self",(char *) "win", NULL
54210 };
54211
54212 arg3 = &temp3;
54213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54215 if (!SWIG_IsOK(res1)) {
54216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54217 }
54218 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54220 if (!SWIG_IsOK(res2)) {
54221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54222 }
54223 arg2 = reinterpret_cast< wxWindow * >(argp2);
54224 {
54225 PyThreadState* __tstate = wxPyBeginAllowThreads();
54226 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54227 wxPyEndAllowThreads(__tstate);
54228 if (PyErr_Occurred()) SWIG_fail;
54229 }
54230 {
54231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54232 }
54233 if (SWIG_IsTmpObj(res3)) {
54234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54235 } else {
54236 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54238 }
54239 return resultobj;
54240 fail:
54241 return NULL;
54242 }
54243
54244
54245 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54246 PyObject *resultobj = 0;
54247 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54248 bool result;
54249 void *argp1 = 0 ;
54250 int res1 = 0 ;
54251 PyObject *swig_obj[1] ;
54252
54253 if (!args) SWIG_fail;
54254 swig_obj[0] = args;
54255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54256 if (!SWIG_IsOK(res1)) {
54257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54258 }
54259 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54260 {
54261 PyThreadState* __tstate = wxPyBeginAllowThreads();
54262 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54263 wxPyEndAllowThreads(__tstate);
54264 if (PyErr_Occurred()) SWIG_fail;
54265 }
54266 {
54267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54268 }
54269 return resultobj;
54270 fail:
54271 return NULL;
54272 }
54273
54274
54275 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54276 PyObject *obj;
54277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54278 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54279 return SWIG_Py_Void();
54280 }
54281
54282 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54283 return SWIG_Python_InitShadowInstance(args);
54284 }
54285
54286 static PyMethodDef SwigMethods[] = {
54287 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54288 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54289 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54290 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54291 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54292 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54293 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54294 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54295 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54296 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54297 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54310 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54311 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54312 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54314 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54315 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54316 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54317 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54318 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54319 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54320 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54322 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54328 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54329 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54330 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54331 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54332 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54333 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54334 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54336 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54344 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54345 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54346 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54351 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54352 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54354 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54356 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54358 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54360 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54362 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54364 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54365 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54367 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54369 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54371 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54373 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54374 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54375 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54376 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54396 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54397 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54398 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54399 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54400 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54401 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54402 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54403 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54405 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54406 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54407 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54412 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54413 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54414 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54415 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54416 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54423 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54430 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54431 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54432 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54433 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54435 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54436 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54437 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54439 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54440 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54441 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54442 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54447 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54448 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54449 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54450 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54451 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54452 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54455 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54456 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54457 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54459 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54460 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54462 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54463 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54464 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54465 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54466 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54467 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54468 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54469 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54470 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54471 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54472 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54473 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54478 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54484 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54485 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54486 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54487 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54489 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54492 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54495 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54498 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54499 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54500 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54503 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54504 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54505 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54509 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54510 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54511 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54515 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54520 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54521 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54522 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54523 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54524 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54525 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54526 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54530 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54533 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54534 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54536 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54537 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54538 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54543 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54544 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54545 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54547 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54548 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54549 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54550 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54551 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54552 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54553 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54554 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54555 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54556 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54557 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54558 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54559 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54560 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54561 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54562 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54563 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54565 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54568 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54569 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54574 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54590 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54591 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54592 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54607 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54608 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54609 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54610 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54613 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54615 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54617 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54619 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54621 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54624 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54625 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54626 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54627 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54629 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54646 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54647 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54653 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54654 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54655 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54656 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54657 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54658 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54659 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54660 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54661 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54662 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54663 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54664 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54665 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54666 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54667 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54668 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54669 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54670 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54671 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54672 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54673 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54674 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54675 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54676 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54677 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54678 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54679 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54680 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54681 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54682 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54683 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54684 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54685 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54686 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54687 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54688 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54689 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54690 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54691 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54692 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54693 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54696 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54699 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54700 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54701 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54702 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54703 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54707 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54708 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54709 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54710 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54712 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54713 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54714 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54715 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54716 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54717 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54719 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54721 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54722 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54723 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54725 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54726 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54728 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54729 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54730 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54732 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54733 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54734 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54736 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54738 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54739 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54740 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54742 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54744 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54745 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54747 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54748 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54749 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54751 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54752 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54753 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54754 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54755 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54757 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54758 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54761 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54762 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54764 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54765 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54768 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54769 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54771 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54777 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54778 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54779 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54780 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54781 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54782 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54783 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54784 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54785 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54786 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54787 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54788 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54789 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54790 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54791 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54792 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54793 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54794 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54795 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54796 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54797 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54798 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54799 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54800 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54802 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54803 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54804 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54805 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54806 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54807 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54808 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54809 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54810 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54811 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54812 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54813 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54814 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54815 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54816 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54817 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54818 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54819 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54820 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54821 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54822 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54823 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54824 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54825 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54826 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54827 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54828 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54829 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54830 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54831 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54832 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54833 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54835 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54836 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54838 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54839 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54840 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54841 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54843 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54844 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54845 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54846 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54847 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54848 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54849 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54850 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54851 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54853 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54854 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54855 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54856 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54857 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54858 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54859 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54860 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54861 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54862 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54863 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54864 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54865 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54866 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54867 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54868 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54869 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54870 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54871 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54872 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54873 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54874 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54875 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54876 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54877 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54878 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54879 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54880 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54882 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54883 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54886 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54887 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54888 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54889 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54890 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54891 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54893 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54894 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54897 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54898 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54900 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54901 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54903 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54904 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54906 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54907 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54908 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54910 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54912 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54913 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54915 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54916 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54917 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54919 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54920 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54921 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54923 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54924 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54925 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54926 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54927 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54928 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54929 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54930 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54933 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54935 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54937 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54938 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54939 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54942 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54943 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54944 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54946 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54947 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54948 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54950 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54951 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54952 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54953 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54954 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54955 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54957 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54958 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54959 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54960 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54961 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54962 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54963 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54964 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54970 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54972 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54974 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54975 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54976 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54977 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54978 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54979 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54981 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54982 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54983 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54985 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54986 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54987 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54988 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54989 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54992 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54993 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54994 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54997 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54998 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54999 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55000 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55001 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55003 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55005 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55008 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55010 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55011 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55013 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55014 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55015 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55017 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55018 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55019 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55021 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55023 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55024 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55025 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55027 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55029 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55031 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55032 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55034 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55035 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55037 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55039 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55040 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55041 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55043 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55044 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55045 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55046 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55047 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55049 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55051 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55052 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55053 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55054 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55056 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55058 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55060 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55062 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55063 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55065 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55066 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55067 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55068 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55069 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55070 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55071 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55072 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55073 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55075 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55077 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55078 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55079 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55080 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55081 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55083 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55085 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55086 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55087 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55088 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55089 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55090 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55096 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55097 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55098 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55099 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55100 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55101 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55102 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55103 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55104 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55105 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55106 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55107 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55108 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55110 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55111 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55112 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55113 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55115 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55116 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55117 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55118 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55120 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55121 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55123 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55124 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55125 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55127 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55130 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55131 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55132 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55133 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55134 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55136 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55137 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55139 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55140 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55141 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55142 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55144 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55145 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55146 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55147 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55148 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55149 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55150 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55151 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55152 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55153 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55155 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55158 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55159 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55160 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55162 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55164 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55165 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55166 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55167 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55168 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55169 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55172 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55182 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55183 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55187 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55188 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55189 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55190 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55191 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55192 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55193 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55194 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55195 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55196 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55197 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55198 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55199 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55200 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55201 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55202 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55203 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55204 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55207 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55208 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55213 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55214 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55217 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55218 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55219 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55220 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55222 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55223 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55224 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55225 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55226 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55227 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55228 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55229 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55230 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55231 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55232 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55234 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55235 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55236 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55237 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55238 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55239 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55241 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55242 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55243 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55244 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55245 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55246 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55247 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55249 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55250 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55251 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55252 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55253 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55254 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55255 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55260 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55263 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55265 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55266 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55267 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55268 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55269 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55270 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55272 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55275 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55276 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55277 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55278 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55282 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55283 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55284 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55285 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55288 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55289 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55290 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55291 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55292 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55294 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55295 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55296 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55297 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55300 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55306 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55307 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55308 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55309 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55311 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55312 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55313 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55314 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55316 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55317 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55319 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55320 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55321 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55325 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55326 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55330 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55334 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55335 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55337 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55339 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55340 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55342 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55343 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55346 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55347 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55348 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55349 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55350 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55354 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55355 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55357 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55359 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55362 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55364 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55365 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55368 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55369 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55370 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55371 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55372 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55373 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55374 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55375 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55376 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55380 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55381 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55382 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55383 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55384 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55385 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55386 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55387 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55388 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55389 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55390 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55391 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55392 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55393 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55394 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55395 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55396 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55397 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55398 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55399 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55401 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55402 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55404 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55405 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55407 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55408 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55413 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55414 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55416 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55417 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55421 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55422 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55425 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55426 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55431 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55439 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55441 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55442 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55443 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55444 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55446 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55448 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55449 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55450 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55451 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55452 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55453 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55454 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55457 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55458 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55475 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55476 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55477 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55478 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55479 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55480 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55481 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55482 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55483 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55484 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55485 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55486 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55487 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55489 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55490 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55491 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55492 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55493 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55494 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55495 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55496 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55499 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55500 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55502 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55503 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55504 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55505 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55506 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55507 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55508 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55509 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55510 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55511 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55512 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55513 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55514 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55515 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55516 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55517 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55518 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55519 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55521 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55522 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55523 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55524 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55525 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55526 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55528 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55529 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55530 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55531 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55532 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55534 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55535 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55536 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55537 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55538 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55539 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55540 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55541 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55543 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55544 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55545 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55547 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55548 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55550 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55551 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55552 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55553 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55554 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55555 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55556 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55557 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55558 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55559 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55560 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55561 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55563 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55564 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55565 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55566 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55567 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55568 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55569 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55570 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55571 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55576 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55577 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55578 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55579 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55580 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55582 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55583 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55584 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55585 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55586 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55587 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55588 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55589 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55590 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55591 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55592 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55593 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55594 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55595 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55596 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55597 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55598 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55599 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55600 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55603 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55604 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55605 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55606 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55608 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55612 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55613 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55615 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55617 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55618 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55619 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55620 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55621 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55622 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55623 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55624 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55625 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55626 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55627 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55628 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55629 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55630 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55631 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55633 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55634 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55635 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55636 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55638 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55639 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55640 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55641 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55642 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55643 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55644 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55645 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55646 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55647 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55648 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55649 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55650 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55651 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55652 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55653 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55654 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55655 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55656 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55657 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55658 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55659 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55660 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55661 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55662 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55663 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55664 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55665 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55666 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55667 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55668 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55669 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55670 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55671 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55672 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55673 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55674 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55675 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55676 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55677 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55678 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55679 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55680 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55681 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55682 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55683 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55684 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55685 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55686 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55687 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55688 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55689 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55690 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55691 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55692 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55693 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55694 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55695 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55696 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55697 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55698 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55699 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55700 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55701 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55702 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55703 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55704 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55705 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55706 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55707 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55708 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55709 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55710 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55711 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55712 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55713 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55714 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55715 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55716 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55717 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55718 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55719 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55720 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55721 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55722 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55723 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55724 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55725 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55726 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55727 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55728 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55729 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55730 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55731 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55732 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55733 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55734 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55735 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55736 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55737 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55738 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55739 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55740 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55741 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55742 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55743 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55744 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55745 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55746 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55747 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55748 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55750 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55751 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55752 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55753 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55754 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55756 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55757 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55758 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55759 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55760 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55761 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55762 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55763 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55764 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55765 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55766 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55767 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55768 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55769 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55770 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55771 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55772 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55773 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55774 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55775 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55776 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55777 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55778 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55779 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55780 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55781 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55782 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55783 { NULL, NULL, 0, NULL }
55784 };
55785
55786
55787 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55788
55789 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55790 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55791 }
55792 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55793 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55794 }
55795 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55796 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55797 }
55798 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55799 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55800 }
55801 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55802 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55803 }
55804 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55805 return (void *)((wxSizer *) ((wxGridSizer *) x));
55806 }
55807 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55808 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55809 }
55810 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55811 return (void *)((wxSizer *) ((wxPySizer *) x));
55812 }
55813 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55814 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55815 }
55816 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55817 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55818 }
55819 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55820 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55821 }
55822 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55823 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55824 }
55825 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55826 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55827 }
55828 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55829 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55830 }
55831 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55832 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55833 }
55834 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55835 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55836 }
55837 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55838 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55839 }
55840 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55841 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55842 }
55843 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55844 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55845 }
55846 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55847 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55848 }
55849 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55850 return (void *)((wxEvent *) ((wxPyEvent *) x));
55851 }
55852 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55853 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55854 }
55855 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55856 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55857 }
55858 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55859 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55860 }
55861 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55862 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55863 }
55864 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55865 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55866 }
55867 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55868 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55869 }
55870 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55871 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55872 }
55873 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55874 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55875 }
55876 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55877 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55878 }
55879 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55880 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55881 }
55882 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55883 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55884 }
55885 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55886 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55887 }
55888 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55889 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55890 }
55891 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55892 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55893 }
55894 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55895 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55896 }
55897 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55898 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55899 }
55900 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55901 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55902 }
55903 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55904 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55905 }
55906 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55907 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55908 }
55909 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55910 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55911 }
55912 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55913 return (void *)((wxEvent *) ((wxShowEvent *) x));
55914 }
55915 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55916 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55917 }
55918 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55919 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55920 }
55921 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55922 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55923 }
55924 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55925 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55926 }
55927 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55928 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55929 }
55930 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55931 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55932 }
55933 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55934 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55935 }
55936 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55937 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55938 }
55939 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55940 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55941 }
55942 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55943 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55944 }
55945 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55946 return (void *)((wxControl *) ((wxControlWithItems *) x));
55947 }
55948 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55949 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55950 }
55951 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55952 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55953 }
55954 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55955 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55956 }
55957 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55958 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55959 }
55960 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55961 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55962 }
55963 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55964 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55965 }
55966 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55967 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55968 }
55969 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55970 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55971 }
55972 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55973 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55974 }
55975 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55976 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55977 }
55978 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55979 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55980 }
55981 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55982 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55983 }
55984 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55985 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55986 }
55987 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55988 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55989 }
55990 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55991 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55992 }
55993 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55994 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55995 }
55996 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55997 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55998 }
55999 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56000 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56001 }
56002 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56003 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56004 }
56005 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56006 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56007 }
56008 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56009 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56010 }
56011 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56012 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56013 }
56014 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56015 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56016 }
56017 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56018 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56019 }
56020 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56021 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56022 }
56023 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56024 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56025 }
56026 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56027 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56028 }
56029 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56030 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56031 }
56032 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56033 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56034 }
56035 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56036 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56037 }
56038 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56039 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56040 }
56041 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56042 return (void *)((wxObject *) ((wxSizerItem *) x));
56043 }
56044 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56045 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56046 }
56047 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56048 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56049 }
56050 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56051 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56052 }
56053 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56054 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56055 }
56056 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56057 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56058 }
56059 static void *_p_wxSizerTo_p_wxObject(void *x) {
56060 return (void *)((wxObject *) ((wxSizer *) x));
56061 }
56062 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56063 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56064 }
56065 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56066 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56067 }
56068 static void *_p_wxEventTo_p_wxObject(void *x) {
56069 return (void *)((wxObject *) ((wxEvent *) x));
56070 }
56071 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56072 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56073 }
56074 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56075 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56076 }
56077 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56078 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56079 }
56080 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56081 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56082 }
56083 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56084 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56085 }
56086 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56087 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56088 }
56089 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56090 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56091 }
56092 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56093 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56094 }
56095 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56096 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56097 }
56098 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56099 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56100 }
56101 static void *_p_wxControlTo_p_wxObject(void *x) {
56102 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56103 }
56104 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56105 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56106 }
56107 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56108 return (void *)((wxObject *) ((wxFSFile *) x));
56109 }
56110 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56111 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56112 }
56113 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56114 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56115 }
56116 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56117 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56118 }
56119 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56120 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56121 }
56122 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56123 return (void *)((wxObject *) ((wxMenuItem *) x));
56124 }
56125 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56126 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56127 }
56128 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56129 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56130 }
56131 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56132 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56133 }
56134 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56135 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56136 }
56137 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56138 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56139 }
56140 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56141 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56142 }
56143 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56144 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56145 }
56146 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56147 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56148 }
56149 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56150 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56151 }
56152 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56153 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56154 }
56155 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56156 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56157 }
56158 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56159 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56160 }
56161 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56162 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56163 }
56164 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56165 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56166 }
56167 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56168 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56169 }
56170 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56171 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56172 }
56173 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56174 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56175 }
56176 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56177 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56178 }
56179 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56180 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56181 }
56182 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56183 return (void *)((wxObject *) ((wxImageHandler *) x));
56184 }
56185 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56186 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56187 }
56188 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56189 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56190 }
56191 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56192 return (void *)((wxObject *) ((wxEvtHandler *) x));
56193 }
56194 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56195 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56196 }
56197 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56198 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56199 }
56200 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56201 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56202 }
56203 static void *_p_wxImageTo_p_wxObject(void *x) {
56204 return (void *)((wxObject *) ((wxImage *) x));
56205 }
56206 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56207 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56208 }
56209 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56210 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56211 }
56212 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56213 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56214 }
56215 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56216 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56217 }
56218 static void *_p_wxWindowTo_p_wxObject(void *x) {
56219 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56220 }
56221 static void *_p_wxMenuTo_p_wxObject(void *x) {
56222 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56223 }
56224 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56225 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56226 }
56227 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56228 return (void *)((wxObject *) ((wxFileSystem *) x));
56229 }
56230 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56231 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56232 }
56233 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56234 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56235 }
56236 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56237 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56238 }
56239 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56240 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56241 }
56242 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56243 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56244 }
56245 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56246 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56247 }
56248 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56249 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56250 }
56251 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56252 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56253 }
56254 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56255 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56256 }
56257 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56258 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56259 }
56260 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56261 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56262 }
56263 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56264 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56265 }
56266 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56267 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56268 }
56269 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56270 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56271 }
56272 static void *_p_wxControlTo_p_wxWindow(void *x) {
56273 return (void *)((wxWindow *) ((wxControl *) x));
56274 }
56275 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56276 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56277 }
56278 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56279 return (void *)((wxWindow *) ((wxMenuBar *) x));
56280 }
56281 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56282 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56283 }
56284 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56285 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56286 }
56287 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56288 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56289 }
56290 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56291 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56292 }
56293 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56294 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56295 }
56296 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56297 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56298 }
56299 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56300 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56301 }
56302 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56303 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56304 }
56305 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56306 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56307 }
56308 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56309 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56310 }
56311 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56312 return (void *)((wxValidator *) ((wxPyValidator *) x));
56313 }
56314 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56315 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56316 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};
56317 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56318 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56319 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56320 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56321 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56322 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56323 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56324 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56325 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56326 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56327 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56328 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56329 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56330 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56331 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56332 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56333 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56334 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56335 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56336 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56337 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56338 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56339 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56340 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56341 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56342 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56343 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56344 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56345 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56346 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56348 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56349 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56446
56447 static swig_type_info *swig_type_initial[] = {
56448 &_swigt__p_buffer,
56449 &_swigt__p_char,
56450 &_swigt__p_form_ops_t,
56451 &_swigt__p_int,
56452 &_swigt__p_long,
56453 &_swigt__p_unsigned_char,
56454 &_swigt__p_unsigned_int,
56455 &_swigt__p_unsigned_long,
56456 &_swigt__p_wxANIHandler,
56457 &_swigt__p_wxAcceleratorEntry,
56458 &_swigt__p_wxAcceleratorTable,
56459 &_swigt__p_wxActivateEvent,
56460 &_swigt__p_wxAppTraits,
56461 &_swigt__p_wxArrayString,
56462 &_swigt__p_wxBMPHandler,
56463 &_swigt__p_wxBitmap,
56464 &_swigt__p_wxBoxSizer,
56465 &_swigt__p_wxButton,
56466 &_swigt__p_wxCURHandler,
56467 &_swigt__p_wxCaret,
56468 &_swigt__p_wxChildFocusEvent,
56469 &_swigt__p_wxClipboardTextEvent,
56470 &_swigt__p_wxCloseEvent,
56471 &_swigt__p_wxColour,
56472 &_swigt__p_wxCommandEvent,
56473 &_swigt__p_wxContextMenuEvent,
56474 &_swigt__p_wxControl,
56475 &_swigt__p_wxControlWithItems,
56476 &_swigt__p_wxCursor,
56477 &_swigt__p_wxDC,
56478 &_swigt__p_wxDateEvent,
56479 &_swigt__p_wxDateTime,
56480 &_swigt__p_wxDisplayChangedEvent,
56481 &_swigt__p_wxDropFilesEvent,
56482 &_swigt__p_wxDuplexMode,
56483 &_swigt__p_wxEraseEvent,
56484 &_swigt__p_wxEvent,
56485 &_swigt__p_wxEventLoop,
56486 &_swigt__p_wxEventLoopActivator,
56487 &_swigt__p_wxEvtHandler,
56488 &_swigt__p_wxFSFile,
56489 &_swigt__p_wxFileSystem,
56490 &_swigt__p_wxFileSystemHandler,
56491 &_swigt__p_wxFlexGridSizer,
56492 &_swigt__p_wxFocusEvent,
56493 &_swigt__p_wxFont,
56494 &_swigt__p_wxFrame,
56495 &_swigt__p_wxGBPosition,
56496 &_swigt__p_wxGBSizerItem,
56497 &_swigt__p_wxGBSpan,
56498 &_swigt__p_wxGIFHandler,
56499 &_swigt__p_wxGridBagSizer,
56500 &_swigt__p_wxGridSizer,
56501 &_swigt__p_wxHelpEvent__Origin,
56502 &_swigt__p_wxICOHandler,
56503 &_swigt__p_wxIconizeEvent,
56504 &_swigt__p_wxIdleEvent,
56505 &_swigt__p_wxImage,
56506 &_swigt__p_wxImageHandler,
56507 &_swigt__p_wxImageHistogram,
56508 &_swigt__p_wxImage_HSVValue,
56509 &_swigt__p_wxImage_RGBValue,
56510 &_swigt__p_wxIndividualLayoutConstraint,
56511 &_swigt__p_wxInitDialogEvent,
56512 &_swigt__p_wxInputStream,
56513 &_swigt__p_wxInternetFSHandler,
56514 &_swigt__p_wxItemContainer,
56515 &_swigt__p_wxJPEGHandler,
56516 &_swigt__p_wxKeyEvent,
56517 &_swigt__p_wxLayoutConstraints,
56518 &_swigt__p_wxMaximizeEvent,
56519 &_swigt__p_wxMemoryFSHandler,
56520 &_swigt__p_wxMenu,
56521 &_swigt__p_wxMenuBar,
56522 &_swigt__p_wxMenuBarBase,
56523 &_swigt__p_wxMenuEvent,
56524 &_swigt__p_wxMenuItem,
56525 &_swigt__p_wxMouseCaptureChangedEvent,
56526 &_swigt__p_wxMouseCaptureLostEvent,
56527 &_swigt__p_wxMouseEvent,
56528 &_swigt__p_wxMoveEvent,
56529 &_swigt__p_wxNavigationKeyEvent,
56530 &_swigt__p_wxNcPaintEvent,
56531 &_swigt__p_wxNotifyEvent,
56532 &_swigt__p_wxObject,
56533 &_swigt__p_wxOutputStream,
56534 &_swigt__p_wxPCXHandler,
56535 &_swigt__p_wxPNGHandler,
56536 &_swigt__p_wxPNMHandler,
56537 &_swigt__p_wxPaintEvent,
56538 &_swigt__p_wxPaletteChangedEvent,
56539 &_swigt__p_wxPaperSize,
56540 &_swigt__p_wxPoint,
56541 &_swigt__p_wxPoint2D,
56542 &_swigt__p_wxPropagateOnce,
56543 &_swigt__p_wxPropagationDisabler,
56544 &_swigt__p_wxPyApp,
56545 &_swigt__p_wxPyCommandEvent,
56546 &_swigt__p_wxPyDropTarget,
56547 &_swigt__p_wxPyEvent,
56548 &_swigt__p_wxPyFileSystemHandler,
56549 &_swigt__p_wxPyImageHandler,
56550 &_swigt__p_wxPyInputStream,
56551 &_swigt__p_wxPySizer,
56552 &_swigt__p_wxPyValidator,
56553 &_swigt__p_wxQuantize,
56554 &_swigt__p_wxQueryNewPaletteEvent,
56555 &_swigt__p_wxRealPoint,
56556 &_swigt__p_wxRect,
56557 &_swigt__p_wxRegion,
56558 &_swigt__p_wxScrollEvent,
56559 &_swigt__p_wxScrollWinEvent,
56560 &_swigt__p_wxSetCursorEvent,
56561 &_swigt__p_wxShowEvent,
56562 &_swigt__p_wxSize,
56563 &_swigt__p_wxSizeEvent,
56564 &_swigt__p_wxSizer,
56565 &_swigt__p_wxSizerItem,
56566 &_swigt__p_wxStaticBox,
56567 &_swigt__p_wxStaticBoxSizer,
56568 &_swigt__p_wxStdDialogButtonSizer,
56569 &_swigt__p_wxSysColourChangedEvent,
56570 &_swigt__p_wxTIFFHandler,
56571 &_swigt__p_wxToolTip,
56572 &_swigt__p_wxUpdateUIEvent,
56573 &_swigt__p_wxValidator,
56574 &_swigt__p_wxVisualAttributes,
56575 &_swigt__p_wxWindow,
56576 &_swigt__p_wxWindowCreateEvent,
56577 &_swigt__p_wxWindowDestroyEvent,
56578 &_swigt__p_wxXPMHandler,
56579 &_swigt__p_wxZipFSHandler,
56580 };
56581
56582 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56583 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56584 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56585 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56586 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56587 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56588 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56589 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56590 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56591 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56592 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56593 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56594 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56595 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56596 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}};
56597 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56598 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}};
56599 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56600 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}};
56601 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56602 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56603 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56604 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56605 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56606 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}};
56607 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56608 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}};
56609 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56610 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56611 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56612 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56613 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56614 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56615 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56617 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56618 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}};
56619 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56623 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56624 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}};
56625 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}};
56626 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56627 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56628 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56629 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56630 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56631 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56632 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56633 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56634 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}};
56635 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56636 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}};
56637 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56639 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56640 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
56641 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56642 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56643 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56646 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56647 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56648 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}};
56649 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56650 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56651 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56653 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56654 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56656 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56657 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56660 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56661 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56666 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
56667 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56669 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56672 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56675 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56698 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}};
56699 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}};
56700 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56704 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56705 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56706 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56707 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}};
56708 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56709 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}};
56710 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56713 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56714
56715 static swig_cast_info *swig_cast_initial[] = {
56716 _swigc__p_buffer,
56717 _swigc__p_char,
56718 _swigc__p_form_ops_t,
56719 _swigc__p_int,
56720 _swigc__p_long,
56721 _swigc__p_unsigned_char,
56722 _swigc__p_unsigned_int,
56723 _swigc__p_unsigned_long,
56724 _swigc__p_wxANIHandler,
56725 _swigc__p_wxAcceleratorEntry,
56726 _swigc__p_wxAcceleratorTable,
56727 _swigc__p_wxActivateEvent,
56728 _swigc__p_wxAppTraits,
56729 _swigc__p_wxArrayString,
56730 _swigc__p_wxBMPHandler,
56731 _swigc__p_wxBitmap,
56732 _swigc__p_wxBoxSizer,
56733 _swigc__p_wxButton,
56734 _swigc__p_wxCURHandler,
56735 _swigc__p_wxCaret,
56736 _swigc__p_wxChildFocusEvent,
56737 _swigc__p_wxClipboardTextEvent,
56738 _swigc__p_wxCloseEvent,
56739 _swigc__p_wxColour,
56740 _swigc__p_wxCommandEvent,
56741 _swigc__p_wxContextMenuEvent,
56742 _swigc__p_wxControl,
56743 _swigc__p_wxControlWithItems,
56744 _swigc__p_wxCursor,
56745 _swigc__p_wxDC,
56746 _swigc__p_wxDateEvent,
56747 _swigc__p_wxDateTime,
56748 _swigc__p_wxDisplayChangedEvent,
56749 _swigc__p_wxDropFilesEvent,
56750 _swigc__p_wxDuplexMode,
56751 _swigc__p_wxEraseEvent,
56752 _swigc__p_wxEvent,
56753 _swigc__p_wxEventLoop,
56754 _swigc__p_wxEventLoopActivator,
56755 _swigc__p_wxEvtHandler,
56756 _swigc__p_wxFSFile,
56757 _swigc__p_wxFileSystem,
56758 _swigc__p_wxFileSystemHandler,
56759 _swigc__p_wxFlexGridSizer,
56760 _swigc__p_wxFocusEvent,
56761 _swigc__p_wxFont,
56762 _swigc__p_wxFrame,
56763 _swigc__p_wxGBPosition,
56764 _swigc__p_wxGBSizerItem,
56765 _swigc__p_wxGBSpan,
56766 _swigc__p_wxGIFHandler,
56767 _swigc__p_wxGridBagSizer,
56768 _swigc__p_wxGridSizer,
56769 _swigc__p_wxHelpEvent__Origin,
56770 _swigc__p_wxICOHandler,
56771 _swigc__p_wxIconizeEvent,
56772 _swigc__p_wxIdleEvent,
56773 _swigc__p_wxImage,
56774 _swigc__p_wxImageHandler,
56775 _swigc__p_wxImageHistogram,
56776 _swigc__p_wxImage_HSVValue,
56777 _swigc__p_wxImage_RGBValue,
56778 _swigc__p_wxIndividualLayoutConstraint,
56779 _swigc__p_wxInitDialogEvent,
56780 _swigc__p_wxInputStream,
56781 _swigc__p_wxInternetFSHandler,
56782 _swigc__p_wxItemContainer,
56783 _swigc__p_wxJPEGHandler,
56784 _swigc__p_wxKeyEvent,
56785 _swigc__p_wxLayoutConstraints,
56786 _swigc__p_wxMaximizeEvent,
56787 _swigc__p_wxMemoryFSHandler,
56788 _swigc__p_wxMenu,
56789 _swigc__p_wxMenuBar,
56790 _swigc__p_wxMenuBarBase,
56791 _swigc__p_wxMenuEvent,
56792 _swigc__p_wxMenuItem,
56793 _swigc__p_wxMouseCaptureChangedEvent,
56794 _swigc__p_wxMouseCaptureLostEvent,
56795 _swigc__p_wxMouseEvent,
56796 _swigc__p_wxMoveEvent,
56797 _swigc__p_wxNavigationKeyEvent,
56798 _swigc__p_wxNcPaintEvent,
56799 _swigc__p_wxNotifyEvent,
56800 _swigc__p_wxObject,
56801 _swigc__p_wxOutputStream,
56802 _swigc__p_wxPCXHandler,
56803 _swigc__p_wxPNGHandler,
56804 _swigc__p_wxPNMHandler,
56805 _swigc__p_wxPaintEvent,
56806 _swigc__p_wxPaletteChangedEvent,
56807 _swigc__p_wxPaperSize,
56808 _swigc__p_wxPoint,
56809 _swigc__p_wxPoint2D,
56810 _swigc__p_wxPropagateOnce,
56811 _swigc__p_wxPropagationDisabler,
56812 _swigc__p_wxPyApp,
56813 _swigc__p_wxPyCommandEvent,
56814 _swigc__p_wxPyDropTarget,
56815 _swigc__p_wxPyEvent,
56816 _swigc__p_wxPyFileSystemHandler,
56817 _swigc__p_wxPyImageHandler,
56818 _swigc__p_wxPyInputStream,
56819 _swigc__p_wxPySizer,
56820 _swigc__p_wxPyValidator,
56821 _swigc__p_wxQuantize,
56822 _swigc__p_wxQueryNewPaletteEvent,
56823 _swigc__p_wxRealPoint,
56824 _swigc__p_wxRect,
56825 _swigc__p_wxRegion,
56826 _swigc__p_wxScrollEvent,
56827 _swigc__p_wxScrollWinEvent,
56828 _swigc__p_wxSetCursorEvent,
56829 _swigc__p_wxShowEvent,
56830 _swigc__p_wxSize,
56831 _swigc__p_wxSizeEvent,
56832 _swigc__p_wxSizer,
56833 _swigc__p_wxSizerItem,
56834 _swigc__p_wxStaticBox,
56835 _swigc__p_wxStaticBoxSizer,
56836 _swigc__p_wxStdDialogButtonSizer,
56837 _swigc__p_wxSysColourChangedEvent,
56838 _swigc__p_wxTIFFHandler,
56839 _swigc__p_wxToolTip,
56840 _swigc__p_wxUpdateUIEvent,
56841 _swigc__p_wxValidator,
56842 _swigc__p_wxVisualAttributes,
56843 _swigc__p_wxWindow,
56844 _swigc__p_wxWindowCreateEvent,
56845 _swigc__p_wxWindowDestroyEvent,
56846 _swigc__p_wxXPMHandler,
56847 _swigc__p_wxZipFSHandler,
56848 };
56849
56850
56851 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56852
56853 static swig_const_info swig_const_table[] = {
56854 {0, 0, 0, 0.0, 0, 0}};
56855
56856 #ifdef __cplusplus
56857 }
56858 #endif
56859 /* -----------------------------------------------------------------------------
56860 * Type initialization:
56861 * This problem is tough by the requirement that no dynamic
56862 * memory is used. Also, since swig_type_info structures store pointers to
56863 * swig_cast_info structures and swig_cast_info structures store pointers back
56864 * to swig_type_info structures, we need some lookup code at initialization.
56865 * The idea is that swig generates all the structures that are needed.
56866 * The runtime then collects these partially filled structures.
56867 * The SWIG_InitializeModule function takes these initial arrays out of
56868 * swig_module, and does all the lookup, filling in the swig_module.types
56869 * array with the correct data and linking the correct swig_cast_info
56870 * structures together.
56871 *
56872 * The generated swig_type_info structures are assigned staticly to an initial
56873 * array. We just loop though that array, and handle each type individually.
56874 * First we lookup if this type has been already loaded, and if so, use the
56875 * loaded structure instead of the generated one. Then we have to fill in the
56876 * cast linked list. The cast data is initially stored in something like a
56877 * two-dimensional array. Each row corresponds to a type (there are the same
56878 * number of rows as there are in the swig_type_initial array). Each entry in
56879 * a column is one of the swig_cast_info structures for that type.
56880 * The cast_initial array is actually an array of arrays, because each row has
56881 * a variable number of columns. So to actually build the cast linked list,
56882 * we find the array of casts associated with the type, and loop through it
56883 * adding the casts to the list. The one last trick we need to do is making
56884 * sure the type pointer in the swig_cast_info struct is correct.
56885 *
56886 * First off, we lookup the cast->type name to see if it is already loaded.
56887 * There are three cases to handle:
56888 * 1) If the cast->type has already been loaded AND the type we are adding
56889 * casting info to has not been loaded (it is in this module), THEN we
56890 * replace the cast->type pointer with the type pointer that has already
56891 * been loaded.
56892 * 2) If BOTH types (the one we are adding casting info to, and the
56893 * cast->type) are loaded, THEN the cast info has already been loaded by
56894 * the previous module so we just ignore it.
56895 * 3) Finally, if cast->type has not already been loaded, then we add that
56896 * swig_cast_info to the linked list (because the cast->type) pointer will
56897 * be correct.
56898 * ----------------------------------------------------------------------------- */
56899
56900 #ifdef __cplusplus
56901 extern "C" {
56902 #if 0
56903 } /* c-mode */
56904 #endif
56905 #endif
56906
56907 #if 0
56908 #define SWIGRUNTIME_DEBUG
56909 #endif
56910
56911 SWIGRUNTIME void
56912 SWIG_InitializeModule(void *clientdata) {
56913 size_t i;
56914 swig_module_info *module_head;
56915 static int init_run = 0;
56916
56917 clientdata = clientdata;
56918
56919 if (init_run) return;
56920 init_run = 1;
56921
56922 /* Initialize the swig_module */
56923 swig_module.type_initial = swig_type_initial;
56924 swig_module.cast_initial = swig_cast_initial;
56925
56926 /* Try and load any already created modules */
56927 module_head = SWIG_GetModule(clientdata);
56928 if (module_head) {
56929 swig_module.next = module_head->next;
56930 module_head->next = &swig_module;
56931 } else {
56932 /* This is the first module loaded */
56933 swig_module.next = &swig_module;
56934 SWIG_SetModule(clientdata, &swig_module);
56935 }
56936
56937 /* Now work on filling in swig_module.types */
56938 #ifdef SWIGRUNTIME_DEBUG
56939 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56940 #endif
56941 for (i = 0; i < swig_module.size; ++i) {
56942 swig_type_info *type = 0;
56943 swig_type_info *ret;
56944 swig_cast_info *cast;
56945
56946 #ifdef SWIGRUNTIME_DEBUG
56947 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56948 #endif
56949
56950 /* if there is another module already loaded */
56951 if (swig_module.next != &swig_module) {
56952 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56953 }
56954 if (type) {
56955 /* Overwrite clientdata field */
56956 #ifdef SWIGRUNTIME_DEBUG
56957 printf("SWIG_InitializeModule: found type %s\n", type->name);
56958 #endif
56959 if (swig_module.type_initial[i]->clientdata) {
56960 type->clientdata = swig_module.type_initial[i]->clientdata;
56961 #ifdef SWIGRUNTIME_DEBUG
56962 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56963 #endif
56964 }
56965 } else {
56966 type = swig_module.type_initial[i];
56967 }
56968
56969 /* Insert casting types */
56970 cast = swig_module.cast_initial[i];
56971 while (cast->type) {
56972 /* Don't need to add information already in the list */
56973 ret = 0;
56974 #ifdef SWIGRUNTIME_DEBUG
56975 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56976 #endif
56977 if (swig_module.next != &swig_module) {
56978 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56979 #ifdef SWIGRUNTIME_DEBUG
56980 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56981 #endif
56982 }
56983 if (ret) {
56984 if (type == swig_module.type_initial[i]) {
56985 #ifdef SWIGRUNTIME_DEBUG
56986 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56987 #endif
56988 cast->type = ret;
56989 ret = 0;
56990 } else {
56991 /* Check for casting already in the list */
56992 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56993 #ifdef SWIGRUNTIME_DEBUG
56994 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56995 #endif
56996 if (!ocast) ret = 0;
56997 }
56998 }
56999
57000 if (!ret) {
57001 #ifdef SWIGRUNTIME_DEBUG
57002 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57003 #endif
57004 if (type->cast) {
57005 type->cast->prev = cast;
57006 cast->next = type->cast;
57007 }
57008 type->cast = cast;
57009 }
57010 cast++;
57011 }
57012 /* Set entry in modules->types array equal to the type */
57013 swig_module.types[i] = type;
57014 }
57015 swig_module.types[i] = 0;
57016
57017 #ifdef SWIGRUNTIME_DEBUG
57018 printf("**** SWIG_InitializeModule: Cast List ******\n");
57019 for (i = 0; i < swig_module.size; ++i) {
57020 int j = 0;
57021 swig_cast_info *cast = swig_module.cast_initial[i];
57022 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57023 while (cast->type) {
57024 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57025 cast++;
57026 ++j;
57027 }
57028 printf("---- Total casts: %d\n",j);
57029 }
57030 printf("**** SWIG_InitializeModule: Cast List ******\n");
57031 #endif
57032 }
57033
57034 /* This function will propagate the clientdata field of type to
57035 * any new swig_type_info structures that have been added into the list
57036 * of equivalent types. It is like calling
57037 * SWIG_TypeClientData(type, clientdata) a second time.
57038 */
57039 SWIGRUNTIME void
57040 SWIG_PropagateClientData(void) {
57041 size_t i;
57042 swig_cast_info *equiv;
57043 static int init_run = 0;
57044
57045 if (init_run) return;
57046 init_run = 1;
57047
57048 for (i = 0; i < swig_module.size; i++) {
57049 if (swig_module.types[i]->clientdata) {
57050 equiv = swig_module.types[i]->cast;
57051 while (equiv) {
57052 if (!equiv->converter) {
57053 if (equiv->type && !equiv->type->clientdata)
57054 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57055 }
57056 equiv = equiv->next;
57057 }
57058 }
57059 }
57060 }
57061
57062 #ifdef __cplusplus
57063 #if 0
57064 {
57065 /* c-mode */
57066 #endif
57067 }
57068 #endif
57069
57070
57071
57072 #ifdef __cplusplus
57073 extern "C" {
57074 #endif
57075
57076 /* Python-specific SWIG API */
57077 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57078 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57079 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57080
57081 /* -----------------------------------------------------------------------------
57082 * global variable support code.
57083 * ----------------------------------------------------------------------------- */
57084
57085 typedef struct swig_globalvar {
57086 char *name; /* Name of global variable */
57087 PyObject *(*get_attr)(void); /* Return the current value */
57088 int (*set_attr)(PyObject *); /* Set the value */
57089 struct swig_globalvar *next;
57090 } swig_globalvar;
57091
57092 typedef struct swig_varlinkobject {
57093 PyObject_HEAD
57094 swig_globalvar *vars;
57095 } swig_varlinkobject;
57096
57097 SWIGINTERN PyObject *
57098 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57099 return PyString_FromString("<Swig global variables>");
57100 }
57101
57102 SWIGINTERN PyObject *
57103 swig_varlink_str(swig_varlinkobject *v) {
57104 PyObject *str = PyString_FromString("(");
57105 swig_globalvar *var;
57106 for (var = v->vars; var; var=var->next) {
57107 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57108 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57109 }
57110 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57111 return str;
57112 }
57113
57114 SWIGINTERN int
57115 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57116 PyObject *str = swig_varlink_str(v);
57117 fprintf(fp,"Swig global variables ");
57118 fprintf(fp,"%s\n", PyString_AsString(str));
57119 Py_DECREF(str);
57120 return 0;
57121 }
57122
57123 SWIGINTERN void
57124 swig_varlink_dealloc(swig_varlinkobject *v) {
57125 swig_globalvar *var = v->vars;
57126 while (var) {
57127 swig_globalvar *n = var->next;
57128 free(var->name);
57129 free(var);
57130 var = n;
57131 }
57132 }
57133
57134 SWIGINTERN PyObject *
57135 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57136 PyObject *res = NULL;
57137 swig_globalvar *var = v->vars;
57138 while (var) {
57139 if (strcmp(var->name,n) == 0) {
57140 res = (*var->get_attr)();
57141 break;
57142 }
57143 var = var->next;
57144 }
57145 if (res == NULL && !PyErr_Occurred()) {
57146 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57147 }
57148 return res;
57149 }
57150
57151 SWIGINTERN int
57152 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57153 int res = 1;
57154 swig_globalvar *var = v->vars;
57155 while (var) {
57156 if (strcmp(var->name,n) == 0) {
57157 res = (*var->set_attr)(p);
57158 break;
57159 }
57160 var = var->next;
57161 }
57162 if (res == 1 && !PyErr_Occurred()) {
57163 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57164 }
57165 return res;
57166 }
57167
57168 SWIGINTERN PyTypeObject*
57169 swig_varlink_type(void) {
57170 static char varlink__doc__[] = "Swig var link object";
57171 static PyTypeObject varlink_type;
57172 static int type_init = 0;
57173 if (!type_init) {
57174 const PyTypeObject tmp
57175 = {
57176 PyObject_HEAD_INIT(NULL)
57177 0, /* Number of items in variable part (ob_size) */
57178 (char *)"swigvarlink", /* Type name (tp_name) */
57179 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57180 0, /* Itemsize (tp_itemsize) */
57181 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57182 (printfunc) swig_varlink_print, /* Print (tp_print) */
57183 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57184 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57185 0, /* tp_compare */
57186 (reprfunc) swig_varlink_repr, /* tp_repr */
57187 0, /* tp_as_number */
57188 0, /* tp_as_sequence */
57189 0, /* tp_as_mapping */
57190 0, /* tp_hash */
57191 0, /* tp_call */
57192 (reprfunc)swig_varlink_str, /* tp_str */
57193 0, /* tp_getattro */
57194 0, /* tp_setattro */
57195 0, /* tp_as_buffer */
57196 0, /* tp_flags */
57197 varlink__doc__, /* tp_doc */
57198 0, /* tp_traverse */
57199 0, /* tp_clear */
57200 0, /* tp_richcompare */
57201 0, /* tp_weaklistoffset */
57202 #if PY_VERSION_HEX >= 0x02020000
57203 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57204 #endif
57205 #if PY_VERSION_HEX >= 0x02030000
57206 0, /* tp_del */
57207 #endif
57208 #ifdef COUNT_ALLOCS
57209 0,0,0,0 /* tp_alloc -> tp_next */
57210 #endif
57211 };
57212 varlink_type = tmp;
57213 varlink_type.ob_type = &PyType_Type;
57214 type_init = 1;
57215 }
57216 return &varlink_type;
57217 }
57218
57219 /* Create a variable linking object for use later */
57220 SWIGINTERN PyObject *
57221 SWIG_Python_newvarlink(void) {
57222 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57223 if (result) {
57224 result->vars = 0;
57225 }
57226 return ((PyObject*) result);
57227 }
57228
57229 SWIGINTERN void
57230 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57231 swig_varlinkobject *v = (swig_varlinkobject *) p;
57232 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57233 if (gv) {
57234 size_t size = strlen(name)+1;
57235 gv->name = (char *)malloc(size);
57236 if (gv->name) {
57237 strncpy(gv->name,name,size);
57238 gv->get_attr = get_attr;
57239 gv->set_attr = set_attr;
57240 gv->next = v->vars;
57241 }
57242 }
57243 v->vars = gv;
57244 }
57245
57246 SWIGINTERN PyObject *
57247 SWIG_globals() {
57248 static PyObject *_SWIG_globals = 0;
57249 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57250 return _SWIG_globals;
57251 }
57252
57253 /* -----------------------------------------------------------------------------
57254 * constants/methods manipulation
57255 * ----------------------------------------------------------------------------- */
57256
57257 /* Install Constants */
57258 SWIGINTERN void
57259 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57260 PyObject *obj = 0;
57261 size_t i;
57262 for (i = 0; constants[i].type; ++i) {
57263 switch(constants[i].type) {
57264 case SWIG_PY_POINTER:
57265 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57266 break;
57267 case SWIG_PY_BINARY:
57268 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57269 break;
57270 default:
57271 obj = 0;
57272 break;
57273 }
57274 if (obj) {
57275 PyDict_SetItemString(d, constants[i].name, obj);
57276 Py_DECREF(obj);
57277 }
57278 }
57279 }
57280
57281 /* -----------------------------------------------------------------------------*/
57282 /* Fix SwigMethods to carry the callback ptrs when needed */
57283 /* -----------------------------------------------------------------------------*/
57284
57285 SWIGINTERN void
57286 SWIG_Python_FixMethods(PyMethodDef *methods,
57287 swig_const_info *const_table,
57288 swig_type_info **types,
57289 swig_type_info **types_initial) {
57290 size_t i;
57291 for (i = 0; methods[i].ml_name; ++i) {
57292 const char *c = methods[i].ml_doc;
57293 if (c && (c = strstr(c, "swig_ptr: "))) {
57294 int j;
57295 swig_const_info *ci = 0;
57296 const char *name = c + 10;
57297 for (j = 0; const_table[j].type; ++j) {
57298 if (strncmp(const_table[j].name, name,
57299 strlen(const_table[j].name)) == 0) {
57300 ci = &(const_table[j]);
57301 break;
57302 }
57303 }
57304 if (ci) {
57305 size_t shift = (ci->ptype) - types;
57306 swig_type_info *ty = types_initial[shift];
57307 size_t ldoc = (c - methods[i].ml_doc);
57308 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57309 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57310 if (ndoc) {
57311 char *buff = ndoc;
57312 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57313 if (ptr) {
57314 strncpy(buff, methods[i].ml_doc, ldoc);
57315 buff += ldoc;
57316 strncpy(buff, "swig_ptr: ", 10);
57317 buff += 10;
57318 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57319 methods[i].ml_doc = ndoc;
57320 }
57321 }
57322 }
57323 }
57324 }
57325 }
57326
57327 #ifdef __cplusplus
57328 }
57329 #endif
57330
57331 /* -----------------------------------------------------------------------------*
57332 * Partial Init method
57333 * -----------------------------------------------------------------------------*/
57334
57335 #ifdef __cplusplus
57336 extern "C"
57337 #endif
57338 SWIGEXPORT void SWIG_init(void) {
57339 PyObject *m, *d;
57340
57341 /* Fix SwigMethods to carry the callback ptrs when needed */
57342 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57343
57344 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57345 d = PyModule_GetDict(m);
57346
57347 SWIG_InitializeModule(0);
57348 SWIG_InstallConstants(d,swig_const_table);
57349
57350
57351
57352 #ifndef wxPyUSE_EXPORT
57353 // Make our API structure a CObject so other modules can import it
57354 // from this module.
57355 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57356 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57357 Py_XDECREF(cobj);
57358 #endif
57359
57360 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57361 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57362 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57363 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57364 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57365 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57366 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57367 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57368 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57369 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57370 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57371 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57372 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57373 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57374 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57375 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57376 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57377 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57378 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57379 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57380 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57381 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57382 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57383 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57384 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57385 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57386 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57387 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57388 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57389 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57390 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57391 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57392 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57393 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57394 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57395 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57396 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57397 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57398 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57399 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57400 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57401 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57402 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57403 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57404 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57405 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57406 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57407 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57408 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57409 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57410 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57411 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57412 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57413 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57414 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57415 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57416 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57417 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57418 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57419 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57420 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57421 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57422 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57423 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57424 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57425 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57426 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57427 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57428 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57429 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57430 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57431 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57432 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57433 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57434 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57435 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57436 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57437 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57438 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57439 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57440 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57441 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57442 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57443 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57444 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57445 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57446 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57447 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57448 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57449 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57450 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57451 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57452 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57453 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57454 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57455 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57456 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57457 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57458 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57459 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57460 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57461 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57462 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57463 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57464 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57465 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57466 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57467 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57468 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57469 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57470 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57471 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57472 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57473 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57474 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57475 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57476 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57477 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57478 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57479 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57480 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57481 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57482 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57483 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57484 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57485 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57486 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57487 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57488 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57489 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57490 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57491 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57492 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57493 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57494 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57495 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57496 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57497 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57498 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57499 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57500 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57501 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57502 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57503 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57504 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57505 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57506 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57507 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57508 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57509 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57510 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57511 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57512 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57513 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57514 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57515 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57516 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57517 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57518 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57519 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57520 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57521 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57522 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57523 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57524 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57525 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57526 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57527 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57528 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57529 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57530 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57531 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57532 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57533 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57534 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57535 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57536 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57537 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57538 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57539 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57540 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57541 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57542 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57543 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57544 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57545 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57546 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57547 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57548 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57549 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57550 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57551 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57552 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57553 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57554 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57555 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57556 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57557 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57558 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57559 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57560 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57561 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57562 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57563 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57564 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57565 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57566 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57567 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57568 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57569 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57570 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57571 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57572 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57573 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57574 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57575 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57576 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57577 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57578 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57579 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57580 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57581 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57582 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57583 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57584 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57585 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57586 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57587 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57588 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57589 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57590 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57591 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57592 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57593 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57594 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57595 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57596 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57597 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57598 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57599 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57600 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57601 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57602 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57603 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57604 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57605 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57606 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57607 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57608 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57609 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57610 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57611 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57612 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57613 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57614 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57615 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57616 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57617 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57618 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57619 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57620 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57621 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57622 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57623 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57624 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57625 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57626 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57627 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57628 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57629 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57630 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57631 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57632 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57633 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57634 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57635 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57636 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57637 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57638 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57639 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57640 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57641 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57642 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57643 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57644 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57645 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57646 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57647 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57648 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57649 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57650 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57651 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57652 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57653 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57654 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57655 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57656 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57657 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57658 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57659 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57660 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57661 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57662 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57663 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57664 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57665 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57666 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57667 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57668 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57669 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57670 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57671 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57672 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57673 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57674 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57675 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57676 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57677 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57678 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57679 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57680 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57681 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57682 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57683 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57684 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57685 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57686 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57687 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57688 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57689 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57690 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57691 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57692 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57693 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57694 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57695 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57696 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57697 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57698 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57699 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57700 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57701 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57702 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57703 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57704 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57705 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57706 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57707 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57708 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57709 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57710 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57711 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57712 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57713 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57714 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57715 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57716 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57717 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57718 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57719 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57720 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57721 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57722 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57723 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57724 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57725 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57726 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57727 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57728 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57729 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57730 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57731 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57732 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57733 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57734 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57735 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57736 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57737 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57738 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57739 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57740 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57741 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57742 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57743 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57744 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57745 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57746 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57747 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57748 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57749 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57750 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57751 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57752 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57753 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57754 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57755 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57756 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57757 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57758 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57759 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57781 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57782 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57783 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57784 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57785 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57786 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57787 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57788 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57789 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57790 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57791 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57792 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57793 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57794 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57795 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57796 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57797 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57798 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57799 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57800 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57801 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57802 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57803 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57804 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57805 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57806 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57807 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57808 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57809 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57810 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57811 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57812 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57813 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57814 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57815 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57816 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57817 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57818 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57819 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57820 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57821 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57822 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57823 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57824 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57825 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57826 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57827 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57828 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57829 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57830 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57831 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57832 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57833 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57834 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57835 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57836 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57837 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57838 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57839 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57840 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57841 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57842 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57843 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57844 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57845 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57846 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57847 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57848 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57849 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57850 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57851 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57852 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57853 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57854 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57855 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57856 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57857 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57858 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57859 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57860 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57861 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57862 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57863 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57864 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57865 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57866 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57867 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57868 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57869 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57870 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57871 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57872 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57873 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57874 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57875 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57876 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57877 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57878 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57879 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57880 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57881 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57882 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57883 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57884 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57885 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57886 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57887 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57888 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57889 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57890 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57891 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57892 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57893 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57894 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57895 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57896 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57897 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57898 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57899 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57900 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57901 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57902 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57903 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57904 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57905 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57906 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57907 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57908 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57909 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57910 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57911 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57912 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57913 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57914 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57915 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57918 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57921 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57922 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57923 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57924 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57925 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57926 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57927 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57928 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57929 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57930 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57931 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57932 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57933 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57934 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57935 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57936 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57939 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57940 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57941 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57942 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57943 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57944 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57945 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57946 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57947 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57948 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57949 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57950 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57951 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57952 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57953 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57954 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57955 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57956 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57957 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57958 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57959 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57960 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57961 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57962 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57963 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57964 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57965 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57966 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57967 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57968 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57982 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57983 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57984 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57985 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57986 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57987 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57988 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57989 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57990 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57991 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57992 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57993 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57994 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57995 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57996 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57997 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57998 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57999 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58000 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58001 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58002 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58003 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58004 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58005 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58006 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58007 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58008 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58009 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58010 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58011 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58012 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58013 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58014 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58015 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58016 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58017 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58018 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58019
58020 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58021
58022
58023 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58024
58025 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58026 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58027 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58028 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58029 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58030 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58031 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58032 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58033 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58034 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58035 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58036 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58037 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58038 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58039 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58040 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58041 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58045 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58046 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58047 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58048 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58049 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58050 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58051 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58052 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58053 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58054 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58055 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58056 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58057 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58058 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58059 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58060 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58061 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58062 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58063 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58064 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58065 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58066 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58067 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58068 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58069 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58070 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58071 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58072 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58073 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58074 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58075 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58076 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58077 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58078 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58079 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58080 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58081 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58082 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58083 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58084 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58085 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58086 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58087 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58088 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58089 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58090 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58091 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58092 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58093 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58094 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58095 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58096 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58097 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58098 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58099 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58100 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58101 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58102 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58103 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58104 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58105 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58106 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58107 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58108 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58109 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58110 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58111 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58112 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58113 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58114 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58115 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58116 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58117 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58118 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58119 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58120 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58121 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58122 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58123 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58124 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58125 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58126 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58127 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58128 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58129 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58130 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58131 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58132 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58133 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58134 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58135 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58136 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58137 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58138 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58139 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58140 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58141 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58142 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58143 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58144 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58145 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58146 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58147 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58148 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58149 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58150 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58151 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58152 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58153 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58154 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58155 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58156 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58157 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58158 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58159 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58160 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58161 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58162 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58163 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58164 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58165 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58166 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58167 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58168 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58169 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58170 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58171 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58172 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58173 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58174 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58175 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58176 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58177 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58178 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58179 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58180 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58181 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58182 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58183 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58184 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58185 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58186 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58187 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58188 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58189 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58190 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58191 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58192 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58193 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58194 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58195 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58196 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58197 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58198 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58199 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58200 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58201 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58202 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58203 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58204 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58205 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58206 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58207 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58208 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58209 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58210 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58211 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58212 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58213 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58214 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58215 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58216 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58217 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58218 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58219 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58220 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58221 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58222 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58223 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58224 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58225 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58226 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58227 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58228 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58229 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58230 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58231 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58232 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58233 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58234 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58235 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58236 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58237 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58238 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58239
58240 // Initialize threading, some globals and such
58241 __wxPyPreStart(d);
58242
58243
58244 // Although these are defined in __version__ they need to be here too so
58245 // that an assert can be done to ensure that the wxPython and the wxWindows
58246 // versions match.
58247 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58248 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58249 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58250
58251 }
58252
wxWidgets (Impactor)