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


c989d797c7cc0f88f6b06d0ea61d070c40ec46ab
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTIFFHandler swig_types[124]
2591 #define SWIGTYPE_p_wxToolTip swig_types[125]
2592 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[126]
2593 #define SWIGTYPE_p_wxValidator swig_types[127]
2594 #define SWIGTYPE_p_wxVisualAttributes swig_types[128]
2595 #define SWIGTYPE_p_wxWindow swig_types[129]
2596 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[130]
2597 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[131]
2598 #define SWIGTYPE_p_wxXPMHandler swig_types[132]
2599 #define SWIGTYPE_p_wxZipFSHandler swig_types[133]
2600 static swig_type_info *swig_types[135];
2601 static swig_module_info swig_module = {swig_types, 134, 0, 0, 0, 0};
2602 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2603 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2604
2605 /* -------- TYPES TABLE (END) -------- */
2606
2607 #if (PY_VERSION_HEX <= 0x02000000)
2608 # if !defined(SWIG_PYTHON_CLASSIC)
2609 # error "This python version requires to use swig with the '-classic' option"
2610 # endif
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodern' option"
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodernargs' option"
2617 #endif
2618 #ifndef METH_O
2619 # error "This python version requires to use swig with the '-nofastunpack' option"
2620 #endif
2621
2622 /*-----------------------------------------------
2623 @(target):= _core_.so
2624 ------------------------------------------------*/
2625 #define SWIG_init init_core_
2626
2627 #define SWIG_name "_core_"
2628
2629 #define SWIGVERSION 0x010329
2630
2631
2632 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2633 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2634
2635
2636 #include <stdexcept>
2637
2638
2639 namespace swig {
2640 class PyObject_ptr {
2641 protected:
2642 PyObject *_obj;
2643
2644 public:
2645 PyObject_ptr() :_obj(0)
2646 {
2647 }
2648
2649 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2650 {
2651 Py_XINCREF(_obj);
2652 }
2653
2654 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2655 {
2656 if (initial_ref) Py_XINCREF(_obj);
2657 }
2658
2659 PyObject_ptr & operator=(const PyObject_ptr& item)
2660 {
2661 Py_XINCREF(item._obj);
2662 Py_XDECREF(_obj);
2663 _obj = item._obj;
2664 return *this;
2665 }
2666
2667 ~PyObject_ptr()
2668 {
2669 Py_XDECREF(_obj);
2670 }
2671
2672 operator PyObject *() const
2673 {
2674 return _obj;
2675 }
2676
2677 PyObject *operator->() const
2678 {
2679 return _obj;
2680 }
2681 };
2682 }
2683
2684
2685 namespace swig {
2686 struct PyObject_var : PyObject_ptr {
2687 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2688
2689 PyObject_var & operator = (PyObject* obj)
2690 {
2691 Py_XDECREF(_obj);
2692 _obj = obj;
2693 return *this;
2694 }
2695 };
2696 }
2697
2698
2699 #include "wx/wxPython/wxPython_int.h"
2700 #include "wx/wxPython/pyclasses.h"
2701 #include "wx/wxPython/twoitem.h"
2702
2703
2704 #ifndef wxPyUSE_EXPORT
2705 // Helper functions for dealing with SWIG objects and such. These are
2706 // located here so they know about the SWIG types and functions declared
2707 // in the wrapper code.
2708
2709 #include <wx/hashmap.h>
2710 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2711
2712
2713 // Maintains a hashmap of className to swig_type_info pointers. Given the
2714 // name of a class either looks up the type info in the cache, or scans the
2715 // SWIG tables for it.
2716 extern PyObject* wxPyPtrTypeMap;
2717 static
2718 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2719
2720 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2721
2722 if (typeInfoCache == NULL)
2723 typeInfoCache = new wxPyTypeInfoHashMap;
2724
2725 wxString name(className);
2726 swig_type_info* swigType = (*typeInfoCache)[name];
2727
2728 if (! swigType) {
2729 // it wasn't in the cache, so look it up from SWIG
2730 name.Append(wxT(" *"));
2731 swigType = SWIG_TypeQuery(name.mb_str());
2732
2733 // if it still wasn't found, try looking for a mapped name
2734 if (!swigType) {
2735 PyObject* item;
2736 name = className;
2737
2738 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2739 (char*)(const char*)name.mbc_str())) != NULL) {
2740 name = wxString(PyString_AsString(item), *wxConvCurrent);
2741 name.Append(wxT(" *"));
2742 swigType = SWIG_TypeQuery(name.mb_str());
2743 }
2744 }
2745 if (swigType) {
2746 // and add it to the map if found
2747 (*typeInfoCache)[className] = swigType;
2748 }
2749 }
2750 return swigType;
2751 }
2752
2753
2754 // Check if a class name is a type known to SWIG
2755 bool wxPyCheckSwigType(const wxChar* className) {
2756
2757 swig_type_info* swigType = wxPyFindSwigType(className);
2758 return swigType != NULL;
2759 }
2760
2761
2762 // Given a pointer to a C++ object and a class name, construct a Python proxy
2763 // object for it.
2764 PyObject* wxPyConstructObject(void* ptr,
2765 const wxChar* className,
2766 int setThisOwn) {
2767
2768 swig_type_info* swigType = wxPyFindSwigType(className);
2769 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2770
2771 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2772 }
2773
2774
2775 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2776 // Ensures that the proxy object is of the specified (or derived) type. If
2777 // not able to perform the conversion then a Python exception is set and the
2778 // error should be handled properly in the caller. Returns True on success.
2779 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2780 const wxChar* className) {
2781
2782 swig_type_info* swigType = wxPyFindSwigType(className);
2783 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2784
2785 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2786 }
2787
2788
2789
2790 // Make a SWIGified pointer object suitable for a .this attribute
2791 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2792
2793 PyObject* robj = NULL;
2794
2795 swig_type_info* swigType = wxPyFindSwigType(className);
2796 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2797
2798 robj = PySwigObject_New(ptr, swigType, 0);
2799 return robj;
2800 }
2801
2802
2803 // Python's PyInstance_Check does not return True for instances of new-style
2804 // classes. This should get close enough for both new and old classes but I
2805 // should re-evaluate the need for doing instance checks...
2806 bool wxPyInstance_Check(PyObject* obj) {
2807 return PyObject_HasAttrString(obj, "__class__") != 0;
2808 }
2809
2810
2811 // This one checks if the object is an instance of a SWIG proxy class (it has
2812 // a .this attribute, and the .this attribute is a PySwigObject.)
2813 bool wxPySwigInstance_Check(PyObject* obj) {
2814 static PyObject* this_str = NULL;
2815 if (this_str == NULL)
2816 this_str = PyString_FromString("this");
2817
2818 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2819 if (this_attr) {
2820 bool retval = (PySwigObject_Check(this_attr) != 0);
2821 Py_DECREF(this_attr);
2822 return retval;
2823 }
2824
2825 PyErr_Clear();
2826 return false;
2827 }
2828
2829
2830 // Export a C API in a struct. Other modules will be able to load this from
2831 // the wx._core_ module and will then have safe access to these functions,
2832 // even if they are located in another shared library.
2833 static wxPyCoreAPI API = {
2834
2835 wxPyCheckSwigType,
2836 wxPyConstructObject,
2837 wxPyConvertSwigPtr,
2838 wxPyMakeSwigPtr,
2839
2840 wxPyBeginAllowThreads,
2841 wxPyEndAllowThreads,
2842 wxPyBeginBlockThreads,
2843 wxPyEndBlockThreads,
2844
2845 wxPy_ConvertList,
2846
2847 wxString_in_helper,
2848 Py2wxString,
2849 wx2PyString,
2850
2851 byte_LIST_helper,
2852 int_LIST_helper,
2853 long_LIST_helper,
2854 string_LIST_helper,
2855 wxPoint_LIST_helper,
2856 wxBitmap_LIST_helper,
2857 wxString_LIST_helper,
2858 wxAcceleratorEntry_LIST_helper,
2859
2860 wxSize_helper,
2861 wxPoint_helper,
2862 wxRealPoint_helper,
2863 wxRect_helper,
2864 wxColour_helper,
2865 wxPoint2D_helper,
2866
2867 wxPySimple_typecheck,
2868 wxColour_typecheck,
2869
2870 wxPyCBH_setCallbackInfo,
2871 wxPyCBH_findCallback,
2872 wxPyCBH_callCallback,
2873 wxPyCBH_callCallbackObj,
2874 wxPyCBH_delete,
2875
2876 wxPyMake_wxObject,
2877 wxPyMake_wxSizer,
2878 wxPyPtrTypeMap_Add,
2879 wxPy2int_seq_helper,
2880 wxPy4int_seq_helper,
2881 wxArrayString2PyList_helper,
2882 wxArrayInt2PyList_helper,
2883
2884 wxPyClientData_dtor,
2885 wxPyUserData_dtor,
2886 wxPyOORClientData_dtor,
2887
2888 wxPyCBInputStream_create,
2889 wxPyCBInputStream_copy,
2890
2891 wxPyInstance_Check,
2892 wxPySwigInstance_Check,
2893
2894 wxPyCheckForApp,
2895
2896 wxArrayDouble2PyList_helper,
2897 wxPoint2D_LIST_helper,
2898 wxRect2D_helper,
2899
2900 };
2901
2902 #endif
2903
2904
2905 #if !WXWIN_COMPATIBILITY_2_4
2906 #define wxHIDE_READONLY 0
2907 #endif
2908
2909
2910 #define SWIG_From_long PyInt_FromLong
2911
2912
2913 SWIGINTERNINLINE PyObject *
2914 SWIG_From_int (int value)
2915 {
2916 return SWIG_From_long (value);
2917 }
2918
2919 static const wxString wxPyEmptyString(wxEmptyString);
2920 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2921 return self->GetClassInfo()->GetClassName();
2922 }
2923 SWIGINTERN void wxObject_Destroy(wxObject *self){
2924 delete self;
2925 }
2926
2927 #ifndef __WXMAC__
2928 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2929 #endif
2930
2931
2932 #include <limits.h>
2933 #ifndef LLONG_MIN
2934 # define LLONG_MIN LONG_LONG_MIN
2935 #endif
2936 #ifndef LLONG_MAX
2937 # define LLONG_MAX LONG_LONG_MAX
2938 #endif
2939 #ifndef ULLONG_MAX
2940 # define ULLONG_MAX ULONG_LONG_MAX
2941 #endif
2942
2943
2944 SWIGINTERN int
2945 SWIG_AsVal_long (PyObject* obj, long* val)
2946 {
2947 if (PyNumber_Check(obj)) {
2948 if (val) *val = PyInt_AsLong(obj);
2949 return SWIG_OK;
2950 }
2951 return SWIG_TypeError;
2952 }
2953
2954
2955 SWIGINTERN int
2956 SWIG_AsVal_int (PyObject * obj, int *val)
2957 {
2958 long v;
2959 int res = SWIG_AsVal_long (obj, &v);
2960 if (SWIG_IsOK(res)) {
2961 if ((v < INT_MIN || v > INT_MAX)) {
2962 return SWIG_OverflowError;
2963 } else {
2964 if (val) *val = static_cast< int >(v);
2965 }
2966 }
2967 return res;
2968 }
2969
2970 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2971 wxSize temp, *obj = &temp;
2972 if ( other == Py_None ) return false;
2973 if ( ! wxSize_helper(other, &obj) ) {
2974 PyErr_Clear();
2975 return false;
2976 }
2977 return self->operator==(*obj);
2978 }
2979 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2980 wxSize temp, *obj = &temp;
2981 if ( other == Py_None ) return true;
2982 if ( ! wxSize_helper(other, &obj)) {
2983 PyErr_Clear();
2984 return true;
2985 }
2986 return self->operator!=(*obj);
2987 }
2988
2989 #include <float.h>
2990
2991
2992 SWIGINTERN int
2993 SWIG_AsVal_double (PyObject *obj, double* val)
2994 {
2995 if (PyNumber_Check(obj)) {
2996 if (val) *val = PyFloat_AsDouble(obj);
2997 return SWIG_OK;
2998 }
2999 return SWIG_TypeError;
3000 }
3001
3002
3003 SWIGINTERN int
3004 SWIG_AsVal_float (PyObject * obj, float *val)
3005 {
3006 double v;
3007 int res = SWIG_AsVal_double (obj, &v);
3008 if (SWIG_IsOK(res)) {
3009 if ((v < -FLT_MAX || v > FLT_MAX)) {
3010 return SWIG_OverflowError;
3011 } else {
3012 if (val) *val = static_cast< float >(v);
3013 }
3014 }
3015 return res;
3016 }
3017
3018 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3019 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3023 //wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026
3027 #define SWIG_From_double PyFloat_FromDouble
3028
3029 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3030 wxRealPoint temp, *obj = &temp;
3031 if ( other == Py_None ) return false;
3032 if ( ! wxRealPoint_helper(other, &obj) ) {
3033 PyErr_Clear();
3034 return false;
3035 }
3036 return self->operator==(*obj);
3037 }
3038 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3039 wxRealPoint temp, *obj = &temp;
3040 if ( other == Py_None ) return true;
3041 if ( ! wxRealPoint_helper(other, &obj)) {
3042 PyErr_Clear();
3043 return true;
3044 }
3045 return self->operator!=(*obj);
3046 }
3047 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3048 self->x = x;
3049 self->y = y;
3050 }
3051 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3052 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3053 PyObject* tup = PyTuple_New(2);
3054 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3055 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3056 //PyEndBlockThreads(blocked);
3057 return tup;
3058 }
3059 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3060 wxPoint temp, *obj = &temp;
3061 if ( other == Py_None ) return false;
3062 if ( ! wxPoint_helper(other, &obj) ) {
3063 PyErr_Clear();
3064 return false;
3065 }
3066 return self->operator==(*obj);
3067 }
3068 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3069 wxPoint temp, *obj = &temp;
3070 if ( other == Py_None ) return true;
3071 if ( ! wxPoint_helper(other, &obj)) {
3072 PyErr_Clear();
3073 return true;
3074 }
3075 return self->operator!=(*obj);
3076 }
3077 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3078 self->x = x;
3079 self->y = y;
3080 }
3081 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3082 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 PyObject* tup = PyTuple_New(2);
3084 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3085 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3086 //wxPyEndBlockThreads(blocked);
3087 return tup;
3088 }
3089 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3090 wxRect temp, *obj = &temp;
3091 if ( other == Py_None ) return false;
3092 if ( ! wxRect_helper(other, &obj) ) {
3093 PyErr_Clear();
3094 return false;
3095 }
3096 return self->operator==(*obj);
3097 }
3098 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3099 wxRect temp, *obj = &temp;
3100 if ( other == Py_None ) return true;
3101 if ( ! wxRect_helper(other, &obj)) {
3102 PyErr_Clear();
3103 return true;
3104 }
3105 return self->operator!=(*obj);
3106 }
3107 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3108 self->x = x;
3109 self->y = y;
3110 self->width = width;
3111 self->height = height;
3112 }
3113 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3114 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3115 PyObject* tup = PyTuple_New(4);
3116 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3117 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3118 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3119 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3120 //wxPyEndBlockThreads(blocked);
3121 return tup;
3122 }
3123
3124 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3125 wxRegion reg1(*r1);
3126 wxRegion reg2(*r2);
3127 wxRect dest(0,0,0,0);
3128 PyObject* obj;
3129
3130 reg1.Intersect(reg2);
3131 dest = reg1.GetBox();
3132
3133 if (dest != wxRect(0,0,0,0)) {
3134 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 wxRect* newRect = new wxRect(dest);
3136 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3137 //wxPyEndBlockThreads(blocked);
3138 return obj;
3139 }
3140 Py_INCREF(Py_None);
3141 return Py_None;
3142 }
3143
3144 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3145 wxPoint2D temp, *obj = &temp;
3146 if ( other == Py_None ) return false;
3147 if ( ! wxPoint2D_helper(other, &obj) ) {
3148 PyErr_Clear();
3149 return false;
3150 }
3151 return self->operator==(*obj);
3152 }
3153 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3154 wxPoint2D temp, *obj = &temp;
3155 if ( other == Py_None ) return true;
3156 if ( ! wxPoint2D_helper(other, &obj)) {
3157 PyErr_Clear();
3158 return true;
3159 }
3160 return self->operator!=(*obj);
3161 }
3162 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3163 self->m_x = x;
3164 self->m_y = y;
3165 }
3166 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3167 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3168 PyObject* tup = PyTuple_New(2);
3169 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3170 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3171 //wxPyEndBlockThreads(blocked);
3172 return tup;
3173 }
3174 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3175 wxRect2D temp, *obj = &temp;
3176 if ( other == Py_None ) return false;
3177 if ( ! wxRect2D_helper(other, &obj) ) {
3178 PyErr_Clear();
3179 return false;
3180 }
3181 return self->operator==(*obj);
3182 }
3183 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3184 wxRect2D temp, *obj = &temp;
3185 if ( other == Py_None ) return true;
3186 if ( ! wxRect2D_helper(other, &obj)) {
3187 PyErr_Clear();
3188 return true;
3189 }
3190 return self->operator!=(*obj);
3191 }
3192 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3193 self->m_x = x;
3194 self->m_y = y;
3195 self->m_width = width;
3196 self->m_height = height;
3197 }
3198 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3199 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 PyObject* tup = PyTuple_New(4);
3201 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3202 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3203 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3204 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3205 //wxPyEndBlockThreads(blocked);
3206 return tup;
3207 }
3208
3209 #include "wx/wxPython/pyistream.h"
3210
3211 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3212 wxInputStream* wxis = wxPyCBInputStream::create(p);
3213 if (wxis)
3214 return new wxPyInputStream(wxis);
3215 else
3216 return NULL;
3217 }
3218
3219 SWIGINTERN swig_type_info*
3220 SWIG_pchar_descriptor()
3221 {
3222 static int init = 0;
3223 static swig_type_info* info = 0;
3224 if (!init) {
3225 info = SWIG_TypeQuery("_p_char");
3226 init = 1;
3227 }
3228 return info;
3229 }
3230
3231
3232 SWIGINTERNINLINE PyObject *
3233 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3234 {
3235 if (carray) {
3236 if (size > INT_MAX) {
3237 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3238 return pchar_descriptor ?
3239 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3240 } else {
3241 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3242 }
3243 } else {
3244 return SWIG_Py_Void();
3245 }
3246 }
3247
3248
3249 SWIGINTERNINLINE PyObject *
3250 SWIG_From_char (char c)
3251 {
3252 return SWIG_FromCharPtrAndSize(&c,1);
3253 }
3254
3255
3256 SWIGINTERNINLINE PyObject*
3257 SWIG_From_unsigned_SS_long (unsigned long value)
3258 {
3259 return (value > LONG_MAX) ?
3260 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3261 }
3262
3263
3264 SWIGINTERNINLINE PyObject *
3265 SWIG_From_size_t (size_t value)
3266 {
3267 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3268 }
3269
3270
3271 SWIGINTERN int
3272 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3273 {
3274 if (PyString_Check(obj)) {
3275 char *cstr; Py_ssize_t len;
3276 PyString_AsStringAndSize(obj, &cstr, &len);
3277 if (cptr) {
3278 if (alloc) {
3279 /*
3280 In python the user should not be able to modify the inner
3281 string representation. To warranty that, if you define
3282 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3283 buffer is always returned.
3284
3285 The default behavior is just to return the pointer value,
3286 so, be careful.
3287 */
3288 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3289 if (*alloc != SWIG_OLDOBJ)
3290 #else
3291 if (*alloc == SWIG_NEWOBJ)
3292 #endif
3293 {
3294 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3295 *alloc = SWIG_NEWOBJ;
3296 }
3297 else {
3298 *cptr = cstr;
3299 *alloc = SWIG_OLDOBJ;
3300 }
3301 } else {
3302 *cptr = PyString_AsString(obj);
3303 }
3304 }
3305 if (psize) *psize = len + 1;
3306 return SWIG_OK;
3307 } else {
3308 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3309 if (pchar_descriptor) {
3310 void* vptr = 0;
3311 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3312 if (cptr) *cptr = (char *) vptr;
3313 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3314 if (alloc) *alloc = SWIG_OLDOBJ;
3315 return SWIG_OK;
3316 }
3317 }
3318 }
3319 return SWIG_TypeError;
3320 }
3321
3322
3323 SWIGINTERN int
3324 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3325 {
3326 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3327 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3328 if (SWIG_IsOK(res)) {
3329 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3330 if (csize <= size) {
3331 if (val) {
3332 if (csize) memcpy(val, cptr, csize*sizeof(char));
3333 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3334 }
3335 if (alloc == SWIG_NEWOBJ) {
3336 delete[] cptr;
3337 res = SWIG_DelNewMask(res);
3338 }
3339 return res;
3340 }
3341 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3342 }
3343 return SWIG_TypeError;
3344 }
3345
3346
3347 SWIGINTERN int
3348 SWIG_AsVal_char (PyObject * obj, char *val)
3349 {
3350 int res = SWIG_AsCharArray(obj, val, 1);
3351 if (!SWIG_IsOK(res)) {
3352 long v;
3353 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3354 if (SWIG_IsOK(res)) {
3355 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3356 if (val) *val = static_cast< char >(v);
3357 } else {
3358 res = SWIG_OverflowError;
3359 }
3360 }
3361 }
3362 return res;
3363 }
3364
3365 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3366 // We use only strings for the streams, not unicode
3367 PyObject* str = PyObject_Str(obj);
3368 if (! str) {
3369 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3370 return;
3371 }
3372 self->Write(PyString_AS_STRING(str),
3373 PyString_GET_SIZE(str));
3374 Py_DECREF(str);
3375 }
3376
3377 #include "wx/wxPython/pyistream.h"
3378
3379
3380 class wxPyFileSystemHandler : public wxFileSystemHandler
3381 {
3382 public:
3383 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3384
3385 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3386 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3387 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3388 DEC_PYCALLBACK_STRING__pure(FindNext);
3389
3390 wxString GetProtocol(const wxString& location) {
3391 return wxFileSystemHandler::GetProtocol(location);
3392 }
3393
3394 wxString GetLeftLocation(const wxString& location) {
3395 return wxFileSystemHandler::GetLeftLocation(location);
3396 }
3397
3398 wxString GetAnchor(const wxString& location) {
3399 return wxFileSystemHandler::GetAnchor(location);
3400 }
3401
3402 wxString GetRightLocation(const wxString& location) {
3403 return wxFileSystemHandler::GetRightLocation(location);
3404 }
3405
3406 wxString GetMimeTypeFromExt(const wxString& location) {
3407 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3408 }
3409
3410 PYPRIVATE;
3411 };
3412
3413
3414 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3415 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3416 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3417 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_bool (PyObject *obj, bool *val)
3422 {
3423 if (obj == Py_True) {
3424 if (val) *val = true;
3425 return SWIG_OK;
3426 } else if (obj == Py_False) {
3427 if (val) *val = false;
3428 return SWIG_OK;
3429 } else {
3430 long v = 0;
3431 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3432 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3433 return res;
3434 }
3435 }
3436
3437 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3438 wxFileName fname = wxFileSystem::URLToFileName(url);
3439 return fname.GetFullPath();
3440 }
3441
3442 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3443 wxImage& image,
3444 long type) {
3445 wxMemoryFSHandler::AddFile(filename, image, type);
3446 }
3447
3448 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3449 const wxBitmap& bitmap,
3450 long type) {
3451 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3452 }
3453
3454 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3455 PyObject* data) {
3456 if (! PyString_Check(data)) {
3457 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3458 "Expected string object"));
3459 return;
3460 }
3461
3462 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3463 void* ptr = (void*)PyString_AsString(data);
3464 size_t size = PyString_Size(data);
3465 wxPyEndBlockThreads(blocked);
3466
3467 wxMemoryFSHandler::AddFile(filename, ptr, size);
3468 }
3469
3470
3471 #include "wx/wxPython/pyistream.h"
3472
3473
3474 SWIGINTERN int
3475 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3476 {
3477 long v = 0;
3478 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3479 return SWIG_TypeError;
3480 }
3481 else if (val)
3482 *val = (unsigned long)v;
3483 return SWIG_OK;
3484 }
3485
3486
3487 SWIGINTERN int
3488 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3489 {
3490 unsigned long v;
3491 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3492 if (SWIG_IsOK(res)) {
3493 if ((v > UCHAR_MAX)) {
3494 return SWIG_OverflowError;
3495 } else {
3496 if (val) *val = static_cast< unsigned char >(v);
3497 }
3498 }
3499 return res;
3500 }
3501
3502
3503 SWIGINTERNINLINE PyObject *
3504 SWIG_From_unsigned_SS_char (unsigned char value)
3505 {
3506 return SWIG_From_unsigned_SS_long (value);
3507 }
3508
3509 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3510 wxImageHistogramEntry e = (*self)[key];
3511 return e.value;
3512 }
3513 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3514 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3515 wxImageHistogramEntry e = (*self)[key];
3516 return e.value;
3517 }
3518 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3519 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3520 colour.Green(),
3521 colour.Blue());
3522 wxImageHistogramEntry e = (*self)[key];
3523 return e.value;
3524 }
3525
3526 // Pull the nested class out to the top level for SWIG's sake
3527 #define wxImage_RGBValue wxImage::RGBValue
3528 #define wxImage_HSVValue wxImage::HSVValue
3529
3530 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3531 if (width > 0 && height > 0)
3532 return new wxImage(width, height, clear);
3533 else
3534 return new wxImage;
3535 }
3536 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3537 return new wxImage(bitmap.ConvertToImage());
3538 }
3539 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3540 if (DATASIZE != width*height*3) {
3541 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3542 return NULL;
3543 }
3544
3545 // Copy the source data so the wxImage can clean it up later
3546 buffer copy = (buffer)malloc(DATASIZE);
3547 if (copy == NULL) {
3548 wxPyBLOCK_THREADS(PyErr_NoMemory());
3549 return NULL;
3550 }
3551 memcpy(copy, data, DATASIZE);
3552 return new wxImage(width, height, copy, false);
3553 }
3554 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3555 if (DATASIZE != width*height*3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return NULL;
3558 }
3559 if (ALPHASIZE != width*height) {
3560 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3561 return NULL;
3562 }
3563
3564 // Copy the source data so the wxImage can clean it up later
3565 buffer dcopy = (buffer)malloc(DATASIZE);
3566 if (dcopy == NULL) {
3567 wxPyBLOCK_THREADS(PyErr_NoMemory());
3568 return NULL;
3569 }
3570 memcpy(dcopy, data, DATASIZE);
3571
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return NULL;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578
3579 return new wxImage(width, height, dcopy, acopy, false);
3580 }
3581 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3582 wxSize size(self->GetWidth(), self->GetHeight());
3583 return size;
3584 }
3585 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3586 buffer data = self->GetData();
3587 int len = self->GetWidth() * self->GetHeight() * 3;
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3590 return rv;
3591 }
3592 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3593 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3595 return;
3596 }
3597 buffer copy = (buffer)malloc(DATASIZE);
3598 if (copy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(copy, data, DATASIZE);
3603 self->SetData(copy, false);
3604 // wxImage takes ownership of copy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3607 buffer data = self->GetData();
3608 int len = self->GetWidth() * self->GetHeight() * 3;
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3614 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3616 return;
3617 }
3618 self->SetData(data, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3621 buffer data = self->GetAlpha();
3622 if (! data) {
3623 RETURN_NONE();
3624 } else {
3625 int len = self->GetWidth() * self->GetHeight();
3626 PyObject* rv;
3627 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3628 return rv;
3629 }
3630 }
3631 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3632 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3633 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3634 return;
3635 }
3636 buffer acopy = (buffer)malloc(ALPHASIZE);
3637 if (acopy == NULL) {
3638 wxPyBLOCK_THREADS(PyErr_NoMemory());
3639 return;
3640 }
3641 memcpy(acopy, alpha, ALPHASIZE);
3642 self->SetAlpha(acopy, false);
3643 // wxImage takes ownership of acopy...
3644 }
3645 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3646 buffer data = self->GetAlpha();
3647 int len = self->GetWidth() * self->GetHeight();
3648 PyObject* rv;
3649 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3650 return rv;
3651 }
3652 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3653 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3654 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3655 return;
3656 }
3657 self->SetAlpha(alpha, true);
3658 }
3659 SWIGINTERN PyObject *wxImage_GetHandlers(){
3660 wxList& list = wxImage::GetHandlers();
3661 return wxPy_ConvertList(&list);
3662 }
3663 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3664 wxBitmap bitmap(*self, depth);
3665 return bitmap;
3666 }
3667 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3668 wxImage mono = self->ConvertToMono( red, green, blue );
3669 wxBitmap bitmap( mono, 1 );
3670 return bitmap;
3671 }
3672
3673 wxImage* _ImageFromBuffer(int width, int height,
3674 buffer data, int DATASIZE,
3675 buffer alpha=NULL, int ALPHASIZE=0)
3676 {
3677 if (DATASIZE != width*height*3) {
3678 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3679 return NULL;
3680 }
3681 if (alpha != NULL) {
3682 if (ALPHASIZE != width*height) {
3683 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3684 return NULL;
3685 }
3686 return new wxImage(width, height, data, alpha, true);
3687 }
3688 return new wxImage(width, height, data, true);
3689 }
3690
3691 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3692 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3693 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3695 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3699 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3700 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3701 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3702 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3703 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3704 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3705 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3706
3707 #include <wx/quantize.h>
3708
3709 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3710 return wxQuantize::Quantize(src, dest,
3711 //NULL, // palette
3712 desiredNoColours,
3713 NULL, // eightBitData
3714 flags);
3715 }
3716 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3717 if (PyCallable_Check(func)) {
3718 self->Connect(id, lastId, eventType,
3719 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3720 new wxPyCallback(func));
3721 }
3722 else if (func == Py_None) {
3723 self->Disconnect(id, lastId, eventType,
3724 (wxObjectEventFunction)
3725 &wxPyCallback::EventThunker);
3726 }
3727 else {
3728 wxPyBLOCK_THREADS(
3729 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3730 }
3731 }
3732 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3733 return self->Disconnect(id, lastId, eventType,
3734 (wxObjectEventFunction)
3735 &wxPyCallback::EventThunker);
3736 }
3737 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3738 if (_self && _self != Py_None) {
3739 self->SetClientObject(new wxPyOORClientData(_self, incref));
3740 }
3741 else {
3742 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3743 if (data) {
3744 self->SetClientObject(NULL); // This will delete it too
3745 }
3746 }
3747 }
3748
3749 #if ! wxUSE_HOTKEY
3750 #define wxEVT_HOTKEY -9999
3751 #endif
3752
3753 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3754 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3755 if (data) {
3756 Py_INCREF(data->m_obj);
3757 return data->m_obj;
3758 } else {
3759 Py_INCREF(Py_None);
3760 return Py_None;
3761 }
3762 }
3763 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3764 wxPyClientData* data = new wxPyClientData(clientData);
3765 self->SetClientObject(data);
3766 }
3767 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3768 #if wxUSE_UNICODE
3769 return self->GetUnicodeKey();
3770 #else
3771 return 0;
3772 #endif
3773 }
3774 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3775 #if wxUSE_UNICODE
3776 self->m_uniChar = uniChar;
3777 #endif
3778 }
3779
3780 SWIGINTERNINLINE PyObject *
3781 SWIG_From_unsigned_SS_int (unsigned int value)
3782 {
3783 return SWIG_From_unsigned_SS_long (value);
3784 }
3785
3786
3787 SWIGINTERN int
3788 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3789 {
3790 unsigned long v;
3791 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3792 if (SWIG_IsOK(res)) {
3793 if ((v > UINT_MAX)) {
3794 return SWIG_OverflowError;
3795 } else {
3796 if (val) *val = static_cast< unsigned int >(v);
3797 }
3798 }
3799 return res;
3800 }
3801
3802 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3803 self->m_size = size;
3804 }
3805 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3806 int count = self->GetNumberOfFiles();
3807 wxString* files = self->GetFiles();
3808 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3809 PyObject* list = PyList_New(count);
3810
3811 if (!list) {
3812 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3813 wxPyEndBlockThreads(blocked);
3814 return NULL;
3815 }
3816
3817 for (int i=0; i<count; i++) {
3818 PyList_SetItem(list, i, wx2PyString(files[i]));
3819 }
3820 wxPyEndBlockThreads(blocked);
3821 return list;
3822 }
3823
3824
3825 SWIGINTERN wxPyApp *new_wxPyApp(){
3826 wxPythonApp = new wxPyApp();
3827 return wxPythonApp;
3828 }
3829 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3830 return wxPyTestDisplayAvailable();
3831 }
3832
3833 void wxApp_CleanUp() {
3834 __wxPyCleanup();
3835 }
3836
3837
3838 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3839
3840
3841
3842
3843
3844 SWIGINTERNINLINE PyObject *
3845 SWIG_FromCharPtr(const char *cptr)
3846 {
3847 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3848 }
3849
3850
3851 #if 0 // #ifdef __WXMAC__
3852
3853 // A dummy class that raises an exception if used...
3854 class wxEventLoop
3855 {
3856 public:
3857 wxEventLoop() { wxPyRaiseNotImplemented(); }
3858 int Run() { return 0; }
3859 void Exit(int rc = 0) {}
3860 bool Pending() const { return false; }
3861 bool Dispatch() { return false; }
3862 bool IsRunning() const { return false; }
3863 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3864 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3865 };
3866
3867 #else
3868
3869 #include <wx/evtloop.h>
3870
3871 #endif
3872
3873
3874
3875 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3876 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3877 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3878 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3879 wxWindowList& list = self->GetChildren();
3880 return wxPy_ConvertList(&list);
3881 }
3882 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3883 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3884 #if wxUSE_HOTKEY
3885 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3886 #else
3887 return false;
3888 #endif
3889 }
3890 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3891
3892
3893
3894 return false;
3895
3896 }
3897 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3898 return wxPyGetWinHandle(self);
3899 }
3900 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3901 self->AssociateHandle((WXWidget)handle);
3902 }
3903
3904 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3905 return wxWindow::FindWindowById(id, parent);
3906 }
3907
3908 wxWindow* wxFindWindowByName( const wxString& name,
3909 const wxWindow *parent = NULL ) {
3910 return wxWindow::FindWindowByName(name, parent);
3911 }
3912
3913 wxWindow* wxFindWindowByLabel( const wxString& label,
3914 const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowByLabel(label, parent);
3916 }
3917
3918
3919 #ifdef __WXMSW__
3920 #include <wx/msw/private.h> // to get wxGetWindowId
3921 #endif
3922
3923
3924 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3925 #ifdef __WXMSW__
3926 WXHWND hWnd = (WXHWND)_hWnd;
3927 long id = wxGetWindowId(hWnd);
3928 wxWindow* win = new wxWindow;
3929 if (parent)
3930 parent->AddChild(win);
3931 win->SetEventHandler(win);
3932 win->SetHWND(hWnd);
3933 win->SetId(id);
3934 win->SubclassWin(hWnd);
3935 win->AdoptAttributesFromHWND();
3936 win->SetupColours();
3937 return win;
3938 #else
3939 wxPyRaiseNotImplemented();
3940 return NULL;
3941 #endif
3942 }
3943
3944
3945 PyObject* GetTopLevelWindows() {
3946 return wxPy_ConvertList(&wxTopLevelWindows);
3947 }
3948
3949
3950 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3951 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3952 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3953
3954 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3955
3956
3957 SWIGINTERNINLINE int
3958 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3959 {
3960 unsigned long v;
3961 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3962 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3963 return res;
3964 }
3965
3966 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3967 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3968 wxMenuItemList& list = self->GetMenuItems();
3969 return wxPy_ConvertList(&list);
3970 }
3971 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3972 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3973 static const wxString wxPyControlNameStr(wxControlNameStr);
3974 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3975 if (clientData) {
3976 wxPyClientData* data = new wxPyClientData(clientData);
3977 return self->Append(item, data);
3978 } else
3979 return self->Append(item);
3980 }
3981 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3982 if (clientData) {
3983 wxPyClientData* data = new wxPyClientData(clientData);
3984 return self->Insert(item, pos, data);
3985 } else
3986 return self->Insert(item, pos);
3987 }
3988 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3989 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3990 if (data) {
3991 Py_INCREF(data->m_obj);
3992 return data->m_obj;
3993 } else {
3994 Py_INCREF(Py_None);
3995 return Py_None;
3996 }
3997 }
3998 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3999 wxPyClientData* data = new wxPyClientData(clientData);
4000 self->SetClientObject(n, data);
4001 }
4002
4003
4004 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4005 wxPyUserData* data = NULL;
4006 if ( userData ) {
4007 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4008 data = new wxPyUserData(userData);
4009 wxPyEndBlockThreads(blocked);
4010 }
4011 return new wxSizerItem(window, proportion, flag, border, data);
4012 }
4013 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4014 wxPyUserData* data = NULL;
4015 if ( userData ) {
4016 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4017 data = new wxPyUserData(userData);
4018 wxPyEndBlockThreads(blocked);
4019 }
4020 return new wxSizerItem(width, height, proportion, flag, border, data);
4021 }
4022 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4023 wxPyUserData* data = NULL;
4024 if ( userData ) {
4025 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4026 data = new wxPyUserData(userData);
4027 wxPyEndBlockThreads(blocked);
4028 }
4029 return new wxSizerItem(sizer, proportion, flag, border, data);
4030 }
4031
4032 SWIGINTERNINLINE PyObject *
4033 SWIG_From_float (float value)
4034 {
4035 return SWIG_From_double (value);
4036 }
4037
4038 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4039 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4040 if (data) {
4041 Py_INCREF(data->m_obj);
4042 return data->m_obj;
4043 } else {
4044 Py_INCREF(Py_None);
4045 return Py_None;
4046 }
4047 }
4048 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4049 wxPyUserData* data = NULL;
4050 if ( userData ) {
4051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4052 data = new wxPyUserData(userData);
4053 wxPyEndBlockThreads(blocked);
4054 }
4055 self->SetUserData(data);
4056 }
4057
4058 // Figure out the type of the sizer item
4059
4060 struct wxPySizerItemInfo {
4061 wxPySizerItemInfo()
4062 : window(NULL), sizer(NULL), gotSize(false),
4063 size(wxDefaultSize), gotPos(false), pos(-1)
4064 {}
4065
4066 wxWindow* window;
4067 wxSizer* sizer;
4068 bool gotSize;
4069 wxSize size;
4070 bool gotPos;
4071 int pos;
4072 };
4073
4074 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4075
4076 wxPySizerItemInfo info;
4077 wxSize size;
4078 wxSize* sizePtr = &size;
4079
4080 // Find out what the type of the item is
4081 // try wxWindow
4082 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4083 PyErr_Clear();
4084 info.window = NULL;
4085
4086 // try wxSizer
4087 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4088 PyErr_Clear();
4089 info.sizer = NULL;
4090
4091 // try wxSize or (w,h)
4092 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4093 info.size = *sizePtr;
4094 info.gotSize = true;
4095 }
4096
4097 // or a single int
4098 if (checkIdx && PyInt_Check(item)) {
4099 info.pos = PyInt_AsLong(item);
4100 info.gotPos = true;
4101 }
4102 }
4103 }
4104
4105 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4106 // no expected type, figure out what kind of error message to generate
4107 if ( !checkSize && !checkIdx )
4108 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4109 else if ( checkSize && !checkIdx )
4110 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4111 else if ( !checkSize && checkIdx)
4112 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4113 else
4114 // can this one happen?
4115 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4116 }
4117
4118 return info;
4119 }
4120
4121 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4122 if (!self->GetClientObject())
4123 self->SetClientObject(new wxPyOORClientData(_self));
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Add method if a valid item type was found
4137 if ( info.window )
4138 return self->Add(info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Add(info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,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 Insert method if a valid item type was found
4159 if ( info.window )
4160 return self->Insert(before, info.window, proportion, flag, border, data);
4161 else if ( info.sizer )
4162 return self->Insert(before, info.sizer, proportion, flag, border, data);
4163 else if (info.gotSize)
4164 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4165 proportion, flag, border, data);
4166 else
4167 return NULL;
4168 }
4169 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4170
4171 wxPyUserData* data = NULL;
4172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4173 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4174 if ( userData && (info.window || info.sizer || info.gotSize) )
4175 data = new wxPyUserData(userData);
4176 if ( info.sizer )
4177 PyObject_SetAttrString(item,"thisown",Py_False);
4178 wxPyEndBlockThreads(blocked);
4179
4180 // Now call the real Prepend method if a valid item type was found
4181 if ( info.window )
4182 return self->Prepend(info.window, proportion, flag, border, data);
4183 else if ( info.sizer )
4184 return self->Prepend(info.sizer, proportion, flag, border, data);
4185 else if (info.gotSize)
4186 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4187 proportion, flag, border, data);
4188 else
4189 return NULL;
4190 }
4191 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4194 wxPyEndBlockThreads(blocked);
4195 if ( info.window )
4196 return self->Remove(info.window);
4197 else if ( info.sizer )
4198 return self->Remove(info.sizer);
4199 else if ( info.gotPos )
4200 return self->Remove(info.pos);
4201 else
4202 return false;
4203 }
4204 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4205 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4206 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4207 wxPyEndBlockThreads(blocked);
4208 if ( info.window )
4209 return self->Detach(info.window);
4210 else if ( info.sizer )
4211 return self->Detach(info.sizer);
4212 else if ( info.gotPos )
4213 return self->Detach(info.pos);
4214 else
4215 return false;
4216 }
4217 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4218 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4219 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4220 wxPyEndBlockThreads(blocked);
4221 if ( info.window )
4222 return self->GetItem(info.window);
4223 else if ( info.sizer )
4224 return self->GetItem(info.sizer);
4225 else if ( info.gotPos )
4226 return self->GetItem(info.pos);
4227 else
4228 return NULL;
4229 }
4230 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4231 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4232 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4233 wxPyEndBlockThreads(blocked);
4234 if ( info.window )
4235 self->SetItemMinSize(info.window, size);
4236 else if ( info.sizer )
4237 self->SetItemMinSize(info.sizer, size);
4238 else if ( info.gotPos )
4239 self->SetItemMinSize(info.pos, size);
4240 }
4241 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4242 wxSizerItemList& list = self->GetChildren();
4243 return wxPy_ConvertList(&list);
4244 }
4245 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4248 wxPyEndBlockThreads(blocked);
4249 if ( info.window )
4250 return self->Show(info.window, show, recursive);
4251 else if ( info.sizer )
4252 return self->Show(info.sizer, show, recursive);
4253 else if ( info.gotPos )
4254 return self->Show(info.pos, show);
4255 else
4256 return false;
4257 }
4258 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4259 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4260 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4261 wxPyEndBlockThreads(blocked);
4262 if ( info.window )
4263 return self->IsShown(info.window);
4264 else if ( info.sizer )
4265 return self->IsShown(info.sizer);
4266 else if ( info.gotPos )
4267 return self->IsShown(info.pos);
4268 else
4269 return false;
4270 }
4271
4272 // See pyclasses.h
4273 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4274 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4275 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4276
4277
4278
4279
4280 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4281 {
4282 if (source == Py_None) {
4283 **obj = wxGBPosition(-1,-1);
4284 return true;
4285 }
4286 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4287 }
4288
4289 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4290 {
4291 if (source == Py_None) {
4292 **obj = wxGBSpan(-1,-1);
4293 return true;
4294 }
4295 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4296 }
4297
4298
4299 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4300 wxGBPosition temp, *obj = &temp;
4301 if ( other == Py_None ) return false;
4302 if ( ! wxGBPosition_helper(other, &obj) ) {
4303 PyErr_Clear();
4304 return false;
4305 }
4306 return self->operator==(*obj);
4307 }
4308 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4309 wxGBPosition temp, *obj = &temp;
4310 if ( other == Py_None ) return true;
4311 if ( ! wxGBPosition_helper(other, &obj)) {
4312 PyErr_Clear();
4313 return true;
4314 }
4315 return self->operator!=(*obj);
4316 }
4317 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4318 self->SetRow(row);
4319 self->SetCol(col);
4320 }
4321 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 PyObject* tup = PyTuple_New(2);
4324 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4325 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4326 wxPyEndBlockThreads(blocked);
4327 return tup;
4328 }
4329 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4330 wxGBSpan temp, *obj = &temp;
4331 if ( other == Py_None ) return false;
4332 if ( ! wxGBSpan_helper(other, &obj) ) {
4333 PyErr_Clear();
4334 return false;
4335 }
4336 return self->operator==(*obj);
4337 }
4338 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4339 wxGBSpan temp, *obj = &temp;
4340 if ( other == Py_None ) return true;
4341 if ( ! wxGBSpan_helper(other, &obj)) {
4342 PyErr_Clear();
4343 return true;
4344 }
4345 return self->operator!=(*obj);
4346 }
4347 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4348 self->SetRowspan(rowspan);
4349 self->SetColspan(colspan);
4350 }
4351 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4353 PyObject* tup = PyTuple_New(2);
4354 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4355 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4356 wxPyEndBlockThreads(blocked);
4357 return tup;
4358 }
4359 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4360 wxPyUserData* data = NULL;
4361 if ( userData ) {
4362 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4363 data = new wxPyUserData(userData);
4364 wxPyEndBlockThreads(blocked);
4365 }
4366 return new wxGBSizerItem(window, pos, span, flag, border, data);
4367 }
4368 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4369 wxPyUserData* data = NULL;
4370 if ( userData ) {
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 data = new wxPyUserData(userData);
4373 wxPyEndBlockThreads(blocked);
4374 }
4375 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4376 }
4377 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4378 wxPyUserData* data = NULL;
4379 if ( userData ) {
4380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4381 data = new wxPyUserData(userData);
4382 wxPyEndBlockThreads(blocked);
4383 }
4384 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4385 }
4386 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4387 int row, col;
4388 self->GetEndPos(row, col);
4389 return wxGBPosition(row, col);
4390 }
4391 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4392
4393 wxPyUserData* data = NULL;
4394 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4395 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4396 if ( userData && (info.window || info.sizer || info.gotSize) )
4397 data = new wxPyUserData(userData);
4398 if ( info.sizer )
4399 PyObject_SetAttrString(item,"thisown",Py_False);
4400 wxPyEndBlockThreads(blocked);
4401
4402 // Now call the real Add method if a valid item type was found
4403 if ( info.window )
4404 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4405 else if ( info.sizer )
4406 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4407 else if (info.gotSize)
4408 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4409 pos, span, flag, border, data);
4410 return NULL;
4411 }
4412
4413
4414 #ifdef __cplusplus
4415 extern "C" {
4416 #endif
4417 SWIGINTERN int EmptyString_set(PyObject *) {
4418 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4419 return 1;
4420 }
4421
4422
4423 SWIGINTERN PyObject *EmptyString_get(void) {
4424 PyObject *pyobj = 0;
4425
4426 {
4427 #if wxUSE_UNICODE
4428 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4429 #else
4430 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4431 #endif
4432 }
4433 return pyobj;
4434 }
4435
4436
4437 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4438 PyObject *resultobj = 0;
4439 wxObject *arg1 = (wxObject *) 0 ;
4440 wxString result;
4441 void *argp1 = 0 ;
4442 int res1 = 0 ;
4443 PyObject *swig_obj[1] ;
4444
4445 if (!args) SWIG_fail;
4446 swig_obj[0] = args;
4447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4448 if (!SWIG_IsOK(res1)) {
4449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4450 }
4451 arg1 = reinterpret_cast< wxObject * >(argp1);
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 result = wxObject_GetClassName(arg1);
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 {
4459 #if wxUSE_UNICODE
4460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4461 #else
4462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4463 #endif
4464 }
4465 return resultobj;
4466 fail:
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4472 PyObject *resultobj = 0;
4473 wxObject *arg1 = (wxObject *) 0 ;
4474 void *argp1 = 0 ;
4475 int res1 = 0 ;
4476 PyObject *swig_obj[1] ;
4477
4478 if (!args) SWIG_fail;
4479 swig_obj[0] = args;
4480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4481 if (!SWIG_IsOK(res1)) {
4482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4483 }
4484 arg1 = reinterpret_cast< wxObject * >(argp1);
4485 {
4486 PyThreadState* __tstate = wxPyBeginAllowThreads();
4487 wxObject_Destroy(arg1);
4488 wxPyEndAllowThreads(__tstate);
4489 if (PyErr_Occurred()) SWIG_fail;
4490 }
4491 resultobj = SWIG_Py_Void();
4492 return resultobj;
4493 fail:
4494 return NULL;
4495 }
4496
4497
4498 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4499 PyObject *resultobj = 0;
4500 wxObject *arg1 = (wxObject *) 0 ;
4501 wxObject *arg2 = 0 ;
4502 bool result;
4503 void *argp1 = 0 ;
4504 int res1 = 0 ;
4505 void *argp2 = 0 ;
4506 int res2 = 0 ;
4507 PyObject * obj0 = 0 ;
4508 PyObject * obj1 = 0 ;
4509 char * kwnames[] = {
4510 (char *) "self",(char *) "p", NULL
4511 };
4512
4513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4515 if (!SWIG_IsOK(res1)) {
4516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4517 }
4518 arg1 = reinterpret_cast< wxObject * >(argp1);
4519 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4520 if (!SWIG_IsOK(res2)) {
4521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4522 }
4523 if (!argp2) {
4524 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4525 }
4526 arg2 = reinterpret_cast< wxObject * >(argp2);
4527 {
4528 PyThreadState* __tstate = wxPyBeginAllowThreads();
4529 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4530 wxPyEndAllowThreads(__tstate);
4531 if (PyErr_Occurred()) SWIG_fail;
4532 }
4533 {
4534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4535 }
4536 return resultobj;
4537 fail:
4538 return NULL;
4539 }
4540
4541
4542 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4543 PyObject *obj;
4544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4545 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4546 return SWIG_Py_Void();
4547 }
4548
4549 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 PyObject *resultobj = 0;
4551 wxSize *arg1 = (wxSize *) 0 ;
4552 int arg2 ;
4553 void *argp1 = 0 ;
4554 int res1 = 0 ;
4555 int val2 ;
4556 int ecode2 = 0 ;
4557 PyObject *swig_obj[2] ;
4558
4559 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4561 if (!SWIG_IsOK(res1)) {
4562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4563 }
4564 arg1 = reinterpret_cast< wxSize * >(argp1);
4565 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4566 if (!SWIG_IsOK(ecode2)) {
4567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4568 }
4569 arg2 = static_cast< int >(val2);
4570 if (arg1) (arg1)->x = arg2;
4571
4572 resultobj = SWIG_Py_Void();
4573 return resultobj;
4574 fail:
4575 return NULL;
4576 }
4577
4578
4579 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580 PyObject *resultobj = 0;
4581 wxSize *arg1 = (wxSize *) 0 ;
4582 int result;
4583 void *argp1 = 0 ;
4584 int res1 = 0 ;
4585 PyObject *swig_obj[1] ;
4586
4587 if (!args) SWIG_fail;
4588 swig_obj[0] = args;
4589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4590 if (!SWIG_IsOK(res1)) {
4591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4592 }
4593 arg1 = reinterpret_cast< wxSize * >(argp1);
4594 result = (int) ((arg1)->x);
4595 resultobj = SWIG_From_int(static_cast< int >(result));
4596 return resultobj;
4597 fail:
4598 return NULL;
4599 }
4600
4601
4602 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4603 PyObject *resultobj = 0;
4604 wxSize *arg1 = (wxSize *) 0 ;
4605 int arg2 ;
4606 void *argp1 = 0 ;
4607 int res1 = 0 ;
4608 int val2 ;
4609 int ecode2 = 0 ;
4610 PyObject *swig_obj[2] ;
4611
4612 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4614 if (!SWIG_IsOK(res1)) {
4615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4616 }
4617 arg1 = reinterpret_cast< wxSize * >(argp1);
4618 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4619 if (!SWIG_IsOK(ecode2)) {
4620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4621 }
4622 arg2 = static_cast< int >(val2);
4623 if (arg1) (arg1)->y = arg2;
4624
4625 resultobj = SWIG_Py_Void();
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4633 PyObject *resultobj = 0;
4634 wxSize *arg1 = (wxSize *) 0 ;
4635 int result;
4636 void *argp1 = 0 ;
4637 int res1 = 0 ;
4638 PyObject *swig_obj[1] ;
4639
4640 if (!args) SWIG_fail;
4641 swig_obj[0] = args;
4642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4643 if (!SWIG_IsOK(res1)) {
4644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4645 }
4646 arg1 = reinterpret_cast< wxSize * >(argp1);
4647 result = (int) ((arg1)->y);
4648 resultobj = SWIG_From_int(static_cast< int >(result));
4649 return resultobj;
4650 fail:
4651 return NULL;
4652 }
4653
4654
4655 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4656 PyObject *resultobj = 0;
4657 int arg1 = (int) 0 ;
4658 int arg2 = (int) 0 ;
4659 wxSize *result = 0 ;
4660 int val1 ;
4661 int ecode1 = 0 ;
4662 int val2 ;
4663 int ecode2 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "w",(char *) "h", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4671 if (obj0) {
4672 ecode1 = SWIG_AsVal_int(obj0, &val1);
4673 if (!SWIG_IsOK(ecode1)) {
4674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4675 }
4676 arg1 = static_cast< int >(val1);
4677 }
4678 if (obj1) {
4679 ecode2 = SWIG_AsVal_int(obj1, &val2);
4680 if (!SWIG_IsOK(ecode2)) {
4681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4682 }
4683 arg2 = static_cast< int >(val2);
4684 }
4685 {
4686 result = (wxSize *)new wxSize(arg1,arg2);
4687 if (PyErr_Occurred()) SWIG_fail;
4688 }
4689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4697 PyObject *resultobj = 0;
4698 wxSize *arg1 = (wxSize *) 0 ;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 PyObject *swig_obj[1] ;
4702
4703 if (!args) SWIG_fail;
4704 swig_obj[0] = args;
4705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 {
4711 delete arg1;
4712
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_Py_Void();
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 wxSize *arg1 = (wxSize *) 0 ;
4725 PyObject *arg2 = (PyObject *) 0 ;
4726 bool result;
4727 void *argp1 = 0 ;
4728 int res1 = 0 ;
4729 PyObject * obj0 = 0 ;
4730 PyObject * obj1 = 0 ;
4731 char * kwnames[] = {
4732 (char *) "self",(char *) "other", NULL
4733 };
4734
4735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4739 }
4740 arg1 = reinterpret_cast< wxSize * >(argp1);
4741 arg2 = obj1;
4742 {
4743 result = (bool)wxSize___eq__(arg1,arg2);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 {
4747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4748 }
4749 return resultobj;
4750 fail:
4751 return NULL;
4752 }
4753
4754
4755 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj = 0;
4757 wxSize *arg1 = (wxSize *) 0 ;
4758 PyObject *arg2 = (PyObject *) 0 ;
4759 bool result;
4760 void *argp1 = 0 ;
4761 int res1 = 0 ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char * kwnames[] = {
4765 (char *) "self",(char *) "other", NULL
4766 };
4767
4768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4770 if (!SWIG_IsOK(res1)) {
4771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4772 }
4773 arg1 = reinterpret_cast< wxSize * >(argp1);
4774 arg2 = obj1;
4775 {
4776 result = (bool)wxSize___ne__(arg1,arg2);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 {
4780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4781 }
4782 return resultobj;
4783 fail:
4784 return NULL;
4785 }
4786
4787
4788 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj = 0;
4790 wxSize *arg1 = (wxSize *) 0 ;
4791 wxSize *arg2 = 0 ;
4792 wxSize result;
4793 void *argp1 = 0 ;
4794 int res1 = 0 ;
4795 wxSize temp2 ;
4796 PyObject * obj0 = 0 ;
4797 PyObject * obj1 = 0 ;
4798 char * kwnames[] = {
4799 (char *) "self",(char *) "sz", NULL
4800 };
4801
4802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4804 if (!SWIG_IsOK(res1)) {
4805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4806 }
4807 arg1 = reinterpret_cast< wxSize * >(argp1);
4808 {
4809 arg2 = &temp2;
4810 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4811 }
4812 {
4813 result = (arg1)->operator +((wxSize const &)*arg2);
4814 if (PyErr_Occurred()) SWIG_fail;
4815 }
4816 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4817 return resultobj;
4818 fail:
4819 return NULL;
4820 }
4821
4822
4823 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4824 PyObject *resultobj = 0;
4825 wxSize *arg1 = (wxSize *) 0 ;
4826 wxSize *arg2 = 0 ;
4827 wxSize result;
4828 void *argp1 = 0 ;
4829 int res1 = 0 ;
4830 wxSize temp2 ;
4831 PyObject * obj0 = 0 ;
4832 PyObject * obj1 = 0 ;
4833 char * kwnames[] = {
4834 (char *) "self",(char *) "sz", NULL
4835 };
4836
4837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4839 if (!SWIG_IsOK(res1)) {
4840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4841 }
4842 arg1 = reinterpret_cast< wxSize * >(argp1);
4843 {
4844 arg2 = &temp2;
4845 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4846 }
4847 {
4848 result = (arg1)->operator -((wxSize const &)*arg2);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj = 0;
4860 wxSize *arg1 = (wxSize *) 0 ;
4861 wxSize *arg2 = 0 ;
4862 void *argp1 = 0 ;
4863 int res1 = 0 ;
4864 wxSize temp2 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char * kwnames[] = {
4868 (char *) "self",(char *) "sz", NULL
4869 };
4870
4871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4873 if (!SWIG_IsOK(res1)) {
4874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4875 }
4876 arg1 = reinterpret_cast< wxSize * >(argp1);
4877 {
4878 arg2 = &temp2;
4879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4880 }
4881 {
4882 (arg1)->IncTo((wxSize const &)*arg2);
4883 if (PyErr_Occurred()) SWIG_fail;
4884 }
4885 resultobj = SWIG_Py_Void();
4886 return resultobj;
4887 fail:
4888 return NULL;
4889 }
4890
4891
4892 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4893 PyObject *resultobj = 0;
4894 wxSize *arg1 = (wxSize *) 0 ;
4895 wxSize *arg2 = 0 ;
4896 void *argp1 = 0 ;
4897 int res1 = 0 ;
4898 wxSize temp2 ;
4899 PyObject * obj0 = 0 ;
4900 PyObject * obj1 = 0 ;
4901 char * kwnames[] = {
4902 (char *) "self",(char *) "sz", NULL
4903 };
4904
4905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4907 if (!SWIG_IsOK(res1)) {
4908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4909 }
4910 arg1 = reinterpret_cast< wxSize * >(argp1);
4911 {
4912 arg2 = &temp2;
4913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4914 }
4915 {
4916 (arg1)->DecTo((wxSize const &)*arg2);
4917 if (PyErr_Occurred()) SWIG_fail;
4918 }
4919 resultobj = SWIG_Py_Void();
4920 return resultobj;
4921 fail:
4922 return NULL;
4923 }
4924
4925
4926 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4927 PyObject *resultobj = 0;
4928 wxSize *arg1 = (wxSize *) 0 ;
4929 int arg2 ;
4930 int arg3 ;
4931 void *argp1 = 0 ;
4932 int res1 = 0 ;
4933 int val2 ;
4934 int ecode2 = 0 ;
4935 int val3 ;
4936 int ecode3 = 0 ;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "self",(char *) "dx",(char *) "dy", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4946 if (!SWIG_IsOK(res1)) {
4947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4948 }
4949 arg1 = reinterpret_cast< wxSize * >(argp1);
4950 ecode2 = SWIG_AsVal_int(obj1, &val2);
4951 if (!SWIG_IsOK(ecode2)) {
4952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4953 }
4954 arg2 = static_cast< int >(val2);
4955 ecode3 = SWIG_AsVal_int(obj2, &val3);
4956 if (!SWIG_IsOK(ecode3)) {
4957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4958 }
4959 arg3 = static_cast< int >(val3);
4960 {
4961 (arg1)->IncBy(arg2,arg3);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 resultobj = SWIG_Py_Void();
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4972 PyObject *resultobj = 0;
4973 wxSize *arg1 = (wxSize *) 0 ;
4974 int arg2 ;
4975 int arg3 ;
4976 void *argp1 = 0 ;
4977 int res1 = 0 ;
4978 int val2 ;
4979 int ecode2 = 0 ;
4980 int val3 ;
4981 int ecode3 = 0 ;
4982 PyObject * obj0 = 0 ;
4983 PyObject * obj1 = 0 ;
4984 PyObject * obj2 = 0 ;
4985 char * kwnames[] = {
4986 (char *) "self",(char *) "dx",(char *) "dy", NULL
4987 };
4988
4989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4991 if (!SWIG_IsOK(res1)) {
4992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4993 }
4994 arg1 = reinterpret_cast< wxSize * >(argp1);
4995 ecode2 = SWIG_AsVal_int(obj1, &val2);
4996 if (!SWIG_IsOK(ecode2)) {
4997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4998 }
4999 arg2 = static_cast< int >(val2);
5000 ecode3 = SWIG_AsVal_int(obj2, &val3);
5001 if (!SWIG_IsOK(ecode3)) {
5002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5003 }
5004 arg3 = static_cast< int >(val3);
5005 {
5006 (arg1)->DecBy(arg2,arg3);
5007 if (PyErr_Occurred()) SWIG_fail;
5008 }
5009 resultobj = SWIG_Py_Void();
5010 return resultobj;
5011 fail:
5012 return NULL;
5013 }
5014
5015
5016 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5017 PyObject *resultobj = 0;
5018 wxSize *arg1 = (wxSize *) 0 ;
5019 float arg2 ;
5020 float arg3 ;
5021 void *argp1 = 0 ;
5022 int res1 = 0 ;
5023 float val2 ;
5024 int ecode2 = 0 ;
5025 float val3 ;
5026 int ecode3 = 0 ;
5027 PyObject * obj0 = 0 ;
5028 PyObject * obj1 = 0 ;
5029 PyObject * obj2 = 0 ;
5030 char * kwnames[] = {
5031 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5032 };
5033
5034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5036 if (!SWIG_IsOK(res1)) {
5037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5038 }
5039 arg1 = reinterpret_cast< wxSize * >(argp1);
5040 ecode2 = SWIG_AsVal_float(obj1, &val2);
5041 if (!SWIG_IsOK(ecode2)) {
5042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5043 }
5044 arg2 = static_cast< float >(val2);
5045 ecode3 = SWIG_AsVal_float(obj2, &val3);
5046 if (!SWIG_IsOK(ecode3)) {
5047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5048 }
5049 arg3 = static_cast< float >(val3);
5050 {
5051 (arg1)->Scale(arg2,arg3);
5052 if (PyErr_Occurred()) SWIG_fail;
5053 }
5054 resultobj = SWIG_Py_Void();
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5062 PyObject *resultobj = 0;
5063 wxSize *arg1 = (wxSize *) 0 ;
5064 int arg2 ;
5065 int arg3 ;
5066 void *argp1 = 0 ;
5067 int res1 = 0 ;
5068 int val2 ;
5069 int ecode2 = 0 ;
5070 int val3 ;
5071 int ecode3 = 0 ;
5072 PyObject * obj0 = 0 ;
5073 PyObject * obj1 = 0 ;
5074 PyObject * obj2 = 0 ;
5075 char * kwnames[] = {
5076 (char *) "self",(char *) "w",(char *) "h", NULL
5077 };
5078
5079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5081 if (!SWIG_IsOK(res1)) {
5082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5083 }
5084 arg1 = reinterpret_cast< wxSize * >(argp1);
5085 ecode2 = SWIG_AsVal_int(obj1, &val2);
5086 if (!SWIG_IsOK(ecode2)) {
5087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5088 }
5089 arg2 = static_cast< int >(val2);
5090 ecode3 = SWIG_AsVal_int(obj2, &val3);
5091 if (!SWIG_IsOK(ecode3)) {
5092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5093 }
5094 arg3 = static_cast< int >(val3);
5095 {
5096 (arg1)->Set(arg2,arg3);
5097 if (PyErr_Occurred()) SWIG_fail;
5098 }
5099 resultobj = SWIG_Py_Void();
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj = 0;
5108 wxSize *arg1 = (wxSize *) 0 ;
5109 int arg2 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 int val2 ;
5113 int ecode2 = 0 ;
5114 PyObject * obj0 = 0 ;
5115 PyObject * obj1 = 0 ;
5116 char * kwnames[] = {
5117 (char *) "self",(char *) "w", NULL
5118 };
5119
5120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5122 if (!SWIG_IsOK(res1)) {
5123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5124 }
5125 arg1 = reinterpret_cast< wxSize * >(argp1);
5126 ecode2 = SWIG_AsVal_int(obj1, &val2);
5127 if (!SWIG_IsOK(ecode2)) {
5128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5129 }
5130 arg2 = static_cast< int >(val2);
5131 {
5132 (arg1)->SetWidth(arg2);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5143 PyObject *resultobj = 0;
5144 wxSize *arg1 = (wxSize *) 0 ;
5145 int arg2 ;
5146 void *argp1 = 0 ;
5147 int res1 = 0 ;
5148 int val2 ;
5149 int ecode2 = 0 ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 char * kwnames[] = {
5153 (char *) "self",(char *) "h", NULL
5154 };
5155
5156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5158 if (!SWIG_IsOK(res1)) {
5159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5160 }
5161 arg1 = reinterpret_cast< wxSize * >(argp1);
5162 ecode2 = SWIG_AsVal_int(obj1, &val2);
5163 if (!SWIG_IsOK(ecode2)) {
5164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5165 }
5166 arg2 = static_cast< int >(val2);
5167 {
5168 (arg1)->SetHeight(arg2);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 resultobj = SWIG_Py_Void();
5172 return resultobj;
5173 fail:
5174 return NULL;
5175 }
5176
5177
5178 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5179 PyObject *resultobj = 0;
5180 wxSize *arg1 = (wxSize *) 0 ;
5181 int result;
5182 void *argp1 = 0 ;
5183 int res1 = 0 ;
5184 PyObject *swig_obj[1] ;
5185
5186 if (!args) SWIG_fail;
5187 swig_obj[0] = args;
5188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5189 if (!SWIG_IsOK(res1)) {
5190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5191 }
5192 arg1 = reinterpret_cast< wxSize * >(argp1);
5193 {
5194 result = (int)((wxSize const *)arg1)->GetWidth();
5195 if (PyErr_Occurred()) SWIG_fail;
5196 }
5197 resultobj = SWIG_From_int(static_cast< int >(result));
5198 return resultobj;
5199 fail:
5200 return NULL;
5201 }
5202
5203
5204 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5205 PyObject *resultobj = 0;
5206 wxSize *arg1 = (wxSize *) 0 ;
5207 int result;
5208 void *argp1 = 0 ;
5209 int res1 = 0 ;
5210 PyObject *swig_obj[1] ;
5211
5212 if (!args) SWIG_fail;
5213 swig_obj[0] = args;
5214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5215 if (!SWIG_IsOK(res1)) {
5216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5217 }
5218 arg1 = reinterpret_cast< wxSize * >(argp1);
5219 {
5220 result = (int)((wxSize const *)arg1)->GetHeight();
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 resultobj = SWIG_From_int(static_cast< int >(result));
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5231 PyObject *resultobj = 0;
5232 wxSize *arg1 = (wxSize *) 0 ;
5233 bool result;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 PyObject *swig_obj[1] ;
5237
5238 if (!args) SWIG_fail;
5239 swig_obj[0] = args;
5240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5241 if (!SWIG_IsOK(res1)) {
5242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5243 }
5244 arg1 = reinterpret_cast< wxSize * >(argp1);
5245 {
5246 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 {
5250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5251 }
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj = 0;
5260 wxSize *arg1 = (wxSize *) 0 ;
5261 wxSize *arg2 = 0 ;
5262 void *argp1 = 0 ;
5263 int res1 = 0 ;
5264 wxSize temp2 ;
5265 PyObject * obj0 = 0 ;
5266 PyObject * obj1 = 0 ;
5267 char * kwnames[] = {
5268 (char *) "self",(char *) "size", NULL
5269 };
5270
5271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5273 if (!SWIG_IsOK(res1)) {
5274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5275 }
5276 arg1 = reinterpret_cast< wxSize * >(argp1);
5277 {
5278 arg2 = &temp2;
5279 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5280 }
5281 {
5282 (arg1)->SetDefaults((wxSize const &)*arg2);
5283 if (PyErr_Occurred()) SWIG_fail;
5284 }
5285 resultobj = SWIG_Py_Void();
5286 return resultobj;
5287 fail:
5288 return NULL;
5289 }
5290
5291
5292 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293 PyObject *resultobj = 0;
5294 wxSize *arg1 = (wxSize *) 0 ;
5295 PyObject *result = 0 ;
5296 void *argp1 = 0 ;
5297 int res1 = 0 ;
5298 PyObject *swig_obj[1] ;
5299
5300 if (!args) SWIG_fail;
5301 swig_obj[0] = args;
5302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5303 if (!SWIG_IsOK(res1)) {
5304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5305 }
5306 arg1 = reinterpret_cast< wxSize * >(argp1);
5307 {
5308 result = (PyObject *)wxSize_Get(arg1);
5309 if (PyErr_Occurred()) SWIG_fail;
5310 }
5311 resultobj = result;
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5319 PyObject *obj;
5320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5321 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5322 return SWIG_Py_Void();
5323 }
5324
5325 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5326 return SWIG_Python_InitShadowInstance(args);
5327 }
5328
5329 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 PyObject *resultobj = 0;
5331 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5332 double arg2 ;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 double val2 ;
5336 int ecode2 = 0 ;
5337 PyObject *swig_obj[2] ;
5338
5339 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5341 if (!SWIG_IsOK(res1)) {
5342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5343 }
5344 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5345 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5346 if (!SWIG_IsOK(ecode2)) {
5347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5348 }
5349 arg2 = static_cast< double >(val2);
5350 if (arg1) (arg1)->x = arg2;
5351
5352 resultobj = SWIG_Py_Void();
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5360 PyObject *resultobj = 0;
5361 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5362 double result;
5363 void *argp1 = 0 ;
5364 int res1 = 0 ;
5365 PyObject *swig_obj[1] ;
5366
5367 if (!args) SWIG_fail;
5368 swig_obj[0] = args;
5369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5370 if (!SWIG_IsOK(res1)) {
5371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5372 }
5373 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5374 result = (double) ((arg1)->x);
5375 resultobj = SWIG_From_double(static_cast< double >(result));
5376 return resultobj;
5377 fail:
5378 return NULL;
5379 }
5380
5381
5382 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5383 PyObject *resultobj = 0;
5384 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5385 double arg2 ;
5386 void *argp1 = 0 ;
5387 int res1 = 0 ;
5388 double val2 ;
5389 int ecode2 = 0 ;
5390 PyObject *swig_obj[2] ;
5391
5392 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5394 if (!SWIG_IsOK(res1)) {
5395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5396 }
5397 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5398 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5399 if (!SWIG_IsOK(ecode2)) {
5400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5401 }
5402 arg2 = static_cast< double >(val2);
5403 if (arg1) (arg1)->y = arg2;
5404
5405 resultobj = SWIG_Py_Void();
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *resultobj = 0;
5414 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5415 double result;
5416 void *argp1 = 0 ;
5417 int res1 = 0 ;
5418 PyObject *swig_obj[1] ;
5419
5420 if (!args) SWIG_fail;
5421 swig_obj[0] = args;
5422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5423 if (!SWIG_IsOK(res1)) {
5424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5425 }
5426 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5427 result = (double) ((arg1)->y);
5428 resultobj = SWIG_From_double(static_cast< double >(result));
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
5435 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5436 PyObject *resultobj = 0;
5437 double arg1 = (double) 0.0 ;
5438 double arg2 = (double) 0.0 ;
5439 wxRealPoint *result = 0 ;
5440 double val1 ;
5441 int ecode1 = 0 ;
5442 double val2 ;
5443 int ecode2 = 0 ;
5444 PyObject * obj0 = 0 ;
5445 PyObject * obj1 = 0 ;
5446 char * kwnames[] = {
5447 (char *) "x",(char *) "y", NULL
5448 };
5449
5450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5451 if (obj0) {
5452 ecode1 = SWIG_AsVal_double(obj0, &val1);
5453 if (!SWIG_IsOK(ecode1)) {
5454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5455 }
5456 arg1 = static_cast< double >(val1);
5457 }
5458 if (obj1) {
5459 ecode2 = SWIG_AsVal_double(obj1, &val2);
5460 if (!SWIG_IsOK(ecode2)) {
5461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5462 }
5463 arg2 = static_cast< double >(val2);
5464 }
5465 {
5466 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 PyObject *swig_obj[1] ;
5482
5483 if (!args) SWIG_fail;
5484 swig_obj[0] = args;
5485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5486 if (!SWIG_IsOK(res1)) {
5487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5488 }
5489 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5490 {
5491 delete arg1;
5492
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 resultobj = SWIG_Py_Void();
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj = 0;
5504 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5505 PyObject *arg2 = (PyObject *) 0 ;
5506 bool result;
5507 void *argp1 = 0 ;
5508 int res1 = 0 ;
5509 PyObject * obj0 = 0 ;
5510 PyObject * obj1 = 0 ;
5511 char * kwnames[] = {
5512 (char *) "self",(char *) "other", NULL
5513 };
5514
5515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5521 arg2 = obj1;
5522 {
5523 result = (bool)wxRealPoint___eq__(arg1,arg2);
5524 if (PyErr_Occurred()) SWIG_fail;
5525 }
5526 {
5527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5528 }
5529 return resultobj;
5530 fail:
5531 return NULL;
5532 }
5533
5534
5535 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5536 PyObject *resultobj = 0;
5537 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5538 PyObject *arg2 = (PyObject *) 0 ;
5539 bool result;
5540 void *argp1 = 0 ;
5541 int res1 = 0 ;
5542 PyObject * obj0 = 0 ;
5543 PyObject * obj1 = 0 ;
5544 char * kwnames[] = {
5545 (char *) "self",(char *) "other", NULL
5546 };
5547
5548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5550 if (!SWIG_IsOK(res1)) {
5551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5552 }
5553 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5554 arg2 = obj1;
5555 {
5556 result = (bool)wxRealPoint___ne__(arg1,arg2);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 {
5560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5561 }
5562 return resultobj;
5563 fail:
5564 return NULL;
5565 }
5566
5567
5568 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5569 PyObject *resultobj = 0;
5570 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5571 wxRealPoint *arg2 = 0 ;
5572 wxRealPoint result;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 wxRealPoint temp2 ;
5576 PyObject * obj0 = 0 ;
5577 PyObject * obj1 = 0 ;
5578 char * kwnames[] = {
5579 (char *) "self",(char *) "pt", NULL
5580 };
5581
5582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5584 if (!SWIG_IsOK(res1)) {
5585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5586 }
5587 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5588 {
5589 arg2 = &temp2;
5590 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5591 }
5592 {
5593 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5594 if (PyErr_Occurred()) SWIG_fail;
5595 }
5596 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj = 0;
5605 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5606 wxRealPoint *arg2 = 0 ;
5607 wxRealPoint result;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 wxRealPoint temp2 ;
5611 PyObject * obj0 = 0 ;
5612 PyObject * obj1 = 0 ;
5613 char * kwnames[] = {
5614 (char *) "self",(char *) "pt", NULL
5615 };
5616
5617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5619 if (!SWIG_IsOK(res1)) {
5620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5621 }
5622 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5623 {
5624 arg2 = &temp2;
5625 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5626 }
5627 {
5628 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5629 if (PyErr_Occurred()) SWIG_fail;
5630 }
5631 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5632 return resultobj;
5633 fail:
5634 return NULL;
5635 }
5636
5637
5638 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5639 PyObject *resultobj = 0;
5640 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5641 double arg2 ;
5642 double arg3 ;
5643 void *argp1 = 0 ;
5644 int res1 = 0 ;
5645 double val2 ;
5646 int ecode2 = 0 ;
5647 double val3 ;
5648 int ecode3 = 0 ;
5649 PyObject * obj0 = 0 ;
5650 PyObject * obj1 = 0 ;
5651 PyObject * obj2 = 0 ;
5652 char * kwnames[] = {
5653 (char *) "self",(char *) "x",(char *) "y", NULL
5654 };
5655
5656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5658 if (!SWIG_IsOK(res1)) {
5659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5660 }
5661 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5662 ecode2 = SWIG_AsVal_double(obj1, &val2);
5663 if (!SWIG_IsOK(ecode2)) {
5664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5665 }
5666 arg2 = static_cast< double >(val2);
5667 ecode3 = SWIG_AsVal_double(obj2, &val3);
5668 if (!SWIG_IsOK(ecode3)) {
5669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5670 }
5671 arg3 = static_cast< double >(val3);
5672 {
5673 wxRealPoint_Set(arg1,arg2,arg3);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 resultobj = SWIG_Py_Void();
5677 return resultobj;
5678 fail:
5679 return NULL;
5680 }
5681
5682
5683 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5684 PyObject *resultobj = 0;
5685 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5686 PyObject *result = 0 ;
5687 void *argp1 = 0 ;
5688 int res1 = 0 ;
5689 PyObject *swig_obj[1] ;
5690
5691 if (!args) SWIG_fail;
5692 swig_obj[0] = args;
5693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5694 if (!SWIG_IsOK(res1)) {
5695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5696 }
5697 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5698 {
5699 result = (PyObject *)wxRealPoint_Get(arg1);
5700 if (PyErr_Occurred()) SWIG_fail;
5701 }
5702 resultobj = result;
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5710 PyObject *obj;
5711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5712 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5713 return SWIG_Py_Void();
5714 }
5715
5716 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5717 return SWIG_Python_InitShadowInstance(args);
5718 }
5719
5720 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5721 PyObject *resultobj = 0;
5722 wxPoint *arg1 = (wxPoint *) 0 ;
5723 int arg2 ;
5724 void *argp1 = 0 ;
5725 int res1 = 0 ;
5726 int val2 ;
5727 int ecode2 = 0 ;
5728 PyObject *swig_obj[2] ;
5729
5730 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5732 if (!SWIG_IsOK(res1)) {
5733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5734 }
5735 arg1 = reinterpret_cast< wxPoint * >(argp1);
5736 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5737 if (!SWIG_IsOK(ecode2)) {
5738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5739 }
5740 arg2 = static_cast< int >(val2);
5741 if (arg1) (arg1)->x = arg2;
5742
5743 resultobj = SWIG_Py_Void();
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5751 PyObject *resultobj = 0;
5752 wxPoint *arg1 = (wxPoint *) 0 ;
5753 int result;
5754 void *argp1 = 0 ;
5755 int res1 = 0 ;
5756 PyObject *swig_obj[1] ;
5757
5758 if (!args) SWIG_fail;
5759 swig_obj[0] = args;
5760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5761 if (!SWIG_IsOK(res1)) {
5762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5763 }
5764 arg1 = reinterpret_cast< wxPoint * >(argp1);
5765 result = (int) ((arg1)->x);
5766 resultobj = SWIG_From_int(static_cast< int >(result));
5767 return resultobj;
5768 fail:
5769 return NULL;
5770 }
5771
5772
5773 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5774 PyObject *resultobj = 0;
5775 wxPoint *arg1 = (wxPoint *) 0 ;
5776 int arg2 ;
5777 void *argp1 = 0 ;
5778 int res1 = 0 ;
5779 int val2 ;
5780 int ecode2 = 0 ;
5781 PyObject *swig_obj[2] ;
5782
5783 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5785 if (!SWIG_IsOK(res1)) {
5786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5787 }
5788 arg1 = reinterpret_cast< wxPoint * >(argp1);
5789 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5790 if (!SWIG_IsOK(ecode2)) {
5791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5792 }
5793 arg2 = static_cast< int >(val2);
5794 if (arg1) (arg1)->y = arg2;
5795
5796 resultobj = SWIG_Py_Void();
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5804 PyObject *resultobj = 0;
5805 wxPoint *arg1 = (wxPoint *) 0 ;
5806 int result;
5807 void *argp1 = 0 ;
5808 int res1 = 0 ;
5809 PyObject *swig_obj[1] ;
5810
5811 if (!args) SWIG_fail;
5812 swig_obj[0] = args;
5813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5814 if (!SWIG_IsOK(res1)) {
5815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5816 }
5817 arg1 = reinterpret_cast< wxPoint * >(argp1);
5818 result = (int) ((arg1)->y);
5819 resultobj = SWIG_From_int(static_cast< int >(result));
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj = 0;
5828 int arg1 = (int) 0 ;
5829 int arg2 = (int) 0 ;
5830 wxPoint *result = 0 ;
5831 int val1 ;
5832 int ecode1 = 0 ;
5833 int val2 ;
5834 int ecode2 = 0 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char * kwnames[] = {
5838 (char *) "x",(char *) "y", NULL
5839 };
5840
5841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5842 if (obj0) {
5843 ecode1 = SWIG_AsVal_int(obj0, &val1);
5844 if (!SWIG_IsOK(ecode1)) {
5845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5846 }
5847 arg1 = static_cast< int >(val1);
5848 }
5849 if (obj1) {
5850 ecode2 = SWIG_AsVal_int(obj1, &val2);
5851 if (!SWIG_IsOK(ecode2)) {
5852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5853 }
5854 arg2 = static_cast< int >(val2);
5855 }
5856 {
5857 result = (wxPoint *)new wxPoint(arg1,arg2);
5858 if (PyErr_Occurred()) SWIG_fail;
5859 }
5860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868 PyObject *resultobj = 0;
5869 wxPoint *arg1 = (wxPoint *) 0 ;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 PyObject *swig_obj[1] ;
5873
5874 if (!args) SWIG_fail;
5875 swig_obj[0] = args;
5876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5877 if (!SWIG_IsOK(res1)) {
5878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5879 }
5880 arg1 = reinterpret_cast< wxPoint * >(argp1);
5881 {
5882 delete arg1;
5883
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 resultobj = SWIG_Py_Void();
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj = 0;
5895 wxPoint *arg1 = (wxPoint *) 0 ;
5896 PyObject *arg2 = (PyObject *) 0 ;
5897 bool result;
5898 void *argp1 = 0 ;
5899 int res1 = 0 ;
5900 PyObject * obj0 = 0 ;
5901 PyObject * obj1 = 0 ;
5902 char * kwnames[] = {
5903 (char *) "self",(char *) "other", NULL
5904 };
5905
5906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5908 if (!SWIG_IsOK(res1)) {
5909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5910 }
5911 arg1 = reinterpret_cast< wxPoint * >(argp1);
5912 arg2 = obj1;
5913 {
5914 result = (bool)wxPoint___eq__(arg1,arg2);
5915 if (PyErr_Occurred()) SWIG_fail;
5916 }
5917 {
5918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5919 }
5920 return resultobj;
5921 fail:
5922 return NULL;
5923 }
5924
5925
5926 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5927 PyObject *resultobj = 0;
5928 wxPoint *arg1 = (wxPoint *) 0 ;
5929 PyObject *arg2 = (PyObject *) 0 ;
5930 bool result;
5931 void *argp1 = 0 ;
5932 int res1 = 0 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char * kwnames[] = {
5936 (char *) "self",(char *) "other", NULL
5937 };
5938
5939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5941 if (!SWIG_IsOK(res1)) {
5942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5943 }
5944 arg1 = reinterpret_cast< wxPoint * >(argp1);
5945 arg2 = obj1;
5946 {
5947 result = (bool)wxPoint___ne__(arg1,arg2);
5948 if (PyErr_Occurred()) SWIG_fail;
5949 }
5950 {
5951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5952 }
5953 return resultobj;
5954 fail:
5955 return NULL;
5956 }
5957
5958
5959 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5960 PyObject *resultobj = 0;
5961 wxPoint *arg1 = (wxPoint *) 0 ;
5962 wxPoint *arg2 = 0 ;
5963 wxPoint result;
5964 void *argp1 = 0 ;
5965 int res1 = 0 ;
5966 wxPoint temp2 ;
5967 PyObject * obj0 = 0 ;
5968 PyObject * obj1 = 0 ;
5969 char * kwnames[] = {
5970 (char *) "self",(char *) "pt", NULL
5971 };
5972
5973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5975 if (!SWIG_IsOK(res1)) {
5976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5977 }
5978 arg1 = reinterpret_cast< wxPoint * >(argp1);
5979 {
5980 arg2 = &temp2;
5981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5982 }
5983 {
5984 result = (arg1)->operator +((wxPoint const &)*arg2);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj = 0;
5996 wxPoint *arg1 = (wxPoint *) 0 ;
5997 wxPoint *arg2 = 0 ;
5998 wxPoint result;
5999 void *argp1 = 0 ;
6000 int res1 = 0 ;
6001 wxPoint temp2 ;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 char * kwnames[] = {
6005 (char *) "self",(char *) "pt", NULL
6006 };
6007
6008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6010 if (!SWIG_IsOK(res1)) {
6011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6012 }
6013 arg1 = reinterpret_cast< wxPoint * >(argp1);
6014 {
6015 arg2 = &temp2;
6016 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6017 }
6018 {
6019 result = (arg1)->operator -((wxPoint const &)*arg2);
6020 if (PyErr_Occurred()) SWIG_fail;
6021 }
6022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6023 return resultobj;
6024 fail:
6025 return NULL;
6026 }
6027
6028
6029 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6030 PyObject *resultobj = 0;
6031 wxPoint *arg1 = (wxPoint *) 0 ;
6032 wxPoint *arg2 = 0 ;
6033 wxPoint *result = 0 ;
6034 void *argp1 = 0 ;
6035 int res1 = 0 ;
6036 wxPoint temp2 ;
6037 PyObject * obj0 = 0 ;
6038 PyObject * obj1 = 0 ;
6039 char * kwnames[] = {
6040 (char *) "self",(char *) "pt", NULL
6041 };
6042
6043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6045 if (!SWIG_IsOK(res1)) {
6046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6047 }
6048 arg1 = reinterpret_cast< wxPoint * >(argp1);
6049 {
6050 arg2 = &temp2;
6051 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6052 }
6053 {
6054 {
6055 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6056 result = (wxPoint *) &_result_ref;
6057 }
6058 if (PyErr_Occurred()) SWIG_fail;
6059 }
6060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6061 return resultobj;
6062 fail:
6063 return NULL;
6064 }
6065
6066
6067 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj = 0;
6069 wxPoint *arg1 = (wxPoint *) 0 ;
6070 wxPoint *arg2 = 0 ;
6071 wxPoint *result = 0 ;
6072 void *argp1 = 0 ;
6073 int res1 = 0 ;
6074 wxPoint temp2 ;
6075 PyObject * obj0 = 0 ;
6076 PyObject * obj1 = 0 ;
6077 char * kwnames[] = {
6078 (char *) "self",(char *) "pt", NULL
6079 };
6080
6081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6083 if (!SWIG_IsOK(res1)) {
6084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6085 }
6086 arg1 = reinterpret_cast< wxPoint * >(argp1);
6087 {
6088 arg2 = &temp2;
6089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6090 }
6091 {
6092 {
6093 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6094 result = (wxPoint *) &_result_ref;
6095 }
6096 if (PyErr_Occurred()) SWIG_fail;
6097 }
6098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6099 return resultobj;
6100 fail:
6101 return NULL;
6102 }
6103
6104
6105 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6106 PyObject *resultobj = 0;
6107 wxPoint *arg1 = (wxPoint *) 0 ;
6108 long arg2 ;
6109 long arg3 ;
6110 void *argp1 = 0 ;
6111 int res1 = 0 ;
6112 long val2 ;
6113 int ecode2 = 0 ;
6114 long val3 ;
6115 int ecode3 = 0 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 PyObject * obj2 = 0 ;
6119 char * kwnames[] = {
6120 (char *) "self",(char *) "x",(char *) "y", NULL
6121 };
6122
6123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6125 if (!SWIG_IsOK(res1)) {
6126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6127 }
6128 arg1 = reinterpret_cast< wxPoint * >(argp1);
6129 ecode2 = SWIG_AsVal_long(obj1, &val2);
6130 if (!SWIG_IsOK(ecode2)) {
6131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6132 }
6133 arg2 = static_cast< long >(val2);
6134 ecode3 = SWIG_AsVal_long(obj2, &val3);
6135 if (!SWIG_IsOK(ecode3)) {
6136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6137 }
6138 arg3 = static_cast< long >(val3);
6139 {
6140 wxPoint_Set(arg1,arg2,arg3);
6141 if (PyErr_Occurred()) SWIG_fail;
6142 }
6143 resultobj = SWIG_Py_Void();
6144 return resultobj;
6145 fail:
6146 return NULL;
6147 }
6148
6149
6150 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6151 PyObject *resultobj = 0;
6152 wxPoint *arg1 = (wxPoint *) 0 ;
6153 PyObject *result = 0 ;
6154 void *argp1 = 0 ;
6155 int res1 = 0 ;
6156 PyObject *swig_obj[1] ;
6157
6158 if (!args) SWIG_fail;
6159 swig_obj[0] = args;
6160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6161 if (!SWIG_IsOK(res1)) {
6162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6163 }
6164 arg1 = reinterpret_cast< wxPoint * >(argp1);
6165 {
6166 result = (PyObject *)wxPoint_Get(arg1);
6167 if (PyErr_Occurred()) SWIG_fail;
6168 }
6169 resultobj = result;
6170 return resultobj;
6171 fail:
6172 return NULL;
6173 }
6174
6175
6176 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6177 PyObject *obj;
6178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6179 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6180 return SWIG_Py_Void();
6181 }
6182
6183 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6184 return SWIG_Python_InitShadowInstance(args);
6185 }
6186
6187 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6188 PyObject *resultobj = 0;
6189 int arg1 = (int) 0 ;
6190 int arg2 = (int) 0 ;
6191 int arg3 = (int) 0 ;
6192 int arg4 = (int) 0 ;
6193 wxRect *result = 0 ;
6194 int val1 ;
6195 int ecode1 = 0 ;
6196 int val2 ;
6197 int ecode2 = 0 ;
6198 int val3 ;
6199 int ecode3 = 0 ;
6200 int val4 ;
6201 int ecode4 = 0 ;
6202 PyObject * obj0 = 0 ;
6203 PyObject * obj1 = 0 ;
6204 PyObject * obj2 = 0 ;
6205 PyObject * obj3 = 0 ;
6206 char * kwnames[] = {
6207 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6208 };
6209
6210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6211 if (obj0) {
6212 ecode1 = SWIG_AsVal_int(obj0, &val1);
6213 if (!SWIG_IsOK(ecode1)) {
6214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6215 }
6216 arg1 = static_cast< int >(val1);
6217 }
6218 if (obj1) {
6219 ecode2 = SWIG_AsVal_int(obj1, &val2);
6220 if (!SWIG_IsOK(ecode2)) {
6221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6222 }
6223 arg2 = static_cast< int >(val2);
6224 }
6225 if (obj2) {
6226 ecode3 = SWIG_AsVal_int(obj2, &val3);
6227 if (!SWIG_IsOK(ecode3)) {
6228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6229 }
6230 arg3 = static_cast< int >(val3);
6231 }
6232 if (obj3) {
6233 ecode4 = SWIG_AsVal_int(obj3, &val4);
6234 if (!SWIG_IsOK(ecode4)) {
6235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6236 }
6237 arg4 = static_cast< int >(val4);
6238 }
6239 {
6240 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6241 if (PyErr_Occurred()) SWIG_fail;
6242 }
6243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6244 return resultobj;
6245 fail:
6246 return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6251 PyObject *resultobj = 0;
6252 wxPoint *arg1 = 0 ;
6253 wxPoint *arg2 = 0 ;
6254 wxRect *result = 0 ;
6255 wxPoint temp1 ;
6256 wxPoint temp2 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 char * kwnames[] = {
6260 (char *) "topLeft",(char *) "bottomRight", NULL
6261 };
6262
6263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6264 {
6265 arg1 = &temp1;
6266 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6267 }
6268 {
6269 arg2 = &temp2;
6270 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6271 }
6272 {
6273 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
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 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6307 if (PyErr_Occurred()) SWIG_fail;
6308 }
6309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6310 return resultobj;
6311 fail:
6312 return NULL;
6313 }
6314
6315
6316 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6317 PyObject *resultobj = 0;
6318 wxSize *arg1 = 0 ;
6319 wxRect *result = 0 ;
6320 wxSize temp1 ;
6321 PyObject * obj0 = 0 ;
6322 char * kwnames[] = {
6323 (char *) "size", NULL
6324 };
6325
6326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6327 {
6328 arg1 = &temp1;
6329 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6330 }
6331 {
6332 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6343 PyObject *resultobj = 0;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 void *argp1 = 0 ;
6346 int res1 = 0 ;
6347 PyObject *swig_obj[1] ;
6348
6349 if (!args) SWIG_fail;
6350 swig_obj[0] = args;
6351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6352 if (!SWIG_IsOK(res1)) {
6353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6354 }
6355 arg1 = reinterpret_cast< wxRect * >(argp1);
6356 {
6357 delete arg1;
6358
6359 if (PyErr_Occurred()) SWIG_fail;
6360 }
6361 resultobj = SWIG_Py_Void();
6362 return resultobj;
6363 fail:
6364 return NULL;
6365 }
6366
6367
6368 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6369 PyObject *resultobj = 0;
6370 wxRect *arg1 = (wxRect *) 0 ;
6371 int result;
6372 void *argp1 = 0 ;
6373 int res1 = 0 ;
6374 PyObject *swig_obj[1] ;
6375
6376 if (!args) SWIG_fail;
6377 swig_obj[0] = args;
6378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6379 if (!SWIG_IsOK(res1)) {
6380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6381 }
6382 arg1 = reinterpret_cast< wxRect * >(argp1);
6383 {
6384 result = (int)((wxRect const *)arg1)->GetX();
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_From_int(static_cast< int >(result));
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj = 0;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 int arg2 ;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 int val2 ;
6401 int ecode2 = 0 ;
6402 PyObject * obj0 = 0 ;
6403 PyObject * obj1 = 0 ;
6404 char * kwnames[] = {
6405 (char *) "self",(char *) "x", NULL
6406 };
6407
6408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6410 if (!SWIG_IsOK(res1)) {
6411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6412 }
6413 arg1 = reinterpret_cast< wxRect * >(argp1);
6414 ecode2 = SWIG_AsVal_int(obj1, &val2);
6415 if (!SWIG_IsOK(ecode2)) {
6416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6417 }
6418 arg2 = static_cast< int >(val2);
6419 {
6420 (arg1)->SetX(arg2);
6421 if (PyErr_Occurred()) SWIG_fail;
6422 }
6423 resultobj = SWIG_Py_Void();
6424 return resultobj;
6425 fail:
6426 return NULL;
6427 }
6428
6429
6430 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6431 PyObject *resultobj = 0;
6432 wxRect *arg1 = (wxRect *) 0 ;
6433 int result;
6434 void *argp1 = 0 ;
6435 int res1 = 0 ;
6436 PyObject *swig_obj[1] ;
6437
6438 if (!args) SWIG_fail;
6439 swig_obj[0] = args;
6440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6441 if (!SWIG_IsOK(res1)) {
6442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6443 }
6444 arg1 = reinterpret_cast< wxRect * >(argp1);
6445 {
6446 result = (int)(arg1)->GetY();
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 resultobj = SWIG_From_int(static_cast< int >(result));
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6457 PyObject *resultobj = 0;
6458 wxRect *arg1 = (wxRect *) 0 ;
6459 int arg2 ;
6460 void *argp1 = 0 ;
6461 int res1 = 0 ;
6462 int val2 ;
6463 int ecode2 = 0 ;
6464 PyObject * obj0 = 0 ;
6465 PyObject * obj1 = 0 ;
6466 char * kwnames[] = {
6467 (char *) "self",(char *) "y", NULL
6468 };
6469
6470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 ecode2 = SWIG_AsVal_int(obj1, &val2);
6477 if (!SWIG_IsOK(ecode2)) {
6478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6479 }
6480 arg2 = static_cast< int >(val2);
6481 {
6482 (arg1)->SetY(arg2);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 resultobj = SWIG_Py_Void();
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6493 PyObject *resultobj = 0;
6494 wxRect *arg1 = (wxRect *) 0 ;
6495 int result;
6496 void *argp1 = 0 ;
6497 int res1 = 0 ;
6498 PyObject *swig_obj[1] ;
6499
6500 if (!args) SWIG_fail;
6501 swig_obj[0] = args;
6502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6503 if (!SWIG_IsOK(res1)) {
6504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6505 }
6506 arg1 = reinterpret_cast< wxRect * >(argp1);
6507 {
6508 result = (int)((wxRect const *)arg1)->GetWidth();
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int(static_cast< int >(result));
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6519 PyObject *resultobj = 0;
6520 wxRect *arg1 = (wxRect *) 0 ;
6521 int arg2 ;
6522 void *argp1 = 0 ;
6523 int res1 = 0 ;
6524 int val2 ;
6525 int ecode2 = 0 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 char * kwnames[] = {
6529 (char *) "self",(char *) "w", NULL
6530 };
6531
6532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 ecode2 = SWIG_AsVal_int(obj1, &val2);
6539 if (!SWIG_IsOK(ecode2)) {
6540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6541 }
6542 arg2 = static_cast< int >(val2);
6543 {
6544 (arg1)->SetWidth(arg2);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_Py_Void();
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6555 PyObject *resultobj = 0;
6556 wxRect *arg1 = (wxRect *) 0 ;
6557 int result;
6558 void *argp1 = 0 ;
6559 int res1 = 0 ;
6560 PyObject *swig_obj[1] ;
6561
6562 if (!args) SWIG_fail;
6563 swig_obj[0] = args;
6564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 {
6570 result = (int)((wxRect const *)arg1)->GetHeight();
6571 if (PyErr_Occurred()) SWIG_fail;
6572 }
6573 resultobj = SWIG_From_int(static_cast< int >(result));
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6581 PyObject *resultobj = 0;
6582 wxRect *arg1 = (wxRect *) 0 ;
6583 int arg2 ;
6584 void *argp1 = 0 ;
6585 int res1 = 0 ;
6586 int val2 ;
6587 int ecode2 = 0 ;
6588 PyObject * obj0 = 0 ;
6589 PyObject * obj1 = 0 ;
6590 char * kwnames[] = {
6591 (char *) "self",(char *) "h", NULL
6592 };
6593
6594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6596 if (!SWIG_IsOK(res1)) {
6597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6598 }
6599 arg1 = reinterpret_cast< wxRect * >(argp1);
6600 ecode2 = SWIG_AsVal_int(obj1, &val2);
6601 if (!SWIG_IsOK(ecode2)) {
6602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6603 }
6604 arg2 = static_cast< int >(val2);
6605 {
6606 (arg1)->SetHeight(arg2);
6607 if (PyErr_Occurred()) SWIG_fail;
6608 }
6609 resultobj = SWIG_Py_Void();
6610 return resultobj;
6611 fail:
6612 return NULL;
6613 }
6614
6615
6616 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6617 PyObject *resultobj = 0;
6618 wxRect *arg1 = (wxRect *) 0 ;
6619 wxPoint result;
6620 void *argp1 = 0 ;
6621 int res1 = 0 ;
6622 PyObject *swig_obj[1] ;
6623
6624 if (!args) SWIG_fail;
6625 swig_obj[0] = args;
6626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6627 if (!SWIG_IsOK(res1)) {
6628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6629 }
6630 arg1 = reinterpret_cast< wxRect * >(argp1);
6631 {
6632 result = ((wxRect const *)arg1)->GetPosition();
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6643 PyObject *resultobj = 0;
6644 wxRect *arg1 = (wxRect *) 0 ;
6645 wxPoint *arg2 = 0 ;
6646 void *argp1 = 0 ;
6647 int res1 = 0 ;
6648 wxPoint temp2 ;
6649 PyObject * obj0 = 0 ;
6650 PyObject * obj1 = 0 ;
6651 char * kwnames[] = {
6652 (char *) "self",(char *) "p", NULL
6653 };
6654
6655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6657 if (!SWIG_IsOK(res1)) {
6658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6659 }
6660 arg1 = reinterpret_cast< wxRect * >(argp1);
6661 {
6662 arg2 = &temp2;
6663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6664 }
6665 {
6666 (arg1)->SetPosition((wxPoint const &)*arg2);
6667 if (PyErr_Occurred()) SWIG_fail;
6668 }
6669 resultobj = SWIG_Py_Void();
6670 return resultobj;
6671 fail:
6672 return NULL;
6673 }
6674
6675
6676 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6677 PyObject *resultobj = 0;
6678 wxRect *arg1 = (wxRect *) 0 ;
6679 wxSize result;
6680 void *argp1 = 0 ;
6681 int res1 = 0 ;
6682 PyObject *swig_obj[1] ;
6683
6684 if (!args) SWIG_fail;
6685 swig_obj[0] = args;
6686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6687 if (!SWIG_IsOK(res1)) {
6688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6689 }
6690 arg1 = reinterpret_cast< wxRect * >(argp1);
6691 {
6692 result = ((wxRect const *)arg1)->GetSize();
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6703 PyObject *resultobj = 0;
6704 wxRect *arg1 = (wxRect *) 0 ;
6705 wxSize *arg2 = 0 ;
6706 void *argp1 = 0 ;
6707 int res1 = 0 ;
6708 wxSize temp2 ;
6709 PyObject * obj0 = 0 ;
6710 PyObject * obj1 = 0 ;
6711 char * kwnames[] = {
6712 (char *) "self",(char *) "s", NULL
6713 };
6714
6715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6717 if (!SWIG_IsOK(res1)) {
6718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6719 }
6720 arg1 = reinterpret_cast< wxRect * >(argp1);
6721 {
6722 arg2 = &temp2;
6723 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6724 }
6725 {
6726 (arg1)->SetSize((wxSize const &)*arg2);
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 resultobj = SWIG_Py_Void();
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6737 PyObject *resultobj = 0;
6738 wxRect *arg1 = (wxRect *) 0 ;
6739 bool result;
6740 void *argp1 = 0 ;
6741 int res1 = 0 ;
6742 PyObject *swig_obj[1] ;
6743
6744 if (!args) SWIG_fail;
6745 swig_obj[0] = args;
6746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6747 if (!SWIG_IsOK(res1)) {
6748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6749 }
6750 arg1 = reinterpret_cast< wxRect * >(argp1);
6751 {
6752 result = (bool)((wxRect const *)arg1)->IsEmpty();
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 {
6756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6757 }
6758 return resultobj;
6759 fail:
6760 return NULL;
6761 }
6762
6763
6764 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6765 PyObject *resultobj = 0;
6766 wxRect *arg1 = (wxRect *) 0 ;
6767 wxPoint result;
6768 void *argp1 = 0 ;
6769 int res1 = 0 ;
6770 PyObject *swig_obj[1] ;
6771
6772 if (!args) SWIG_fail;
6773 swig_obj[0] = args;
6774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6775 if (!SWIG_IsOK(res1)) {
6776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6777 }
6778 arg1 = reinterpret_cast< wxRect * >(argp1);
6779 {
6780 result = ((wxRect const *)arg1)->GetTopLeft();
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj = 0;
6792 wxRect *arg1 = (wxRect *) 0 ;
6793 wxPoint *arg2 = 0 ;
6794 void *argp1 = 0 ;
6795 int res1 = 0 ;
6796 wxPoint temp2 ;
6797 PyObject * obj0 = 0 ;
6798 PyObject * obj1 = 0 ;
6799 char * kwnames[] = {
6800 (char *) "self",(char *) "p", NULL
6801 };
6802
6803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6805 if (!SWIG_IsOK(res1)) {
6806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6807 }
6808 arg1 = reinterpret_cast< wxRect * >(argp1);
6809 {
6810 arg2 = &temp2;
6811 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6812 }
6813 {
6814 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 resultobj = SWIG_Py_Void();
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6825 PyObject *resultobj = 0;
6826 wxRect *arg1 = (wxRect *) 0 ;
6827 wxPoint result;
6828 void *argp1 = 0 ;
6829 int res1 = 0 ;
6830 PyObject *swig_obj[1] ;
6831
6832 if (!args) SWIG_fail;
6833 swig_obj[0] = args;
6834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6835 if (!SWIG_IsOK(res1)) {
6836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6837 }
6838 arg1 = reinterpret_cast< wxRect * >(argp1);
6839 {
6840 result = ((wxRect const *)arg1)->GetBottomRight();
6841 if (PyErr_Occurred()) SWIG_fail;
6842 }
6843 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6844 return resultobj;
6845 fail:
6846 return NULL;
6847 }
6848
6849
6850 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6851 PyObject *resultobj = 0;
6852 wxRect *arg1 = (wxRect *) 0 ;
6853 wxPoint *arg2 = 0 ;
6854 void *argp1 = 0 ;
6855 int res1 = 0 ;
6856 wxPoint temp2 ;
6857 PyObject * obj0 = 0 ;
6858 PyObject * obj1 = 0 ;
6859 char * kwnames[] = {
6860 (char *) "self",(char *) "p", NULL
6861 };
6862
6863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6865 if (!SWIG_IsOK(res1)) {
6866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6867 }
6868 arg1 = reinterpret_cast< wxRect * >(argp1);
6869 {
6870 arg2 = &temp2;
6871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6872 }
6873 {
6874 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_Py_Void();
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 wxPoint result;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 PyObject *swig_obj[1] ;
6891
6892 if (!args) SWIG_fail;
6893 swig_obj[0] = args;
6894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6895 if (!SWIG_IsOK(res1)) {
6896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6897 }
6898 arg1 = reinterpret_cast< wxRect * >(argp1);
6899 {
6900 result = ((wxRect const *)arg1)->GetTopRight();
6901 if (PyErr_Occurred()) SWIG_fail;
6902 }
6903 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj = 0;
6912 wxRect *arg1 = (wxRect *) 0 ;
6913 wxPoint *arg2 = 0 ;
6914 void *argp1 = 0 ;
6915 int res1 = 0 ;
6916 wxPoint temp2 ;
6917 PyObject * obj0 = 0 ;
6918 PyObject * obj1 = 0 ;
6919 char * kwnames[] = {
6920 (char *) "self",(char *) "p", NULL
6921 };
6922
6923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6925 if (!SWIG_IsOK(res1)) {
6926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6927 }
6928 arg1 = reinterpret_cast< wxRect * >(argp1);
6929 {
6930 arg2 = &temp2;
6931 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6932 }
6933 {
6934 (arg1)->SetTopRight((wxPoint const &)*arg2);
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_Py_Void();
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6945 PyObject *resultobj = 0;
6946 wxRect *arg1 = (wxRect *) 0 ;
6947 wxPoint result;
6948 void *argp1 = 0 ;
6949 int res1 = 0 ;
6950 PyObject *swig_obj[1] ;
6951
6952 if (!args) SWIG_fail;
6953 swig_obj[0] = args;
6954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 {
6960 result = ((wxRect const *)arg1)->GetBottomLeft();
6961 if (PyErr_Occurred()) SWIG_fail;
6962 }
6963 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6964 return resultobj;
6965 fail:
6966 return NULL;
6967 }
6968
6969
6970 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6971 PyObject *resultobj = 0;
6972 wxRect *arg1 = (wxRect *) 0 ;
6973 wxPoint *arg2 = 0 ;
6974 void *argp1 = 0 ;
6975 int res1 = 0 ;
6976 wxPoint temp2 ;
6977 PyObject * obj0 = 0 ;
6978 PyObject * obj1 = 0 ;
6979 char * kwnames[] = {
6980 (char *) "self",(char *) "p", NULL
6981 };
6982
6983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6985 if (!SWIG_IsOK(res1)) {
6986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6987 }
6988 arg1 = reinterpret_cast< wxRect * >(argp1);
6989 {
6990 arg2 = &temp2;
6991 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6992 }
6993 {
6994 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 resultobj = SWIG_Py_Void();
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7005 PyObject *resultobj = 0;
7006 wxRect *arg1 = (wxRect *) 0 ;
7007 int result;
7008 void *argp1 = 0 ;
7009 int res1 = 0 ;
7010 PyObject *swig_obj[1] ;
7011
7012 if (!args) SWIG_fail;
7013 swig_obj[0] = args;
7014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7015 if (!SWIG_IsOK(res1)) {
7016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7017 }
7018 arg1 = reinterpret_cast< wxRect * >(argp1);
7019 {
7020 result = (int)((wxRect const *)arg1)->GetLeft();
7021 if (PyErr_Occurred()) SWIG_fail;
7022 }
7023 resultobj = SWIG_From_int(static_cast< int >(result));
7024 return resultobj;
7025 fail:
7026 return NULL;
7027 }
7028
7029
7030 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7031 PyObject *resultobj = 0;
7032 wxRect *arg1 = (wxRect *) 0 ;
7033 int result;
7034 void *argp1 = 0 ;
7035 int res1 = 0 ;
7036 PyObject *swig_obj[1] ;
7037
7038 if (!args) SWIG_fail;
7039 swig_obj[0] = args;
7040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7041 if (!SWIG_IsOK(res1)) {
7042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7043 }
7044 arg1 = reinterpret_cast< wxRect * >(argp1);
7045 {
7046 result = (int)((wxRect const *)arg1)->GetTop();
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_From_int(static_cast< int >(result));
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7057 PyObject *resultobj = 0;
7058 wxRect *arg1 = (wxRect *) 0 ;
7059 int result;
7060 void *argp1 = 0 ;
7061 int res1 = 0 ;
7062 PyObject *swig_obj[1] ;
7063
7064 if (!args) SWIG_fail;
7065 swig_obj[0] = args;
7066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7067 if (!SWIG_IsOK(res1)) {
7068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7069 }
7070 arg1 = reinterpret_cast< wxRect * >(argp1);
7071 {
7072 result = (int)((wxRect const *)arg1)->GetBottom();
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 resultobj = SWIG_From_int(static_cast< int >(result));
7076 return resultobj;
7077 fail:
7078 return NULL;
7079 }
7080
7081
7082 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7083 PyObject *resultobj = 0;
7084 wxRect *arg1 = (wxRect *) 0 ;
7085 int result;
7086 void *argp1 = 0 ;
7087 int res1 = 0 ;
7088 PyObject *swig_obj[1] ;
7089
7090 if (!args) SWIG_fail;
7091 swig_obj[0] = args;
7092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 {
7098 result = (int)((wxRect const *)arg1)->GetRight();
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_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int arg2 ;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 int val2 ;
7115 int ecode2 = 0 ;
7116 PyObject * obj0 = 0 ;
7117 PyObject * obj1 = 0 ;
7118 char * kwnames[] = {
7119 (char *) "self",(char *) "left", NULL
7120 };
7121
7122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7124 if (!SWIG_IsOK(res1)) {
7125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7126 }
7127 arg1 = reinterpret_cast< wxRect * >(argp1);
7128 ecode2 = SWIG_AsVal_int(obj1, &val2);
7129 if (!SWIG_IsOK(ecode2)) {
7130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7131 }
7132 arg2 = static_cast< int >(val2);
7133 {
7134 (arg1)->SetLeft(arg2);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 resultobj = SWIG_Py_Void();
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj = 0;
7146 wxRect *arg1 = (wxRect *) 0 ;
7147 int arg2 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 PyObject * obj0 = 0 ;
7153 PyObject * obj1 = 0 ;
7154 char * kwnames[] = {
7155 (char *) "self",(char *) "right", NULL
7156 };
7157
7158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7162 }
7163 arg1 = reinterpret_cast< wxRect * >(argp1);
7164 ecode2 = SWIG_AsVal_int(obj1, &val2);
7165 if (!SWIG_IsOK(ecode2)) {
7166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7167 }
7168 arg2 = static_cast< int >(val2);
7169 {
7170 (arg1)->SetRight(arg2);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 resultobj = SWIG_Py_Void();
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj = 0;
7182 wxRect *arg1 = (wxRect *) 0 ;
7183 int arg2 ;
7184 void *argp1 = 0 ;
7185 int res1 = 0 ;
7186 int val2 ;
7187 int ecode2 = 0 ;
7188 PyObject * obj0 = 0 ;
7189 PyObject * obj1 = 0 ;
7190 char * kwnames[] = {
7191 (char *) "self",(char *) "top", NULL
7192 };
7193
7194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7196 if (!SWIG_IsOK(res1)) {
7197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7198 }
7199 arg1 = reinterpret_cast< wxRect * >(argp1);
7200 ecode2 = SWIG_AsVal_int(obj1, &val2);
7201 if (!SWIG_IsOK(ecode2)) {
7202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7203 }
7204 arg2 = static_cast< int >(val2);
7205 {
7206 (arg1)->SetTop(arg2);
7207 if (PyErr_Occurred()) SWIG_fail;
7208 }
7209 resultobj = SWIG_Py_Void();
7210 return resultobj;
7211 fail:
7212 return NULL;
7213 }
7214
7215
7216 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7217 PyObject *resultobj = 0;
7218 wxRect *arg1 = (wxRect *) 0 ;
7219 int arg2 ;
7220 void *argp1 = 0 ;
7221 int res1 = 0 ;
7222 int val2 ;
7223 int ecode2 = 0 ;
7224 PyObject * obj0 = 0 ;
7225 PyObject * obj1 = 0 ;
7226 char * kwnames[] = {
7227 (char *) "self",(char *) "bottom", NULL
7228 };
7229
7230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7232 if (!SWIG_IsOK(res1)) {
7233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7234 }
7235 arg1 = reinterpret_cast< wxRect * >(argp1);
7236 ecode2 = SWIG_AsVal_int(obj1, &val2);
7237 if (!SWIG_IsOK(ecode2)) {
7238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7239 }
7240 arg2 = static_cast< int >(val2);
7241 {
7242 (arg1)->SetBottom(arg2);
7243 if (PyErr_Occurred()) SWIG_fail;
7244 }
7245 resultobj = SWIG_Py_Void();
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj = 0;
7254 wxRect *arg1 = (wxRect *) 0 ;
7255 int arg2 ;
7256 int arg3 ;
7257 wxRect *result = 0 ;
7258 void *argp1 = 0 ;
7259 int res1 = 0 ;
7260 int val2 ;
7261 int ecode2 = 0 ;
7262 int val3 ;
7263 int ecode3 = 0 ;
7264 PyObject * obj0 = 0 ;
7265 PyObject * obj1 = 0 ;
7266 PyObject * obj2 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "dx",(char *) "dy", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 ecode2 = SWIG_AsVal_int(obj1, &val2);
7278 if (!SWIG_IsOK(ecode2)) {
7279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7280 }
7281 arg2 = static_cast< int >(val2);
7282 ecode3 = SWIG_AsVal_int(obj2, &val3);
7283 if (!SWIG_IsOK(ecode3)) {
7284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7285 }
7286 arg3 = static_cast< int >(val3);
7287 {
7288 {
7289 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7290 result = (wxRect *) &_result_ref;
7291 }
7292 if (PyErr_Occurred()) SWIG_fail;
7293 }
7294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7295 return resultobj;
7296 fail:
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj = 0;
7303 wxRect *arg1 = (wxRect *) 0 ;
7304 int arg2 ;
7305 int arg3 ;
7306 wxRect *result = 0 ;
7307 void *argp1 = 0 ;
7308 int res1 = 0 ;
7309 int val2 ;
7310 int ecode2 = 0 ;
7311 int val3 ;
7312 int ecode3 = 0 ;
7313 PyObject * obj0 = 0 ;
7314 PyObject * obj1 = 0 ;
7315 PyObject * obj2 = 0 ;
7316 char * kwnames[] = {
7317 (char *) "self",(char *) "dx",(char *) "dy", NULL
7318 };
7319
7320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7322 if (!SWIG_IsOK(res1)) {
7323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7324 }
7325 arg1 = reinterpret_cast< wxRect * >(argp1);
7326 ecode2 = SWIG_AsVal_int(obj1, &val2);
7327 if (!SWIG_IsOK(ecode2)) {
7328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7329 }
7330 arg2 = static_cast< int >(val2);
7331 ecode3 = SWIG_AsVal_int(obj2, &val3);
7332 if (!SWIG_IsOK(ecode3)) {
7333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7334 }
7335 arg3 = static_cast< int >(val3);
7336 {
7337 {
7338 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7339 result = (wxRect *) &_result_ref;
7340 }
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 int arg2 ;
7354 int arg3 ;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 int val2 ;
7358 int ecode2 = 0 ;
7359 int val3 ;
7360 int ecode3 = 0 ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 PyObject * obj2 = 0 ;
7364 char * kwnames[] = {
7365 (char *) "self",(char *) "dx",(char *) "dy", NULL
7366 };
7367
7368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7370 if (!SWIG_IsOK(res1)) {
7371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7372 }
7373 arg1 = reinterpret_cast< wxRect * >(argp1);
7374 ecode2 = SWIG_AsVal_int(obj1, &val2);
7375 if (!SWIG_IsOK(ecode2)) {
7376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7377 }
7378 arg2 = static_cast< int >(val2);
7379 ecode3 = SWIG_AsVal_int(obj2, &val3);
7380 if (!SWIG_IsOK(ecode3)) {
7381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7382 }
7383 arg3 = static_cast< int >(val3);
7384 {
7385 (arg1)->Offset(arg2,arg3);
7386 if (PyErr_Occurred()) SWIG_fail;
7387 }
7388 resultobj = SWIG_Py_Void();
7389 return resultobj;
7390 fail:
7391 return NULL;
7392 }
7393
7394
7395 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7396 PyObject *resultobj = 0;
7397 wxRect *arg1 = (wxRect *) 0 ;
7398 wxPoint *arg2 = 0 ;
7399 void *argp1 = 0 ;
7400 int res1 = 0 ;
7401 wxPoint temp2 ;
7402 PyObject * obj0 = 0 ;
7403 PyObject * obj1 = 0 ;
7404 char * kwnames[] = {
7405 (char *) "self",(char *) "pt", NULL
7406 };
7407
7408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7410 if (!SWIG_IsOK(res1)) {
7411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7412 }
7413 arg1 = reinterpret_cast< wxRect * >(argp1);
7414 {
7415 arg2 = &temp2;
7416 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7417 }
7418 {
7419 (arg1)->Offset((wxPoint const &)*arg2);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 resultobj = SWIG_Py_Void();
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj = 0;
7431 wxRect *arg1 = (wxRect *) 0 ;
7432 wxRect *arg2 = 0 ;
7433 wxRect result;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 wxRect temp2 ;
7437 PyObject * obj0 = 0 ;
7438 PyObject * obj1 = 0 ;
7439 char * kwnames[] = {
7440 (char *) "self",(char *) "rect", NULL
7441 };
7442
7443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7447 }
7448 arg1 = reinterpret_cast< wxRect * >(argp1);
7449 {
7450 arg2 = &temp2;
7451 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7452 }
7453 {
7454 result = (arg1)->Intersect((wxRect const &)*arg2);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = 0;
7466 wxRect *arg1 = (wxRect *) 0 ;
7467 wxRect *arg2 = 0 ;
7468 wxRect result;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxRect temp2 ;
7472 PyObject * obj0 = 0 ;
7473 PyObject * obj1 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "rect", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",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_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7482 }
7483 arg1 = reinterpret_cast< wxRect * >(argp1);
7484 {
7485 arg2 = &temp2;
7486 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7487 }
7488 {
7489 result = (arg1)->Union((wxRect const &)*arg2);
7490 if (PyErr_Occurred()) SWIG_fail;
7491 }
7492 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7500 PyObject *resultobj = 0;
7501 wxRect *arg1 = (wxRect *) 0 ;
7502 wxRect *arg2 = 0 ;
7503 wxRect result;
7504 void *argp1 = 0 ;
7505 int res1 = 0 ;
7506 wxRect temp2 ;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 char * kwnames[] = {
7510 (char *) "self",(char *) "rect", NULL
7511 };
7512
7513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7515 if (!SWIG_IsOK(res1)) {
7516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7517 }
7518 arg1 = reinterpret_cast< wxRect * >(argp1);
7519 {
7520 arg2 = &temp2;
7521 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7522 }
7523 {
7524 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7525 if (PyErr_Occurred()) SWIG_fail;
7526 }
7527 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7528 return resultobj;
7529 fail:
7530 return NULL;
7531 }
7532
7533
7534 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7535 PyObject *resultobj = 0;
7536 wxRect *arg1 = (wxRect *) 0 ;
7537 wxRect *arg2 = 0 ;
7538 wxRect *result = 0 ;
7539 void *argp1 = 0 ;
7540 int res1 = 0 ;
7541 wxRect temp2 ;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 char * kwnames[] = {
7545 (char *) "self",(char *) "rect", NULL
7546 };
7547
7548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7550 if (!SWIG_IsOK(res1)) {
7551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7552 }
7553 arg1 = reinterpret_cast< wxRect * >(argp1);
7554 {
7555 arg2 = &temp2;
7556 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7557 }
7558 {
7559 {
7560 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7561 result = (wxRect *) &_result_ref;
7562 }
7563 if (PyErr_Occurred()) SWIG_fail;
7564 }
7565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7573 PyObject *resultobj = 0;
7574 wxRect *arg1 = (wxRect *) 0 ;
7575 PyObject *arg2 = (PyObject *) 0 ;
7576 bool result;
7577 void *argp1 = 0 ;
7578 int res1 = 0 ;
7579 PyObject * obj0 = 0 ;
7580 PyObject * obj1 = 0 ;
7581 char * kwnames[] = {
7582 (char *) "self",(char *) "other", NULL
7583 };
7584
7585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7587 if (!SWIG_IsOK(res1)) {
7588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7589 }
7590 arg1 = reinterpret_cast< wxRect * >(argp1);
7591 arg2 = obj1;
7592 {
7593 result = (bool)wxRect___eq__(arg1,arg2);
7594 if (PyErr_Occurred()) SWIG_fail;
7595 }
7596 {
7597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7598 }
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj = 0;
7607 wxRect *arg1 = (wxRect *) 0 ;
7608 PyObject *arg2 = (PyObject *) 0 ;
7609 bool result;
7610 void *argp1 = 0 ;
7611 int res1 = 0 ;
7612 PyObject * obj0 = 0 ;
7613 PyObject * obj1 = 0 ;
7614 char * kwnames[] = {
7615 (char *) "self",(char *) "other", NULL
7616 };
7617
7618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7620 if (!SWIG_IsOK(res1)) {
7621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7622 }
7623 arg1 = reinterpret_cast< wxRect * >(argp1);
7624 arg2 = obj1;
7625 {
7626 result = (bool)wxRect___ne__(arg1,arg2);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 {
7630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7631 }
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj = 0;
7640 wxRect *arg1 = (wxRect *) 0 ;
7641 int arg2 ;
7642 int arg3 ;
7643 bool result;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 int val2 ;
7647 int ecode2 = 0 ;
7648 int val3 ;
7649 int ecode3 = 0 ;
7650 PyObject * obj0 = 0 ;
7651 PyObject * obj1 = 0 ;
7652 PyObject * obj2 = 0 ;
7653 char * kwnames[] = {
7654 (char *) "self",(char *) "x",(char *) "y", NULL
7655 };
7656
7657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7659 if (!SWIG_IsOK(res1)) {
7660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7661 }
7662 arg1 = reinterpret_cast< wxRect * >(argp1);
7663 ecode2 = SWIG_AsVal_int(obj1, &val2);
7664 if (!SWIG_IsOK(ecode2)) {
7665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7666 }
7667 arg2 = static_cast< int >(val2);
7668 ecode3 = SWIG_AsVal_int(obj2, &val3);
7669 if (!SWIG_IsOK(ecode3)) {
7670 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7671 }
7672 arg3 = static_cast< int >(val3);
7673 {
7674 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7675 if (PyErr_Occurred()) SWIG_fail;
7676 }
7677 {
7678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7679 }
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7687 PyObject *resultobj = 0;
7688 wxRect *arg1 = (wxRect *) 0 ;
7689 wxPoint *arg2 = 0 ;
7690 bool result;
7691 void *argp1 = 0 ;
7692 int res1 = 0 ;
7693 wxPoint temp2 ;
7694 PyObject * obj0 = 0 ;
7695 PyObject * obj1 = 0 ;
7696 char * kwnames[] = {
7697 (char *) "self",(char *) "pt", NULL
7698 };
7699
7700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7702 if (!SWIG_IsOK(res1)) {
7703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7704 }
7705 arg1 = reinterpret_cast< wxRect * >(argp1);
7706 {
7707 arg2 = &temp2;
7708 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7709 }
7710 {
7711 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 {
7715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7716 }
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 wxRect *arg2 = 0 ;
7727 bool result;
7728 void *argp1 = 0 ;
7729 int res1 = 0 ;
7730 wxRect temp2 ;
7731 PyObject * obj0 = 0 ;
7732 PyObject * obj1 = 0 ;
7733 char * kwnames[] = {
7734 (char *) "self",(char *) "rect", NULL
7735 };
7736
7737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) 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_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7741 }
7742 arg1 = reinterpret_cast< wxRect * >(argp1);
7743 {
7744 arg2 = &temp2;
7745 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7746 }
7747 {
7748 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 {
7752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7753 }
7754 return resultobj;
7755 fail:
7756 return NULL;
7757 }
7758
7759
7760 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7761 PyObject *resultobj = 0;
7762 wxRect *arg1 = (wxRect *) 0 ;
7763 wxRect *arg2 = 0 ;
7764 bool result;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 wxRect temp2 ;
7768 PyObject * obj0 = 0 ;
7769 PyObject * obj1 = 0 ;
7770 char * kwnames[] = {
7771 (char *) "self",(char *) "rect", NULL
7772 };
7773
7774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7776 if (!SWIG_IsOK(res1)) {
7777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7778 }
7779 arg1 = reinterpret_cast< wxRect * >(argp1);
7780 {
7781 arg2 = &temp2;
7782 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7783 }
7784 {
7785 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7786 if (PyErr_Occurred()) SWIG_fail;
7787 }
7788 {
7789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7790 }
7791 return resultobj;
7792 fail:
7793 return NULL;
7794 }
7795
7796
7797 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7798 PyObject *resultobj = 0;
7799 wxRect *arg1 = (wxRect *) 0 ;
7800 wxRect *arg2 = 0 ;
7801 int arg3 = (int) wxBOTH ;
7802 wxRect result;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 wxRect temp2 ;
7806 int val3 ;
7807 int ecode3 = 0 ;
7808 PyObject * obj0 = 0 ;
7809 PyObject * obj1 = 0 ;
7810 PyObject * obj2 = 0 ;
7811 char * kwnames[] = {
7812 (char *) "self",(char *) "r",(char *) "dir", NULL
7813 };
7814
7815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7817 if (!SWIG_IsOK(res1)) {
7818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7819 }
7820 arg1 = reinterpret_cast< wxRect * >(argp1);
7821 {
7822 arg2 = &temp2;
7823 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7824 }
7825 if (obj2) {
7826 ecode3 = SWIG_AsVal_int(obj2, &val3);
7827 if (!SWIG_IsOK(ecode3)) {
7828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7829 }
7830 arg3 = static_cast< int >(val3);
7831 }
7832 {
7833 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7844 PyObject *resultobj = 0;
7845 wxRect *arg1 = (wxRect *) 0 ;
7846 int arg2 ;
7847 void *argp1 = 0 ;
7848 int res1 = 0 ;
7849 int val2 ;
7850 int ecode2 = 0 ;
7851 PyObject *swig_obj[2] ;
7852
7853 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7855 if (!SWIG_IsOK(res1)) {
7856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7857 }
7858 arg1 = reinterpret_cast< wxRect * >(argp1);
7859 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7860 if (!SWIG_IsOK(ecode2)) {
7861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7862 }
7863 arg2 = static_cast< int >(val2);
7864 if (arg1) (arg1)->x = arg2;
7865
7866 resultobj = SWIG_Py_Void();
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7874 PyObject *resultobj = 0;
7875 wxRect *arg1 = (wxRect *) 0 ;
7876 int result;
7877 void *argp1 = 0 ;
7878 int res1 = 0 ;
7879 PyObject *swig_obj[1] ;
7880
7881 if (!args) SWIG_fail;
7882 swig_obj[0] = args;
7883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7884 if (!SWIG_IsOK(res1)) {
7885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7886 }
7887 arg1 = reinterpret_cast< wxRect * >(argp1);
7888 result = (int) ((arg1)->x);
7889 resultobj = SWIG_From_int(static_cast< int >(result));
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 PyObject *resultobj = 0;
7898 wxRect *arg1 = (wxRect *) 0 ;
7899 int arg2 ;
7900 void *argp1 = 0 ;
7901 int res1 = 0 ;
7902 int val2 ;
7903 int ecode2 = 0 ;
7904 PyObject *swig_obj[2] ;
7905
7906 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7913 if (!SWIG_IsOK(ecode2)) {
7914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7915 }
7916 arg2 = static_cast< int >(val2);
7917 if (arg1) (arg1)->y = arg2;
7918
7919 resultobj = SWIG_Py_Void();
7920 return resultobj;
7921 fail:
7922 return NULL;
7923 }
7924
7925
7926 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7927 PyObject *resultobj = 0;
7928 wxRect *arg1 = (wxRect *) 0 ;
7929 int result;
7930 void *argp1 = 0 ;
7931 int res1 = 0 ;
7932 PyObject *swig_obj[1] ;
7933
7934 if (!args) SWIG_fail;
7935 swig_obj[0] = args;
7936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7937 if (!SWIG_IsOK(res1)) {
7938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7939 }
7940 arg1 = reinterpret_cast< wxRect * >(argp1);
7941 result = (int) ((arg1)->y);
7942 resultobj = SWIG_From_int(static_cast< int >(result));
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7950 PyObject *resultobj = 0;
7951 wxRect *arg1 = (wxRect *) 0 ;
7952 int arg2 ;
7953 void *argp1 = 0 ;
7954 int res1 = 0 ;
7955 int val2 ;
7956 int ecode2 = 0 ;
7957 PyObject *swig_obj[2] ;
7958
7959 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7961 if (!SWIG_IsOK(res1)) {
7962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7963 }
7964 arg1 = reinterpret_cast< wxRect * >(argp1);
7965 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7966 if (!SWIG_IsOK(ecode2)) {
7967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7968 }
7969 arg2 = static_cast< int >(val2);
7970 if (arg1) (arg1)->width = arg2;
7971
7972 resultobj = SWIG_Py_Void();
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7980 PyObject *resultobj = 0;
7981 wxRect *arg1 = (wxRect *) 0 ;
7982 int result;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 PyObject *swig_obj[1] ;
7986
7987 if (!args) SWIG_fail;
7988 swig_obj[0] = args;
7989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7992 }
7993 arg1 = reinterpret_cast< wxRect * >(argp1);
7994 result = (int) ((arg1)->width);
7995 resultobj = SWIG_From_int(static_cast< int >(result));
7996 return resultobj;
7997 fail:
7998 return NULL;
7999 }
8000
8001
8002 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8003 PyObject *resultobj = 0;
8004 wxRect *arg1 = (wxRect *) 0 ;
8005 int arg2 ;
8006 void *argp1 = 0 ;
8007 int res1 = 0 ;
8008 int val2 ;
8009 int ecode2 = 0 ;
8010 PyObject *swig_obj[2] ;
8011
8012 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8014 if (!SWIG_IsOK(res1)) {
8015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8016 }
8017 arg1 = reinterpret_cast< wxRect * >(argp1);
8018 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8019 if (!SWIG_IsOK(ecode2)) {
8020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8021 }
8022 arg2 = static_cast< int >(val2);
8023 if (arg1) (arg1)->height = arg2;
8024
8025 resultobj = SWIG_Py_Void();
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8033 PyObject *resultobj = 0;
8034 wxRect *arg1 = (wxRect *) 0 ;
8035 int result;
8036 void *argp1 = 0 ;
8037 int res1 = 0 ;
8038 PyObject *swig_obj[1] ;
8039
8040 if (!args) SWIG_fail;
8041 swig_obj[0] = args;
8042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8043 if (!SWIG_IsOK(res1)) {
8044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8045 }
8046 arg1 = reinterpret_cast< wxRect * >(argp1);
8047 result = (int) ((arg1)->height);
8048 resultobj = SWIG_From_int(static_cast< int >(result));
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8056 PyObject *resultobj = 0;
8057 wxRect *arg1 = (wxRect *) 0 ;
8058 int arg2 = (int) 0 ;
8059 int arg3 = (int) 0 ;
8060 int arg4 = (int) 0 ;
8061 int arg5 = (int) 0 ;
8062 void *argp1 = 0 ;
8063 int res1 = 0 ;
8064 int val2 ;
8065 int ecode2 = 0 ;
8066 int val3 ;
8067 int ecode3 = 0 ;
8068 int val4 ;
8069 int ecode4 = 0 ;
8070 int val5 ;
8071 int ecode5 = 0 ;
8072 PyObject * obj0 = 0 ;
8073 PyObject * obj1 = 0 ;
8074 PyObject * obj2 = 0 ;
8075 PyObject * obj3 = 0 ;
8076 PyObject * obj4 = 0 ;
8077 char * kwnames[] = {
8078 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8079 };
8080
8081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8083 if (!SWIG_IsOK(res1)) {
8084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8085 }
8086 arg1 = reinterpret_cast< wxRect * >(argp1);
8087 if (obj1) {
8088 ecode2 = SWIG_AsVal_int(obj1, &val2);
8089 if (!SWIG_IsOK(ecode2)) {
8090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8091 }
8092 arg2 = static_cast< int >(val2);
8093 }
8094 if (obj2) {
8095 ecode3 = SWIG_AsVal_int(obj2, &val3);
8096 if (!SWIG_IsOK(ecode3)) {
8097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8098 }
8099 arg3 = static_cast< int >(val3);
8100 }
8101 if (obj3) {
8102 ecode4 = SWIG_AsVal_int(obj3, &val4);
8103 if (!SWIG_IsOK(ecode4)) {
8104 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8105 }
8106 arg4 = static_cast< int >(val4);
8107 }
8108 if (obj4) {
8109 ecode5 = SWIG_AsVal_int(obj4, &val5);
8110 if (!SWIG_IsOK(ecode5)) {
8111 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8112 }
8113 arg5 = static_cast< int >(val5);
8114 }
8115 {
8116 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_Py_Void();
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8127 PyObject *resultobj = 0;
8128 wxRect *arg1 = (wxRect *) 0 ;
8129 PyObject *result = 0 ;
8130 void *argp1 = 0 ;
8131 int res1 = 0 ;
8132 PyObject *swig_obj[1] ;
8133
8134 if (!args) SWIG_fail;
8135 swig_obj[0] = args;
8136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8137 if (!SWIG_IsOK(res1)) {
8138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8139 }
8140 arg1 = reinterpret_cast< wxRect * >(argp1);
8141 {
8142 result = (PyObject *)wxRect_Get(arg1);
8143 if (PyErr_Occurred()) SWIG_fail;
8144 }
8145 resultobj = result;
8146 return resultobj;
8147 fail:
8148 return NULL;
8149 }
8150
8151
8152 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8153 PyObject *obj;
8154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8155 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8156 return SWIG_Py_Void();
8157 }
8158
8159 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 return SWIG_Python_InitShadowInstance(args);
8161 }
8162
8163 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj = 0;
8165 wxRect *arg1 = (wxRect *) 0 ;
8166 wxRect *arg2 = (wxRect *) 0 ;
8167 PyObject *result = 0 ;
8168 void *argp1 = 0 ;
8169 int res1 = 0 ;
8170 void *argp2 = 0 ;
8171 int res2 = 0 ;
8172 PyObject * obj0 = 0 ;
8173 PyObject * obj1 = 0 ;
8174 char * kwnames[] = {
8175 (char *) "r1",(char *) "r2", NULL
8176 };
8177
8178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8180 if (!SWIG_IsOK(res1)) {
8181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8182 }
8183 arg1 = reinterpret_cast< wxRect * >(argp1);
8184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8185 if (!SWIG_IsOK(res2)) {
8186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8187 }
8188 arg2 = reinterpret_cast< wxRect * >(argp2);
8189 {
8190 if (!wxPyCheckForApp()) SWIG_fail;
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 result = (PyObject *)wxIntersectRect(arg1,arg2);
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 resultobj = result;
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8204 PyObject *resultobj = 0;
8205 double arg1 = (double) 0.0 ;
8206 double arg2 = (double) 0.0 ;
8207 wxPoint2D *result = 0 ;
8208 double val1 ;
8209 int ecode1 = 0 ;
8210 double val2 ;
8211 int ecode2 = 0 ;
8212 PyObject * obj0 = 0 ;
8213 PyObject * obj1 = 0 ;
8214 char * kwnames[] = {
8215 (char *) "x",(char *) "y", NULL
8216 };
8217
8218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8219 if (obj0) {
8220 ecode1 = SWIG_AsVal_double(obj0, &val1);
8221 if (!SWIG_IsOK(ecode1)) {
8222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8223 }
8224 arg1 = static_cast< double >(val1);
8225 }
8226 if (obj1) {
8227 ecode2 = SWIG_AsVal_double(obj1, &val2);
8228 if (!SWIG_IsOK(ecode2)) {
8229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8230 }
8231 arg2 = static_cast< double >(val2);
8232 }
8233 {
8234 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8235 if (PyErr_Occurred()) SWIG_fail;
8236 }
8237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8245 PyObject *resultobj = 0;
8246 wxPoint2D *arg1 = 0 ;
8247 wxPoint2D *result = 0 ;
8248 wxPoint2D temp1 ;
8249 PyObject * obj0 = 0 ;
8250 char * kwnames[] = {
8251 (char *) "pt", NULL
8252 };
8253
8254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8255 {
8256 arg1 = &temp1;
8257 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8258 }
8259 {
8260 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8261 if (PyErr_Occurred()) SWIG_fail;
8262 }
8263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8264 return resultobj;
8265 fail:
8266 return NULL;
8267 }
8268
8269
8270 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8271 PyObject *resultobj = 0;
8272 wxPoint *arg1 = 0 ;
8273 wxPoint2D *result = 0 ;
8274 wxPoint temp1 ;
8275 PyObject * obj0 = 0 ;
8276 char * kwnames[] = {
8277 (char *) "pt", NULL
8278 };
8279
8280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8281 {
8282 arg1 = &temp1;
8283 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8284 }
8285 {
8286 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8297 PyObject *resultobj = 0;
8298 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8299 void *argp1 = 0 ;
8300 int res1 = 0 ;
8301 PyObject *swig_obj[1] ;
8302
8303 if (!args) SWIG_fail;
8304 swig_obj[0] = args;
8305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8306 if (!SWIG_IsOK(res1)) {
8307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8308 }
8309 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8310 {
8311 delete arg1;
8312
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_Py_Void();
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *resultobj = 0;
8324 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8325 int *arg2 = (int *) 0 ;
8326 int *arg3 = (int *) 0 ;
8327 void *argp1 = 0 ;
8328 int res1 = 0 ;
8329 int temp2 ;
8330 int res2 = SWIG_TMPOBJ ;
8331 int temp3 ;
8332 int res3 = SWIG_TMPOBJ ;
8333 PyObject *swig_obj[1] ;
8334
8335 arg2 = &temp2;
8336 arg3 = &temp3;
8337 if (!args) SWIG_fail;
8338 swig_obj[0] = args;
8339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8340 if (!SWIG_IsOK(res1)) {
8341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8342 }
8343 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8344 {
8345 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 resultobj = SWIG_Py_Void();
8349 if (SWIG_IsTmpObj(res2)) {
8350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8351 } else {
8352 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8354 }
8355 if (SWIG_IsTmpObj(res3)) {
8356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8357 } else {
8358 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8360 }
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8368 PyObject *resultobj = 0;
8369 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8370 int *arg2 = (int *) 0 ;
8371 int *arg3 = (int *) 0 ;
8372 void *argp1 = 0 ;
8373 int res1 = 0 ;
8374 int temp2 ;
8375 int res2 = SWIG_TMPOBJ ;
8376 int temp3 ;
8377 int res3 = SWIG_TMPOBJ ;
8378 PyObject *swig_obj[1] ;
8379
8380 arg2 = &temp2;
8381 arg3 = &temp3;
8382 if (!args) SWIG_fail;
8383 swig_obj[0] = args;
8384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8385 if (!SWIG_IsOK(res1)) {
8386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8387 }
8388 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8389 {
8390 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8391 if (PyErr_Occurred()) SWIG_fail;
8392 }
8393 resultobj = SWIG_Py_Void();
8394 if (SWIG_IsTmpObj(res2)) {
8395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8396 } else {
8397 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8399 }
8400 if (SWIG_IsTmpObj(res3)) {
8401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8402 } else {
8403 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8405 }
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8413 PyObject *resultobj = 0;
8414 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8415 double result;
8416 void *argp1 = 0 ;
8417 int res1 = 0 ;
8418 PyObject *swig_obj[1] ;
8419
8420 if (!args) SWIG_fail;
8421 swig_obj[0] = args;
8422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8423 if (!SWIG_IsOK(res1)) {
8424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8425 }
8426 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8427 {
8428 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8429 if (PyErr_Occurred()) SWIG_fail;
8430 }
8431 resultobj = SWIG_From_double(static_cast< double >(result));
8432 return resultobj;
8433 fail:
8434 return NULL;
8435 }
8436
8437
8438 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8439 PyObject *resultobj = 0;
8440 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8441 double result;
8442 void *argp1 = 0 ;
8443 int res1 = 0 ;
8444 PyObject *swig_obj[1] ;
8445
8446 if (!args) SWIG_fail;
8447 swig_obj[0] = args;
8448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8449 if (!SWIG_IsOK(res1)) {
8450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8451 }
8452 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8453 {
8454 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8455 if (PyErr_Occurred()) SWIG_fail;
8456 }
8457 resultobj = SWIG_From_double(static_cast< double >(result));
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj = 0;
8466 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8467 double arg2 ;
8468 void *argp1 = 0 ;
8469 int res1 = 0 ;
8470 double val2 ;
8471 int ecode2 = 0 ;
8472 PyObject * obj0 = 0 ;
8473 PyObject * obj1 = 0 ;
8474 char * kwnames[] = {
8475 (char *) "self",(char *) "length", NULL
8476 };
8477
8478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8480 if (!SWIG_IsOK(res1)) {
8481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8482 }
8483 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8484 ecode2 = SWIG_AsVal_double(obj1, &val2);
8485 if (!SWIG_IsOK(ecode2)) {
8486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8487 }
8488 arg2 = static_cast< double >(val2);
8489 {
8490 (arg1)->SetVectorLength(arg2);
8491 if (PyErr_Occurred()) SWIG_fail;
8492 }
8493 resultobj = SWIG_Py_Void();
8494 return resultobj;
8495 fail:
8496 return NULL;
8497 }
8498
8499
8500 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8501 PyObject *resultobj = 0;
8502 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8503 double arg2 ;
8504 void *argp1 = 0 ;
8505 int res1 = 0 ;
8506 double val2 ;
8507 int ecode2 = 0 ;
8508 PyObject * obj0 = 0 ;
8509 PyObject * obj1 = 0 ;
8510 char * kwnames[] = {
8511 (char *) "self",(char *) "degrees", NULL
8512 };
8513
8514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8516 if (!SWIG_IsOK(res1)) {
8517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8518 }
8519 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8520 ecode2 = SWIG_AsVal_double(obj1, &val2);
8521 if (!SWIG_IsOK(ecode2)) {
8522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8523 }
8524 arg2 = static_cast< double >(val2);
8525 {
8526 (arg1)->SetVectorAngle(arg2);
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_Py_Void();
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 wxPoint2D *arg2 = 0 ;
8540 double result;
8541 void *argp1 = 0 ;
8542 int res1 = 0 ;
8543 wxPoint2D temp2 ;
8544 PyObject * obj0 = 0 ;
8545 PyObject * obj1 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "pt", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8554 }
8555 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8556 {
8557 arg2 = &temp2;
8558 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8559 }
8560 {
8561 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8562 if (PyErr_Occurred()) SWIG_fail;
8563 }
8564 resultobj = SWIG_From_double(static_cast< double >(result));
8565 return resultobj;
8566 fail:
8567 return NULL;
8568 }
8569
8570
8571 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8572 PyObject *resultobj = 0;
8573 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8574 wxPoint2D *arg2 = 0 ;
8575 double result;
8576 void *argp1 = 0 ;
8577 int res1 = 0 ;
8578 wxPoint2D temp2 ;
8579 PyObject * obj0 = 0 ;
8580 PyObject * obj1 = 0 ;
8581 char * kwnames[] = {
8582 (char *) "self",(char *) "pt", NULL
8583 };
8584
8585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8587 if (!SWIG_IsOK(res1)) {
8588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8589 }
8590 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8591 {
8592 arg2 = &temp2;
8593 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8594 }
8595 {
8596 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8597 if (PyErr_Occurred()) SWIG_fail;
8598 }
8599 resultobj = SWIG_From_double(static_cast< double >(result));
8600 return resultobj;
8601 fail:
8602 return NULL;
8603 }
8604
8605
8606 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8607 PyObject *resultobj = 0;
8608 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8609 wxPoint2D *arg2 = 0 ;
8610 double result;
8611 void *argp1 = 0 ;
8612 int res1 = 0 ;
8613 wxPoint2D temp2 ;
8614 PyObject * obj0 = 0 ;
8615 PyObject * obj1 = 0 ;
8616 char * kwnames[] = {
8617 (char *) "self",(char *) "vec", NULL
8618 };
8619
8620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8622 if (!SWIG_IsOK(res1)) {
8623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8624 }
8625 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8626 {
8627 arg2 = &temp2;
8628 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8629 }
8630 {
8631 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8632 if (PyErr_Occurred()) SWIG_fail;
8633 }
8634 resultobj = SWIG_From_double(static_cast< double >(result));
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj = 0;
8643 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8644 wxPoint2D *arg2 = 0 ;
8645 double result;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 wxPoint2D temp2 ;
8649 PyObject * obj0 = 0 ;
8650 PyObject * obj1 = 0 ;
8651 char * kwnames[] = {
8652 (char *) "self",(char *) "vec", NULL
8653 };
8654
8655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8657 if (!SWIG_IsOK(res1)) {
8658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8659 }
8660 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8661 {
8662 arg2 = &temp2;
8663 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8664 }
8665 {
8666 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8667 if (PyErr_Occurred()) SWIG_fail;
8668 }
8669 resultobj = SWIG_From_double(static_cast< double >(result));
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8677 PyObject *resultobj = 0;
8678 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8679 wxPoint2D result;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 PyObject *swig_obj[1] ;
8683
8684 if (!args) SWIG_fail;
8685 swig_obj[0] = args;
8686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8689 }
8690 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8691 {
8692 result = (arg1)->operator -();
8693 if (PyErr_Occurred()) SWIG_fail;
8694 }
8695 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8696 return resultobj;
8697 fail:
8698 return NULL;
8699 }
8700
8701
8702 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8703 PyObject *resultobj = 0;
8704 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8705 wxPoint2D *arg2 = 0 ;
8706 wxPoint2D *result = 0 ;
8707 void *argp1 = 0 ;
8708 int res1 = 0 ;
8709 wxPoint2D temp2 ;
8710 PyObject * obj0 = 0 ;
8711 PyObject * obj1 = 0 ;
8712 char * kwnames[] = {
8713 (char *) "self",(char *) "pt", NULL
8714 };
8715
8716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8718 if (!SWIG_IsOK(res1)) {
8719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8720 }
8721 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8722 {
8723 arg2 = &temp2;
8724 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8725 }
8726 {
8727 {
8728 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8729 result = (wxPoint2D *) &_result_ref;
8730 }
8731 if (PyErr_Occurred()) SWIG_fail;
8732 }
8733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8734 return resultobj;
8735 fail:
8736 return NULL;
8737 }
8738
8739
8740 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8741 PyObject *resultobj = 0;
8742 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8743 wxPoint2D *arg2 = 0 ;
8744 wxPoint2D *result = 0 ;
8745 void *argp1 = 0 ;
8746 int res1 = 0 ;
8747 wxPoint2D temp2 ;
8748 PyObject * obj0 = 0 ;
8749 PyObject * obj1 = 0 ;
8750 char * kwnames[] = {
8751 (char *) "self",(char *) "pt", NULL
8752 };
8753
8754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8756 if (!SWIG_IsOK(res1)) {
8757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8758 }
8759 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8760 {
8761 arg2 = &temp2;
8762 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8763 }
8764 {
8765 {
8766 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8767 result = (wxPoint2D *) &_result_ref;
8768 }
8769 if (PyErr_Occurred()) SWIG_fail;
8770 }
8771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8772 return resultobj;
8773 fail:
8774 return NULL;
8775 }
8776
8777
8778 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8779 PyObject *resultobj = 0;
8780 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8781 wxPoint2D *arg2 = 0 ;
8782 wxPoint2D *result = 0 ;
8783 void *argp1 = 0 ;
8784 int res1 = 0 ;
8785 wxPoint2D temp2 ;
8786 PyObject * obj0 = 0 ;
8787 PyObject * obj1 = 0 ;
8788 char * kwnames[] = {
8789 (char *) "self",(char *) "pt", NULL
8790 };
8791
8792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8794 if (!SWIG_IsOK(res1)) {
8795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8796 }
8797 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8798 {
8799 arg2 = &temp2;
8800 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8801 }
8802 {
8803 {
8804 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8805 result = (wxPoint2D *) &_result_ref;
8806 }
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj = 0;
8818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8819 wxPoint2D *arg2 = 0 ;
8820 wxPoint2D *result = 0 ;
8821 void *argp1 = 0 ;
8822 int res1 = 0 ;
8823 wxPoint2D temp2 ;
8824 PyObject * obj0 = 0 ;
8825 PyObject * obj1 = 0 ;
8826 char * kwnames[] = {
8827 (char *) "self",(char *) "pt", NULL
8828 };
8829
8830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8832 if (!SWIG_IsOK(res1)) {
8833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8834 }
8835 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8836 {
8837 arg2 = &temp2;
8838 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8839 }
8840 {
8841 {
8842 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8843 result = (wxPoint2D *) &_result_ref;
8844 }
8845 if (PyErr_Occurred()) SWIG_fail;
8846 }
8847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8848 return resultobj;
8849 fail:
8850 return NULL;
8851 }
8852
8853
8854 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8855 PyObject *resultobj = 0;
8856 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8857 PyObject *arg2 = (PyObject *) 0 ;
8858 bool result;
8859 void *argp1 = 0 ;
8860 int res1 = 0 ;
8861 PyObject * obj0 = 0 ;
8862 PyObject * obj1 = 0 ;
8863 char * kwnames[] = {
8864 (char *) "self",(char *) "other", NULL
8865 };
8866
8867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8869 if (!SWIG_IsOK(res1)) {
8870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8871 }
8872 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8873 arg2 = obj1;
8874 {
8875 result = (bool)wxPoint2D___eq__(arg1,arg2);
8876 if (PyErr_Occurred()) SWIG_fail;
8877 }
8878 {
8879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8880 }
8881 return resultobj;
8882 fail:
8883 return NULL;
8884 }
8885
8886
8887 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8888 PyObject *resultobj = 0;
8889 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8890 PyObject *arg2 = (PyObject *) 0 ;
8891 bool result;
8892 void *argp1 = 0 ;
8893 int res1 = 0 ;
8894 PyObject * obj0 = 0 ;
8895 PyObject * obj1 = 0 ;
8896 char * kwnames[] = {
8897 (char *) "self",(char *) "other", NULL
8898 };
8899
8900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8902 if (!SWIG_IsOK(res1)) {
8903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8904 }
8905 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8906 arg2 = obj1;
8907 {
8908 result = (bool)wxPoint2D___ne__(arg1,arg2);
8909 if (PyErr_Occurred()) SWIG_fail;
8910 }
8911 {
8912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8913 }
8914 return resultobj;
8915 fail:
8916 return NULL;
8917 }
8918
8919
8920 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8921 PyObject *resultobj = 0;
8922 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8923 double arg2 ;
8924 void *argp1 = 0 ;
8925 int res1 = 0 ;
8926 double val2 ;
8927 int ecode2 = 0 ;
8928 PyObject *swig_obj[2] ;
8929
8930 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8934 }
8935 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8936 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8937 if (!SWIG_IsOK(ecode2)) {
8938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8939 }
8940 arg2 = static_cast< double >(val2);
8941 if (arg1) (arg1)->m_x = arg2;
8942
8943 resultobj = SWIG_Py_Void();
8944 return resultobj;
8945 fail:
8946 return NULL;
8947 }
8948
8949
8950 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 PyObject *resultobj = 0;
8952 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8953 double result;
8954 void *argp1 = 0 ;
8955 int res1 = 0 ;
8956 PyObject *swig_obj[1] ;
8957
8958 if (!args) SWIG_fail;
8959 swig_obj[0] = args;
8960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8961 if (!SWIG_IsOK(res1)) {
8962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8963 }
8964 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8965 result = (double) ((arg1)->m_x);
8966 resultobj = SWIG_From_double(static_cast< double >(result));
8967 return resultobj;
8968 fail:
8969 return NULL;
8970 }
8971
8972
8973 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8974 PyObject *resultobj = 0;
8975 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8976 double arg2 ;
8977 void *argp1 = 0 ;
8978 int res1 = 0 ;
8979 double val2 ;
8980 int ecode2 = 0 ;
8981 PyObject *swig_obj[2] ;
8982
8983 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8985 if (!SWIG_IsOK(res1)) {
8986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8987 }
8988 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8989 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8990 if (!SWIG_IsOK(ecode2)) {
8991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8992 }
8993 arg2 = static_cast< double >(val2);
8994 if (arg1) (arg1)->m_y = arg2;
8995
8996 resultobj = SWIG_Py_Void();
8997 return resultobj;
8998 fail:
8999 return NULL;
9000 }
9001
9002
9003 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9004 PyObject *resultobj = 0;
9005 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9006 double result;
9007 void *argp1 = 0 ;
9008 int res1 = 0 ;
9009 PyObject *swig_obj[1] ;
9010
9011 if (!args) SWIG_fail;
9012 swig_obj[0] = args;
9013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9014 if (!SWIG_IsOK(res1)) {
9015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9016 }
9017 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9018 result = (double) ((arg1)->m_y);
9019 resultobj = SWIG_From_double(static_cast< double >(result));
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj = 0;
9028 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9029 double arg2 = (double) 0 ;
9030 double arg3 = (double) 0 ;
9031 void *argp1 = 0 ;
9032 int res1 = 0 ;
9033 double val2 ;
9034 int ecode2 = 0 ;
9035 double val3 ;
9036 int ecode3 = 0 ;
9037 PyObject * obj0 = 0 ;
9038 PyObject * obj1 = 0 ;
9039 PyObject * obj2 = 0 ;
9040 char * kwnames[] = {
9041 (char *) "self",(char *) "x",(char *) "y", NULL
9042 };
9043
9044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9046 if (!SWIG_IsOK(res1)) {
9047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9048 }
9049 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9050 if (obj1) {
9051 ecode2 = SWIG_AsVal_double(obj1, &val2);
9052 if (!SWIG_IsOK(ecode2)) {
9053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9054 }
9055 arg2 = static_cast< double >(val2);
9056 }
9057 if (obj2) {
9058 ecode3 = SWIG_AsVal_double(obj2, &val3);
9059 if (!SWIG_IsOK(ecode3)) {
9060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9061 }
9062 arg3 = static_cast< double >(val3);
9063 }
9064 {
9065 wxPoint2D_Set(arg1,arg2,arg3);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = SWIG_Py_Void();
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076 PyObject *resultobj = 0;
9077 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9078 PyObject *result = 0 ;
9079 void *argp1 = 0 ;
9080 int res1 = 0 ;
9081 PyObject *swig_obj[1] ;
9082
9083 if (!args) SWIG_fail;
9084 swig_obj[0] = args;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9090 {
9091 result = (PyObject *)wxPoint2D_Get(arg1);
9092 if (PyErr_Occurred()) SWIG_fail;
9093 }
9094 resultobj = result;
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 PyObject *obj;
9103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9104 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9105 return SWIG_Py_Void();
9106 }
9107
9108 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9109 return SWIG_Python_InitShadowInstance(args);
9110 }
9111
9112 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9113 PyObject *resultobj = 0;
9114 wxDouble arg1 = (wxDouble) 0.0 ;
9115 wxDouble arg2 = (wxDouble) 0.0 ;
9116 wxDouble arg3 = (wxDouble) 0.0 ;
9117 wxDouble arg4 = (wxDouble) 0.0 ;
9118 wxRect2D *result = 0 ;
9119 void *argp1 ;
9120 int res1 = 0 ;
9121 void *argp2 ;
9122 int res2 = 0 ;
9123 void *argp3 ;
9124 int res3 = 0 ;
9125 void *argp4 ;
9126 int res4 = 0 ;
9127 PyObject * obj0 = 0 ;
9128 PyObject * obj1 = 0 ;
9129 PyObject * obj2 = 0 ;
9130 PyObject * obj3 = 0 ;
9131 char * kwnames[] = {
9132 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9133 };
9134
9135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9136 if (obj0) {
9137 {
9138 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9141 }
9142 if (!argp1) {
9143 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9144 } else {
9145 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9146 arg1 = *temp;
9147 if (SWIG_IsNewObj(res1)) delete temp;
9148 }
9149 }
9150 }
9151 if (obj1) {
9152 {
9153 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9154 if (!SWIG_IsOK(res2)) {
9155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9156 }
9157 if (!argp2) {
9158 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9159 } else {
9160 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9161 arg2 = *temp;
9162 if (SWIG_IsNewObj(res2)) delete temp;
9163 }
9164 }
9165 }
9166 if (obj2) {
9167 {
9168 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9169 if (!SWIG_IsOK(res3)) {
9170 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9171 }
9172 if (!argp3) {
9173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9174 } else {
9175 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9176 arg3 = *temp;
9177 if (SWIG_IsNewObj(res3)) delete temp;
9178 }
9179 }
9180 }
9181 if (obj3) {
9182 {
9183 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9184 if (!SWIG_IsOK(res4)) {
9185 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9186 }
9187 if (!argp4) {
9188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9189 } else {
9190 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9191 arg4 = *temp;
9192 if (SWIG_IsNewObj(res4)) delete temp;
9193 }
9194 }
9195 }
9196 {
9197 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9198 if (PyErr_Occurred()) SWIG_fail;
9199 }
9200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9201 return resultobj;
9202 fail:
9203 return NULL;
9204 }
9205
9206
9207 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9208 PyObject *resultobj = 0;
9209 wxRect2D *arg1 = (wxRect2D *) 0 ;
9210 void *argp1 = 0 ;
9211 int res1 = 0 ;
9212 PyObject *swig_obj[1] ;
9213
9214 if (!args) SWIG_fail;
9215 swig_obj[0] = args;
9216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9219 }
9220 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9221 {
9222 delete arg1;
9223
9224 if (PyErr_Occurred()) SWIG_fail;
9225 }
9226 resultobj = SWIG_Py_Void();
9227 return resultobj;
9228 fail:
9229 return NULL;
9230 }
9231
9232
9233 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 PyObject *resultobj = 0;
9235 wxRect2D *arg1 = (wxRect2D *) 0 ;
9236 wxPoint2D result;
9237 void *argp1 = 0 ;
9238 int res1 = 0 ;
9239 PyObject *swig_obj[1] ;
9240
9241 if (!args) SWIG_fail;
9242 swig_obj[0] = args;
9243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9246 }
9247 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9248 {
9249 result = (arg1)->GetPosition();
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9260 PyObject *resultobj = 0;
9261 wxRect2D *arg1 = (wxRect2D *) 0 ;
9262 wxSize result;
9263 void *argp1 = 0 ;
9264 int res1 = 0 ;
9265 PyObject *swig_obj[1] ;
9266
9267 if (!args) SWIG_fail;
9268 swig_obj[0] = args;
9269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9270 if (!SWIG_IsOK(res1)) {
9271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9272 }
9273 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9274 {
9275 result = (arg1)->GetSize();
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9279 return resultobj;
9280 fail:
9281 return NULL;
9282 }
9283
9284
9285 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286 PyObject *resultobj = 0;
9287 wxRect2D *arg1 = (wxRect2D *) 0 ;
9288 wxDouble result;
9289 void *argp1 = 0 ;
9290 int res1 = 0 ;
9291 PyObject *swig_obj[1] ;
9292
9293 if (!args) SWIG_fail;
9294 swig_obj[0] = args;
9295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9296 if (!SWIG_IsOK(res1)) {
9297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9298 }
9299 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9300 {
9301 result = ((wxRect2D const *)arg1)->GetLeft();
9302 if (PyErr_Occurred()) SWIG_fail;
9303 }
9304 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9305 return resultobj;
9306 fail:
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj = 0;
9313 wxRect2D *arg1 = (wxRect2D *) 0 ;
9314 wxDouble arg2 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 void *argp2 ;
9318 int res2 = 0 ;
9319 PyObject * obj0 = 0 ;
9320 PyObject * obj1 = 0 ;
9321 char * kwnames[] = {
9322 (char *) "self",(char *) "n", NULL
9323 };
9324
9325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9329 }
9330 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9331 {
9332 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9333 if (!SWIG_IsOK(res2)) {
9334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9335 }
9336 if (!argp2) {
9337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9338 } else {
9339 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9340 arg2 = *temp;
9341 if (SWIG_IsNewObj(res2)) delete temp;
9342 }
9343 }
9344 {
9345 (arg1)->SetLeft(arg2);
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_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj = 0;
9357 wxRect2D *arg1 = (wxRect2D *) 0 ;
9358 wxDouble arg2 ;
9359 void *argp1 = 0 ;
9360 int res1 = 0 ;
9361 void *argp2 ;
9362 int res2 = 0 ;
9363 PyObject * obj0 = 0 ;
9364 PyObject * obj1 = 0 ;
9365 char * kwnames[] = {
9366 (char *) "self",(char *) "n", NULL
9367 };
9368
9369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9373 }
9374 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9375 {
9376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9377 if (!SWIG_IsOK(res2)) {
9378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9379 }
9380 if (!argp2) {
9381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9382 } else {
9383 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9384 arg2 = *temp;
9385 if (SWIG_IsNewObj(res2)) delete temp;
9386 }
9387 }
9388 {
9389 (arg1)->MoveLeftTo(arg2);
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 resultobj = SWIG_Py_Void();
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxRect2D *arg1 = (wxRect2D *) 0 ;
9402 wxDouble result;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 PyObject *swig_obj[1] ;
9406
9407 if (!args) SWIG_fail;
9408 swig_obj[0] = args;
9409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9412 }
9413 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9414 {
9415 result = ((wxRect2D const *)arg1)->GetTop();
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj = 0;
9427 wxRect2D *arg1 = (wxRect2D *) 0 ;
9428 wxDouble arg2 ;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 void *argp2 ;
9432 int res2 = 0 ;
9433 PyObject * obj0 = 0 ;
9434 PyObject * obj1 = 0 ;
9435 char * kwnames[] = {
9436 (char *) "self",(char *) "n", NULL
9437 };
9438
9439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9441 if (!SWIG_IsOK(res1)) {
9442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9443 }
9444 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9445 {
9446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9447 if (!SWIG_IsOK(res2)) {
9448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9449 }
9450 if (!argp2) {
9451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9452 } else {
9453 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9454 arg2 = *temp;
9455 if (SWIG_IsNewObj(res2)) delete temp;
9456 }
9457 }
9458 {
9459 (arg1)->SetTop(arg2);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 resultobj = SWIG_Py_Void();
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9470 PyObject *resultobj = 0;
9471 wxRect2D *arg1 = (wxRect2D *) 0 ;
9472 wxDouble arg2 ;
9473 void *argp1 = 0 ;
9474 int res1 = 0 ;
9475 void *argp2 ;
9476 int res2 = 0 ;
9477 PyObject * obj0 = 0 ;
9478 PyObject * obj1 = 0 ;
9479 char * kwnames[] = {
9480 (char *) "self",(char *) "n", NULL
9481 };
9482
9483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9487 }
9488 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9489 {
9490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9491 if (!SWIG_IsOK(res2)) {
9492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9493 }
9494 if (!argp2) {
9495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9496 } else {
9497 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9498 arg2 = *temp;
9499 if (SWIG_IsNewObj(res2)) delete temp;
9500 }
9501 }
9502 {
9503 (arg1)->MoveTopTo(arg2);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 PyObject *resultobj = 0;
9515 wxRect2D *arg1 = (wxRect2D *) 0 ;
9516 wxDouble result;
9517 void *argp1 = 0 ;
9518 int res1 = 0 ;
9519 PyObject *swig_obj[1] ;
9520
9521 if (!args) SWIG_fail;
9522 swig_obj[0] = args;
9523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9526 }
9527 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9528 {
9529 result = ((wxRect2D const *)arg1)->GetBottom();
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj = 0;
9541 wxRect2D *arg1 = (wxRect2D *) 0 ;
9542 wxDouble arg2 ;
9543 void *argp1 = 0 ;
9544 int res1 = 0 ;
9545 void *argp2 ;
9546 int res2 = 0 ;
9547 PyObject * obj0 = 0 ;
9548 PyObject * obj1 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "n", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9557 }
9558 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9559 {
9560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9561 if (!SWIG_IsOK(res2)) {
9562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9563 }
9564 if (!argp2) {
9565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9566 } else {
9567 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9568 arg2 = *temp;
9569 if (SWIG_IsNewObj(res2)) delete temp;
9570 }
9571 }
9572 {
9573 (arg1)->SetBottom(arg2);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_Py_Void();
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj = 0;
9585 wxRect2D *arg1 = (wxRect2D *) 0 ;
9586 wxDouble arg2 ;
9587 void *argp1 = 0 ;
9588 int res1 = 0 ;
9589 void *argp2 ;
9590 int res2 = 0 ;
9591 PyObject * obj0 = 0 ;
9592 PyObject * obj1 = 0 ;
9593 char * kwnames[] = {
9594 (char *) "self",(char *) "n", NULL
9595 };
9596
9597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9599 if (!SWIG_IsOK(res1)) {
9600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9601 }
9602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9603 {
9604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9605 if (!SWIG_IsOK(res2)) {
9606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9607 }
9608 if (!argp2) {
9609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9610 } else {
9611 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9612 arg2 = *temp;
9613 if (SWIG_IsNewObj(res2)) delete temp;
9614 }
9615 }
9616 {
9617 (arg1)->MoveBottomTo(arg2);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 resultobj = SWIG_Py_Void();
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9628 PyObject *resultobj = 0;
9629 wxRect2D *arg1 = (wxRect2D *) 0 ;
9630 wxDouble result;
9631 void *argp1 = 0 ;
9632 int res1 = 0 ;
9633 PyObject *swig_obj[1] ;
9634
9635 if (!args) SWIG_fail;
9636 swig_obj[0] = args;
9637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9638 if (!SWIG_IsOK(res1)) {
9639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9640 }
9641 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9642 {
9643 result = ((wxRect2D const *)arg1)->GetRight();
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj = 0;
9655 wxRect2D *arg1 = (wxRect2D *) 0 ;
9656 wxDouble arg2 ;
9657 void *argp1 = 0 ;
9658 int res1 = 0 ;
9659 void *argp2 ;
9660 int res2 = 0 ;
9661 PyObject * obj0 = 0 ;
9662 PyObject * obj1 = 0 ;
9663 char * kwnames[] = {
9664 (char *) "self",(char *) "n", NULL
9665 };
9666
9667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9669 if (!SWIG_IsOK(res1)) {
9670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9671 }
9672 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9673 {
9674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9675 if (!SWIG_IsOK(res2)) {
9676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9677 }
9678 if (!argp2) {
9679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9680 } else {
9681 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9682 arg2 = *temp;
9683 if (SWIG_IsNewObj(res2)) delete temp;
9684 }
9685 }
9686 {
9687 (arg1)->SetRight(arg2);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj = 0;
9699 wxRect2D *arg1 = (wxRect2D *) 0 ;
9700 wxDouble arg2 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 void *argp2 ;
9704 int res2 = 0 ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char * kwnames[] = {
9708 (char *) "self",(char *) "n", NULL
9709 };
9710
9711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9715 }
9716 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9717 {
9718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9719 if (!SWIG_IsOK(res2)) {
9720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9721 }
9722 if (!argp2) {
9723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9724 } else {
9725 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9726 arg2 = *temp;
9727 if (SWIG_IsNewObj(res2)) delete temp;
9728 }
9729 }
9730 {
9731 (arg1)->MoveRightTo(arg2);
9732 if (PyErr_Occurred()) SWIG_fail;
9733 }
9734 resultobj = SWIG_Py_Void();
9735 return resultobj;
9736 fail:
9737 return NULL;
9738 }
9739
9740
9741 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9742 PyObject *resultobj = 0;
9743 wxRect2D *arg1 = (wxRect2D *) 0 ;
9744 wxPoint2D result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 PyObject *swig_obj[1] ;
9748
9749 if (!args) SWIG_fail;
9750 swig_obj[0] = args;
9751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9754 }
9755 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9756 {
9757 result = ((wxRect2D const *)arg1)->GetLeftTop();
9758 if (PyErr_Occurred()) SWIG_fail;
9759 }
9760 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9768 PyObject *resultobj = 0;
9769 wxRect2D *arg1 = (wxRect2D *) 0 ;
9770 wxPoint2D *arg2 = 0 ;
9771 void *argp1 = 0 ;
9772 int res1 = 0 ;
9773 wxPoint2D temp2 ;
9774 PyObject * obj0 = 0 ;
9775 PyObject * obj1 = 0 ;
9776 char * kwnames[] = {
9777 (char *) "self",(char *) "pt", NULL
9778 };
9779
9780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9784 }
9785 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9786 {
9787 arg2 = &temp2;
9788 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9789 }
9790 {
9791 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 resultobj = SWIG_Py_Void();
9795 return resultobj;
9796 fail:
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9802 PyObject *resultobj = 0;
9803 wxRect2D *arg1 = (wxRect2D *) 0 ;
9804 wxPoint2D *arg2 = 0 ;
9805 void *argp1 = 0 ;
9806 int res1 = 0 ;
9807 wxPoint2D temp2 ;
9808 PyObject * obj0 = 0 ;
9809 PyObject * obj1 = 0 ;
9810 char * kwnames[] = {
9811 (char *) "self",(char *) "pt", NULL
9812 };
9813
9814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9816 if (!SWIG_IsOK(res1)) {
9817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9818 }
9819 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9820 {
9821 arg2 = &temp2;
9822 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9823 }
9824 {
9825 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9826 if (PyErr_Occurred()) SWIG_fail;
9827 }
9828 resultobj = SWIG_Py_Void();
9829 return resultobj;
9830 fail:
9831 return NULL;
9832 }
9833
9834
9835 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9836 PyObject *resultobj = 0;
9837 wxRect2D *arg1 = (wxRect2D *) 0 ;
9838 wxPoint2D result;
9839 void *argp1 = 0 ;
9840 int res1 = 0 ;
9841 PyObject *swig_obj[1] ;
9842
9843 if (!args) SWIG_fail;
9844 swig_obj[0] = args;
9845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9846 if (!SWIG_IsOK(res1)) {
9847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9848 }
9849 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9850 {
9851 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9852 if (PyErr_Occurred()) SWIG_fail;
9853 }
9854 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9862 PyObject *resultobj = 0;
9863 wxRect2D *arg1 = (wxRect2D *) 0 ;
9864 wxPoint2D *arg2 = 0 ;
9865 void *argp1 = 0 ;
9866 int res1 = 0 ;
9867 wxPoint2D temp2 ;
9868 PyObject * obj0 = 0 ;
9869 PyObject * obj1 = 0 ;
9870 char * kwnames[] = {
9871 (char *) "self",(char *) "pt", NULL
9872 };
9873
9874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9878 }
9879 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9880 {
9881 arg2 = &temp2;
9882 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9883 }
9884 {
9885 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 resultobj = SWIG_Py_Void();
9889 return resultobj;
9890 fail:
9891 return NULL;
9892 }
9893
9894
9895 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9896 PyObject *resultobj = 0;
9897 wxRect2D *arg1 = (wxRect2D *) 0 ;
9898 wxPoint2D *arg2 = 0 ;
9899 void *argp1 = 0 ;
9900 int res1 = 0 ;
9901 wxPoint2D temp2 ;
9902 PyObject * obj0 = 0 ;
9903 PyObject * obj1 = 0 ;
9904 char * kwnames[] = {
9905 (char *) "self",(char *) "pt", NULL
9906 };
9907
9908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9910 if (!SWIG_IsOK(res1)) {
9911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9912 }
9913 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9914 {
9915 arg2 = &temp2;
9916 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9917 }
9918 {
9919 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 resultobj = SWIG_Py_Void();
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *resultobj = 0;
9931 wxRect2D *arg1 = (wxRect2D *) 0 ;
9932 wxPoint2D result;
9933 void *argp1 = 0 ;
9934 int res1 = 0 ;
9935 PyObject *swig_obj[1] ;
9936
9937 if (!args) SWIG_fail;
9938 swig_obj[0] = args;
9939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9940 if (!SWIG_IsOK(res1)) {
9941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9942 }
9943 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9944 {
9945 result = ((wxRect2D const *)arg1)->GetRightTop();
9946 if (PyErr_Occurred()) SWIG_fail;
9947 }
9948 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9949 return resultobj;
9950 fail:
9951 return NULL;
9952 }
9953
9954
9955 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9956 PyObject *resultobj = 0;
9957 wxRect2D *arg1 = (wxRect2D *) 0 ;
9958 wxPoint2D *arg2 = 0 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 wxPoint2D temp2 ;
9962 PyObject * obj0 = 0 ;
9963 PyObject * obj1 = 0 ;
9964 char * kwnames[] = {
9965 (char *) "self",(char *) "pt", NULL
9966 };
9967
9968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9970 if (!SWIG_IsOK(res1)) {
9971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9972 }
9973 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9974 {
9975 arg2 = &temp2;
9976 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9977 }
9978 {
9979 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 resultobj = SWIG_Py_Void();
9983 return resultobj;
9984 fail:
9985 return NULL;
9986 }
9987
9988
9989 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9990 PyObject *resultobj = 0;
9991 wxRect2D *arg1 = (wxRect2D *) 0 ;
9992 wxPoint2D *arg2 = 0 ;
9993 void *argp1 = 0 ;
9994 int res1 = 0 ;
9995 wxPoint2D temp2 ;
9996 PyObject * obj0 = 0 ;
9997 PyObject * obj1 = 0 ;
9998 char * kwnames[] = {
9999 (char *) "self",(char *) "pt", NULL
10000 };
10001
10002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10006 }
10007 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10008 {
10009 arg2 = &temp2;
10010 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10011 }
10012 {
10013 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10014 if (PyErr_Occurred()) SWIG_fail;
10015 }
10016 resultobj = SWIG_Py_Void();
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10024 PyObject *resultobj = 0;
10025 wxRect2D *arg1 = (wxRect2D *) 0 ;
10026 wxPoint2D result;
10027 void *argp1 = 0 ;
10028 int res1 = 0 ;
10029 PyObject *swig_obj[1] ;
10030
10031 if (!args) SWIG_fail;
10032 swig_obj[0] = args;
10033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10034 if (!SWIG_IsOK(res1)) {
10035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10036 }
10037 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10038 {
10039 result = ((wxRect2D const *)arg1)->GetRightBottom();
10040 if (PyErr_Occurred()) SWIG_fail;
10041 }
10042 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10043 return resultobj;
10044 fail:
10045 return NULL;
10046 }
10047
10048
10049 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj = 0;
10051 wxRect2D *arg1 = (wxRect2D *) 0 ;
10052 wxPoint2D *arg2 = 0 ;
10053 void *argp1 = 0 ;
10054 int res1 = 0 ;
10055 wxPoint2D temp2 ;
10056 PyObject * obj0 = 0 ;
10057 PyObject * obj1 = 0 ;
10058 char * kwnames[] = {
10059 (char *) "self",(char *) "pt", NULL
10060 };
10061
10062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10066 }
10067 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10068 {
10069 arg2 = &temp2;
10070 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10071 }
10072 {
10073 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 resultobj = SWIG_Py_Void();
10077 return resultobj;
10078 fail:
10079 return NULL;
10080 }
10081
10082
10083 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10084 PyObject *resultobj = 0;
10085 wxRect2D *arg1 = (wxRect2D *) 0 ;
10086 wxPoint2D *arg2 = 0 ;
10087 void *argp1 = 0 ;
10088 int res1 = 0 ;
10089 wxPoint2D temp2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char * kwnames[] = {
10093 (char *) "self",(char *) "pt", NULL
10094 };
10095
10096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10098 if (!SWIG_IsOK(res1)) {
10099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10100 }
10101 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10102 {
10103 arg2 = &temp2;
10104 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10105 }
10106 {
10107 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 resultobj = SWIG_Py_Void();
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 PyObject *resultobj = 0;
10119 wxRect2D *arg1 = (wxRect2D *) 0 ;
10120 wxPoint2D result;
10121 void *argp1 = 0 ;
10122 int res1 = 0 ;
10123 PyObject *swig_obj[1] ;
10124
10125 if (!args) SWIG_fail;
10126 swig_obj[0] = args;
10127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10128 if (!SWIG_IsOK(res1)) {
10129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10130 }
10131 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10132 {
10133 result = ((wxRect2D const *)arg1)->GetCentre();
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10137 return resultobj;
10138 fail:
10139 return NULL;
10140 }
10141
10142
10143 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10144 PyObject *resultobj = 0;
10145 wxRect2D *arg1 = (wxRect2D *) 0 ;
10146 wxPoint2D *arg2 = 0 ;
10147 void *argp1 = 0 ;
10148 int res1 = 0 ;
10149 wxPoint2D temp2 ;
10150 PyObject * obj0 = 0 ;
10151 PyObject * obj1 = 0 ;
10152 char * kwnames[] = {
10153 (char *) "self",(char *) "pt", NULL
10154 };
10155
10156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10158 if (!SWIG_IsOK(res1)) {
10159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10160 }
10161 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10162 {
10163 arg2 = &temp2;
10164 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10165 }
10166 {
10167 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10168 if (PyErr_Occurred()) SWIG_fail;
10169 }
10170 resultobj = SWIG_Py_Void();
10171 return resultobj;
10172 fail:
10173 return NULL;
10174 }
10175
10176
10177 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10178 PyObject *resultobj = 0;
10179 wxRect2D *arg1 = (wxRect2D *) 0 ;
10180 wxPoint2D *arg2 = 0 ;
10181 void *argp1 = 0 ;
10182 int res1 = 0 ;
10183 wxPoint2D temp2 ;
10184 PyObject * obj0 = 0 ;
10185 PyObject * obj1 = 0 ;
10186 char * kwnames[] = {
10187 (char *) "self",(char *) "pt", NULL
10188 };
10189
10190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10194 }
10195 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10196 {
10197 arg2 = &temp2;
10198 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10199 }
10200 {
10201 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 resultobj = SWIG_Py_Void();
10205 return resultobj;
10206 fail:
10207 return NULL;
10208 }
10209
10210
10211 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = 0;
10213 wxRect2D *arg1 = (wxRect2D *) 0 ;
10214 wxPoint2D *arg2 = 0 ;
10215 wxOutCode result;
10216 void *argp1 = 0 ;
10217 int res1 = 0 ;
10218 wxPoint2D temp2 ;
10219 PyObject * obj0 = 0 ;
10220 PyObject * obj1 = 0 ;
10221 char * kwnames[] = {
10222 (char *) "self",(char *) "pt", NULL
10223 };
10224
10225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10227 if (!SWIG_IsOK(res1)) {
10228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10229 }
10230 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10231 {
10232 arg2 = &temp2;
10233 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10234 }
10235 {
10236 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10237 if (PyErr_Occurred()) SWIG_fail;
10238 }
10239 resultobj = SWIG_From_int(static_cast< int >(result));
10240 return resultobj;
10241 fail:
10242 return NULL;
10243 }
10244
10245
10246 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10247 PyObject *resultobj = 0;
10248 wxRect2D *arg1 = (wxRect2D *) 0 ;
10249 wxPoint2D *arg2 = 0 ;
10250 bool result;
10251 void *argp1 = 0 ;
10252 int res1 = 0 ;
10253 wxPoint2D temp2 ;
10254 PyObject * obj0 = 0 ;
10255 PyObject * obj1 = 0 ;
10256 char * kwnames[] = {
10257 (char *) "self",(char *) "pt", NULL
10258 };
10259
10260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10262 if (!SWIG_IsOK(res1)) {
10263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10264 }
10265 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10266 {
10267 arg2 = &temp2;
10268 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10269 }
10270 {
10271 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10272 if (PyErr_Occurred()) SWIG_fail;
10273 }
10274 {
10275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10276 }
10277 return resultobj;
10278 fail:
10279 return NULL;
10280 }
10281
10282
10283 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10284 PyObject *resultobj = 0;
10285 wxRect2D *arg1 = (wxRect2D *) 0 ;
10286 wxRect2D *arg2 = 0 ;
10287 bool result;
10288 void *argp1 = 0 ;
10289 int res1 = 0 ;
10290 wxRect2D temp2 ;
10291 PyObject * obj0 = 0 ;
10292 PyObject * obj1 = 0 ;
10293 char * kwnames[] = {
10294 (char *) "self",(char *) "rect", NULL
10295 };
10296
10297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10299 if (!SWIG_IsOK(res1)) {
10300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10301 }
10302 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10303 {
10304 arg2 = &temp2;
10305 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10306 }
10307 {
10308 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 {
10312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10313 }
10314 return resultobj;
10315 fail:
10316 return NULL;
10317 }
10318
10319
10320 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10321 PyObject *resultobj = 0;
10322 wxRect2D *arg1 = (wxRect2D *) 0 ;
10323 bool result;
10324 void *argp1 = 0 ;
10325 int res1 = 0 ;
10326 PyObject *swig_obj[1] ;
10327
10328 if (!args) SWIG_fail;
10329 swig_obj[0] = args;
10330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10331 if (!SWIG_IsOK(res1)) {
10332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10333 }
10334 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10335 {
10336 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 {
10340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10341 }
10342 return resultobj;
10343 fail:
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10349 PyObject *resultobj = 0;
10350 wxRect2D *arg1 = (wxRect2D *) 0 ;
10351 wxRect2D *arg2 = 0 ;
10352 bool result;
10353 void *argp1 = 0 ;
10354 int res1 = 0 ;
10355 wxRect2D temp2 ;
10356 PyObject * obj0 = 0 ;
10357 PyObject * obj1 = 0 ;
10358 char * kwnames[] = {
10359 (char *) "self",(char *) "rect", NULL
10360 };
10361
10362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10364 if (!SWIG_IsOK(res1)) {
10365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10366 }
10367 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10368 {
10369 arg2 = &temp2;
10370 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10371 }
10372 {
10373 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10374 if (PyErr_Occurred()) SWIG_fail;
10375 }
10376 {
10377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10378 }
10379 return resultobj;
10380 fail:
10381 return NULL;
10382 }
10383
10384
10385 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10386 PyObject *resultobj = 0;
10387 wxRect2D *arg1 = (wxRect2D *) 0 ;
10388 wxDouble arg2 ;
10389 wxDouble arg3 ;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 void *argp2 ;
10393 int res2 = 0 ;
10394 void *argp3 ;
10395 int res3 = 0 ;
10396
10397 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10399 if (!SWIG_IsOK(res1)) {
10400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10401 }
10402 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10403 {
10404 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10405 if (!SWIG_IsOK(res2)) {
10406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10407 }
10408 if (!argp2) {
10409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10410 } else {
10411 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10412 arg2 = *temp;
10413 if (SWIG_IsNewObj(res2)) delete temp;
10414 }
10415 }
10416 {
10417 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10418 if (!SWIG_IsOK(res3)) {
10419 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10420 }
10421 if (!argp3) {
10422 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10423 } else {
10424 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10425 arg3 = *temp;
10426 if (SWIG_IsNewObj(res3)) delete temp;
10427 }
10428 }
10429 {
10430 (arg1)->Inset(arg2,arg3);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 resultobj = SWIG_Py_Void();
10434 return resultobj;
10435 fail:
10436 return NULL;
10437 }
10438
10439
10440 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10441 PyObject *resultobj = 0;
10442 wxRect2D *arg1 = (wxRect2D *) 0 ;
10443 wxDouble arg2 ;
10444 wxDouble arg3 ;
10445 wxDouble arg4 ;
10446 wxDouble arg5 ;
10447 void *argp1 = 0 ;
10448 int res1 = 0 ;
10449 void *argp2 ;
10450 int res2 = 0 ;
10451 void *argp3 ;
10452 int res3 = 0 ;
10453 void *argp4 ;
10454 int res4 = 0 ;
10455 void *argp5 ;
10456 int res5 = 0 ;
10457
10458 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10460 if (!SWIG_IsOK(res1)) {
10461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10462 }
10463 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10464 {
10465 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10466 if (!SWIG_IsOK(res2)) {
10467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10468 }
10469 if (!argp2) {
10470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10471 } else {
10472 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10473 arg2 = *temp;
10474 if (SWIG_IsNewObj(res2)) delete temp;
10475 }
10476 }
10477 {
10478 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10479 if (!SWIG_IsOK(res3)) {
10480 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10481 }
10482 if (!argp3) {
10483 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10484 } else {
10485 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10486 arg3 = *temp;
10487 if (SWIG_IsNewObj(res3)) delete temp;
10488 }
10489 }
10490 {
10491 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10492 if (!SWIG_IsOK(res4)) {
10493 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10494 }
10495 if (!argp4) {
10496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10497 } else {
10498 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10499 arg4 = *temp;
10500 if (SWIG_IsNewObj(res4)) delete temp;
10501 }
10502 }
10503 {
10504 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10505 if (!SWIG_IsOK(res5)) {
10506 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10507 }
10508 if (!argp5) {
10509 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10510 } else {
10511 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10512 arg5 = *temp;
10513 if (SWIG_IsNewObj(res5)) delete temp;
10514 }
10515 }
10516 {
10517 (arg1)->Inset(arg2,arg3,arg4,arg5);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 resultobj = SWIG_Py_Void();
10521 return resultobj;
10522 fail:
10523 return NULL;
10524 }
10525
10526
10527 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10528 int argc;
10529 PyObject *argv[6];
10530
10531 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10532 --argc;
10533 if (argc == 3) {
10534 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10535 }
10536 if (argc == 5) {
10537 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10538 }
10539
10540 fail:
10541 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10542 return NULL;
10543 }
10544
10545
10546 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10547 PyObject *resultobj = 0;
10548 wxRect2D *arg1 = (wxRect2D *) 0 ;
10549 wxPoint2D *arg2 = 0 ;
10550 void *argp1 = 0 ;
10551 int res1 = 0 ;
10552 wxPoint2D temp2 ;
10553 PyObject * obj0 = 0 ;
10554 PyObject * obj1 = 0 ;
10555 char * kwnames[] = {
10556 (char *) "self",(char *) "pt", NULL
10557 };
10558
10559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10561 if (!SWIG_IsOK(res1)) {
10562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10563 }
10564 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10565 {
10566 arg2 = &temp2;
10567 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10568 }
10569 {
10570 (arg1)->Offset((wxPoint2D const &)*arg2);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 resultobj = SWIG_Py_Void();
10574 return resultobj;
10575 fail:
10576 return NULL;
10577 }
10578
10579
10580 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10581 PyObject *resultobj = 0;
10582 wxRect2D *arg1 = (wxRect2D *) 0 ;
10583 wxRect2D *arg2 = 0 ;
10584 void *argp1 = 0 ;
10585 int res1 = 0 ;
10586 wxRect2D temp2 ;
10587 PyObject * obj0 = 0 ;
10588 PyObject * obj1 = 0 ;
10589 char * kwnames[] = {
10590 (char *) "self",(char *) "rect", NULL
10591 };
10592
10593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10595 if (!SWIG_IsOK(res1)) {
10596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10597 }
10598 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10599 {
10600 arg2 = &temp2;
10601 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10602 }
10603 {
10604 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10605 if (PyErr_Occurred()) SWIG_fail;
10606 }
10607 resultobj = SWIG_Py_Void();
10608 return resultobj;
10609 fail:
10610 return NULL;
10611 }
10612
10613
10614 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10615 PyObject *resultobj = 0;
10616 wxRect2D *arg1 = (wxRect2D *) 0 ;
10617 int arg2 ;
10618 int arg3 ;
10619 wxPoint2D result;
10620 void *argp1 = 0 ;
10621 int res1 = 0 ;
10622 int val2 ;
10623 int ecode2 = 0 ;
10624 int val3 ;
10625 int ecode3 = 0 ;
10626 PyObject * obj0 = 0 ;
10627 PyObject * obj1 = 0 ;
10628 PyObject * obj2 = 0 ;
10629 char * kwnames[] = {
10630 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10631 };
10632
10633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10637 }
10638 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10639 ecode2 = SWIG_AsVal_int(obj1, &val2);
10640 if (!SWIG_IsOK(ecode2)) {
10641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10642 }
10643 arg2 = static_cast< int >(val2);
10644 ecode3 = SWIG_AsVal_int(obj2, &val3);
10645 if (!SWIG_IsOK(ecode3)) {
10646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10647 }
10648 arg3 = static_cast< int >(val3);
10649 {
10650 result = (arg1)->Interpolate(arg2,arg3);
10651 if (PyErr_Occurred()) SWIG_fail;
10652 }
10653 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10654 return resultobj;
10655 fail:
10656 return NULL;
10657 }
10658
10659
10660 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj = 0;
10662 wxRect2D *arg1 = (wxRect2D *) 0 ;
10663 wxRect2D *arg2 = 0 ;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 wxRect2D temp2 ;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "otherRect", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10677 }
10678 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10679 {
10680 arg2 = &temp2;
10681 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10682 }
10683 {
10684 (arg1)->Intersect((wxRect2D const &)*arg2);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 resultobj = SWIG_Py_Void();
10688 return resultobj;
10689 fail:
10690 return NULL;
10691 }
10692
10693
10694 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10695 PyObject *resultobj = 0;
10696 wxRect2D *arg1 = (wxRect2D *) 0 ;
10697 wxRect2D *arg2 = 0 ;
10698 wxRect2D result;
10699 void *argp1 = 0 ;
10700 int res1 = 0 ;
10701 wxRect2D temp2 ;
10702 PyObject * obj0 = 0 ;
10703 PyObject * obj1 = 0 ;
10704 char * kwnames[] = {
10705 (char *) "self",(char *) "otherRect", NULL
10706 };
10707
10708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10712 }
10713 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10714 {
10715 arg2 = &temp2;
10716 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10717 }
10718 {
10719 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = 0;
10731 wxRect2D *arg1 = (wxRect2D *) 0 ;
10732 wxRect2D *arg2 = 0 ;
10733 bool result;
10734 void *argp1 = 0 ;
10735 int res1 = 0 ;
10736 wxRect2D temp2 ;
10737 PyObject * obj0 = 0 ;
10738 PyObject * obj1 = 0 ;
10739 char * kwnames[] = {
10740 (char *) "self",(char *) "rect", NULL
10741 };
10742
10743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10745 if (!SWIG_IsOK(res1)) {
10746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10747 }
10748 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10749 {
10750 arg2 = &temp2;
10751 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10752 }
10753 {
10754 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10755 if (PyErr_Occurred()) SWIG_fail;
10756 }
10757 {
10758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10759 }
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10767 PyObject *resultobj = 0;
10768 wxRect2D *arg1 = (wxRect2D *) 0 ;
10769 wxRect2D *arg2 = 0 ;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 wxRect2D temp2 ;
10773 PyObject * obj0 = 0 ;
10774 PyObject * obj1 = 0 ;
10775 char * kwnames[] = {
10776 (char *) "self",(char *) "otherRect", NULL
10777 };
10778
10779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10781 if (!SWIG_IsOK(res1)) {
10782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10783 }
10784 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10785 {
10786 arg2 = &temp2;
10787 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10788 }
10789 {
10790 (arg1)->Union((wxRect2D const &)*arg2);
10791 if (PyErr_Occurred()) SWIG_fail;
10792 }
10793 resultobj = SWIG_Py_Void();
10794 return resultobj;
10795 fail:
10796 return NULL;
10797 }
10798
10799
10800 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj = 0;
10802 wxRect2D *arg1 = (wxRect2D *) 0 ;
10803 wxRect2D *arg2 = 0 ;
10804 wxRect2D result;
10805 void *argp1 = 0 ;
10806 int res1 = 0 ;
10807 wxRect2D temp2 ;
10808 PyObject * obj0 = 0 ;
10809 PyObject * obj1 = 0 ;
10810 char * kwnames[] = {
10811 (char *) "self",(char *) "otherRect", NULL
10812 };
10813
10814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10816 if (!SWIG_IsOK(res1)) {
10817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10818 }
10819 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10820 {
10821 arg2 = &temp2;
10822 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10823 }
10824 {
10825 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10826 if (PyErr_Occurred()) SWIG_fail;
10827 }
10828 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10836 PyObject *resultobj = 0;
10837 wxRect2D *arg1 = (wxRect2D *) 0 ;
10838 wxDouble arg2 ;
10839 void *argp1 = 0 ;
10840 int res1 = 0 ;
10841 void *argp2 ;
10842 int res2 = 0 ;
10843
10844 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10846 if (!SWIG_IsOK(res1)) {
10847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10848 }
10849 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10850 {
10851 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10852 if (!SWIG_IsOK(res2)) {
10853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10854 }
10855 if (!argp2) {
10856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10857 } else {
10858 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10859 arg2 = *temp;
10860 if (SWIG_IsNewObj(res2)) delete temp;
10861 }
10862 }
10863 {
10864 (arg1)->Scale(arg2);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_Py_Void();
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10875 PyObject *resultobj = 0;
10876 wxRect2D *arg1 = (wxRect2D *) 0 ;
10877 int arg2 ;
10878 int arg3 ;
10879 void *argp1 = 0 ;
10880 int res1 = 0 ;
10881 int val2 ;
10882 int ecode2 = 0 ;
10883 int val3 ;
10884 int ecode3 = 0 ;
10885
10886 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10890 }
10891 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10892 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10893 if (!SWIG_IsOK(ecode2)) {
10894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10895 }
10896 arg2 = static_cast< int >(val2);
10897 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10898 if (!SWIG_IsOK(ecode3)) {
10899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10900 }
10901 arg3 = static_cast< int >(val3);
10902 {
10903 (arg1)->Scale(arg2,arg3);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 resultobj = SWIG_Py_Void();
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10914 int argc;
10915 PyObject *argv[4];
10916
10917 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10918 --argc;
10919 if (argc == 2) {
10920 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10921 }
10922 if (argc == 3) {
10923 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10924 }
10925
10926 fail:
10927 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10928 return NULL;
10929 }
10930
10931
10932 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10933 PyObject *resultobj = 0;
10934 wxRect2D *arg1 = (wxRect2D *) 0 ;
10935 PyObject *arg2 = (PyObject *) 0 ;
10936 bool result;
10937 void *argp1 = 0 ;
10938 int res1 = 0 ;
10939 PyObject * obj0 = 0 ;
10940 PyObject * obj1 = 0 ;
10941 char * kwnames[] = {
10942 (char *) "self",(char *) "other", NULL
10943 };
10944
10945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10947 if (!SWIG_IsOK(res1)) {
10948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10949 }
10950 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10951 arg2 = obj1;
10952 {
10953 result = (bool)wxRect2D___eq__(arg1,arg2);
10954 if (PyErr_Occurred()) SWIG_fail;
10955 }
10956 {
10957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10958 }
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj = 0;
10967 wxRect2D *arg1 = (wxRect2D *) 0 ;
10968 PyObject *arg2 = (PyObject *) 0 ;
10969 bool result;
10970 void *argp1 = 0 ;
10971 int res1 = 0 ;
10972 PyObject * obj0 = 0 ;
10973 PyObject * obj1 = 0 ;
10974 char * kwnames[] = {
10975 (char *) "self",(char *) "other", NULL
10976 };
10977
10978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10980 if (!SWIG_IsOK(res1)) {
10981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10982 }
10983 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10984 arg2 = obj1;
10985 {
10986 result = (bool)wxRect2D___ne__(arg1,arg2);
10987 if (PyErr_Occurred()) SWIG_fail;
10988 }
10989 {
10990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10991 }
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10999 PyObject *resultobj = 0;
11000 wxRect2D *arg1 = (wxRect2D *) 0 ;
11001 wxDouble arg2 ;
11002 void *argp1 = 0 ;
11003 int res1 = 0 ;
11004 void *argp2 ;
11005 int res2 = 0 ;
11006 PyObject *swig_obj[2] ;
11007
11008 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11010 if (!SWIG_IsOK(res1)) {
11011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11012 }
11013 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11014 {
11015 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11016 if (!SWIG_IsOK(res2)) {
11017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11018 }
11019 if (!argp2) {
11020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11021 } else {
11022 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11023 arg2 = *temp;
11024 if (SWIG_IsNewObj(res2)) delete temp;
11025 }
11026 }
11027 if (arg1) (arg1)->m_x = arg2;
11028
11029 resultobj = SWIG_Py_Void();
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11037 PyObject *resultobj = 0;
11038 wxRect2D *arg1 = (wxRect2D *) 0 ;
11039 wxDouble result;
11040 void *argp1 = 0 ;
11041 int res1 = 0 ;
11042 PyObject *swig_obj[1] ;
11043
11044 if (!args) SWIG_fail;
11045 swig_obj[0] = args;
11046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11047 if (!SWIG_IsOK(res1)) {
11048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11049 }
11050 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11051 result = ((arg1)->m_x);
11052 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11053 return resultobj;
11054 fail:
11055 return NULL;
11056 }
11057
11058
11059 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11060 PyObject *resultobj = 0;
11061 wxRect2D *arg1 = (wxRect2D *) 0 ;
11062 wxDouble arg2 ;
11063 void *argp1 = 0 ;
11064 int res1 = 0 ;
11065 void *argp2 ;
11066 int res2 = 0 ;
11067 PyObject *swig_obj[2] ;
11068
11069 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11071 if (!SWIG_IsOK(res1)) {
11072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11073 }
11074 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11075 {
11076 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11077 if (!SWIG_IsOK(res2)) {
11078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11079 }
11080 if (!argp2) {
11081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11082 } else {
11083 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11084 arg2 = *temp;
11085 if (SWIG_IsNewObj(res2)) delete temp;
11086 }
11087 }
11088 if (arg1) (arg1)->m_y = arg2;
11089
11090 resultobj = SWIG_Py_Void();
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11098 PyObject *resultobj = 0;
11099 wxRect2D *arg1 = (wxRect2D *) 0 ;
11100 wxDouble result;
11101 void *argp1 = 0 ;
11102 int res1 = 0 ;
11103 PyObject *swig_obj[1] ;
11104
11105 if (!args) SWIG_fail;
11106 swig_obj[0] = args;
11107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11108 if (!SWIG_IsOK(res1)) {
11109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11110 }
11111 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11112 result = ((arg1)->m_y);
11113 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11114 return resultobj;
11115 fail:
11116 return NULL;
11117 }
11118
11119
11120 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11121 PyObject *resultobj = 0;
11122 wxRect2D *arg1 = (wxRect2D *) 0 ;
11123 wxDouble arg2 ;
11124 void *argp1 = 0 ;
11125 int res1 = 0 ;
11126 void *argp2 ;
11127 int res2 = 0 ;
11128 PyObject *swig_obj[2] ;
11129
11130 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11132 if (!SWIG_IsOK(res1)) {
11133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11134 }
11135 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11136 {
11137 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11138 if (!SWIG_IsOK(res2)) {
11139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11140 }
11141 if (!argp2) {
11142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11143 } else {
11144 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11145 arg2 = *temp;
11146 if (SWIG_IsNewObj(res2)) delete temp;
11147 }
11148 }
11149 if (arg1) (arg1)->m_width = arg2;
11150
11151 resultobj = SWIG_Py_Void();
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11159 PyObject *resultobj = 0;
11160 wxRect2D *arg1 = (wxRect2D *) 0 ;
11161 wxDouble result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 PyObject *swig_obj[1] ;
11165
11166 if (!args) SWIG_fail;
11167 swig_obj[0] = args;
11168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11169 if (!SWIG_IsOK(res1)) {
11170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11171 }
11172 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11173 result = ((arg1)->m_width);
11174 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11175 return resultobj;
11176 fail:
11177 return NULL;
11178 }
11179
11180
11181 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11182 PyObject *resultobj = 0;
11183 wxRect2D *arg1 = (wxRect2D *) 0 ;
11184 wxDouble arg2 ;
11185 void *argp1 = 0 ;
11186 int res1 = 0 ;
11187 void *argp2 ;
11188 int res2 = 0 ;
11189 PyObject *swig_obj[2] ;
11190
11191 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11193 if (!SWIG_IsOK(res1)) {
11194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11195 }
11196 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11197 {
11198 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11199 if (!SWIG_IsOK(res2)) {
11200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11201 }
11202 if (!argp2) {
11203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11204 } else {
11205 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11206 arg2 = *temp;
11207 if (SWIG_IsNewObj(res2)) delete temp;
11208 }
11209 }
11210 if (arg1) (arg1)->m_height = arg2;
11211
11212 resultobj = SWIG_Py_Void();
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11220 PyObject *resultobj = 0;
11221 wxRect2D *arg1 = (wxRect2D *) 0 ;
11222 wxDouble result;
11223 void *argp1 = 0 ;
11224 int res1 = 0 ;
11225 PyObject *swig_obj[1] ;
11226
11227 if (!args) SWIG_fail;
11228 swig_obj[0] = args;
11229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11230 if (!SWIG_IsOK(res1)) {
11231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11232 }
11233 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11234 result = ((arg1)->m_height);
11235 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11236 return resultobj;
11237 fail:
11238 return NULL;
11239 }
11240
11241
11242 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj = 0;
11244 wxRect2D *arg1 = (wxRect2D *) 0 ;
11245 wxDouble arg2 = (wxDouble) 0 ;
11246 wxDouble arg3 = (wxDouble) 0 ;
11247 wxDouble arg4 = (wxDouble) 0 ;
11248 wxDouble arg5 = (wxDouble) 0 ;
11249 void *argp1 = 0 ;
11250 int res1 = 0 ;
11251 void *argp2 ;
11252 int res2 = 0 ;
11253 void *argp3 ;
11254 int res3 = 0 ;
11255 void *argp4 ;
11256 int res4 = 0 ;
11257 void *argp5 ;
11258 int res5 = 0 ;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 PyObject * obj3 = 0 ;
11263 PyObject * obj4 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11266 };
11267
11268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11270 if (!SWIG_IsOK(res1)) {
11271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11272 }
11273 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11274 if (obj1) {
11275 {
11276 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11277 if (!SWIG_IsOK(res2)) {
11278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11279 }
11280 if (!argp2) {
11281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11282 } else {
11283 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11284 arg2 = *temp;
11285 if (SWIG_IsNewObj(res2)) delete temp;
11286 }
11287 }
11288 }
11289 if (obj2) {
11290 {
11291 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11292 if (!SWIG_IsOK(res3)) {
11293 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11294 }
11295 if (!argp3) {
11296 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11297 } else {
11298 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11299 arg3 = *temp;
11300 if (SWIG_IsNewObj(res3)) delete temp;
11301 }
11302 }
11303 }
11304 if (obj3) {
11305 {
11306 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11307 if (!SWIG_IsOK(res4)) {
11308 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11309 }
11310 if (!argp4) {
11311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11312 } else {
11313 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11314 arg4 = *temp;
11315 if (SWIG_IsNewObj(res4)) delete temp;
11316 }
11317 }
11318 }
11319 if (obj4) {
11320 {
11321 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11322 if (!SWIG_IsOK(res5)) {
11323 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11324 }
11325 if (!argp5) {
11326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11327 } else {
11328 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11329 arg5 = *temp;
11330 if (SWIG_IsNewObj(res5)) delete temp;
11331 }
11332 }
11333 }
11334 {
11335 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11336 if (PyErr_Occurred()) SWIG_fail;
11337 }
11338 resultobj = SWIG_Py_Void();
11339 return resultobj;
11340 fail:
11341 return NULL;
11342 }
11343
11344
11345 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11346 PyObject *resultobj = 0;
11347 wxRect2D *arg1 = (wxRect2D *) 0 ;
11348 PyObject *result = 0 ;
11349 void *argp1 = 0 ;
11350 int res1 = 0 ;
11351 PyObject *swig_obj[1] ;
11352
11353 if (!args) SWIG_fail;
11354 swig_obj[0] = args;
11355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11356 if (!SWIG_IsOK(res1)) {
11357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11358 }
11359 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11360 {
11361 result = (PyObject *)wxRect2D_Get(arg1);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 resultobj = result;
11365 return resultobj;
11366 fail:
11367 return NULL;
11368 }
11369
11370
11371 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11372 PyObject *obj;
11373 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11374 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11375 return SWIG_Py_Void();
11376 }
11377
11378 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11379 return SWIG_Python_InitShadowInstance(args);
11380 }
11381
11382 SWIGINTERN int DefaultPosition_set(PyObject *) {
11383 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11384 return 1;
11385 }
11386
11387
11388 SWIGINTERN PyObject *DefaultPosition_get(void) {
11389 PyObject *pyobj = 0;
11390
11391 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11392 return pyobj;
11393 }
11394
11395
11396 SWIGINTERN int DefaultSize_set(PyObject *) {
11397 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11398 return 1;
11399 }
11400
11401
11402 SWIGINTERN PyObject *DefaultSize_get(void) {
11403 PyObject *pyobj = 0;
11404
11405 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11406 return pyobj;
11407 }
11408
11409
11410 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11411 PyObject *resultobj = 0;
11412 PyObject *arg1 = (PyObject *) 0 ;
11413 wxPyInputStream *result = 0 ;
11414 PyObject * obj0 = 0 ;
11415 char * kwnames[] = {
11416 (char *) "p", NULL
11417 };
11418
11419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11420 arg1 = obj0;
11421 {
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11435 PyObject *resultobj = 0;
11436 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11437 void *argp1 = 0 ;
11438 int res1 = 0 ;
11439 PyObject *swig_obj[1] ;
11440
11441 if (!args) SWIG_fail;
11442 swig_obj[0] = args;
11443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11444 if (!SWIG_IsOK(res1)) {
11445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11446 }
11447 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 delete arg1;
11451
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 resultobj = SWIG_Py_Void();
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11463 PyObject *resultobj = 0;
11464 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11465 void *argp1 = 0 ;
11466 int res1 = 0 ;
11467 PyObject *swig_obj[1] ;
11468
11469 if (!args) SWIG_fail;
11470 swig_obj[0] = args;
11471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11472 if (!SWIG_IsOK(res1)) {
11473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11474 }
11475 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 (arg1)->close();
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 resultobj = SWIG_Py_Void();
11483 return resultobj;
11484 fail:
11485 return NULL;
11486 }
11487
11488
11489 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11490 PyObject *resultobj = 0;
11491 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11492 void *argp1 = 0 ;
11493 int res1 = 0 ;
11494 PyObject *swig_obj[1] ;
11495
11496 if (!args) SWIG_fail;
11497 swig_obj[0] = args;
11498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11499 if (!SWIG_IsOK(res1)) {
11500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11501 }
11502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11503 {
11504 PyThreadState* __tstate = wxPyBeginAllowThreads();
11505 (arg1)->flush();
11506 wxPyEndAllowThreads(__tstate);
11507 if (PyErr_Occurred()) SWIG_fail;
11508 }
11509 resultobj = SWIG_Py_Void();
11510 return resultobj;
11511 fail:
11512 return NULL;
11513 }
11514
11515
11516 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11517 PyObject *resultobj = 0;
11518 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11519 bool result;
11520 void *argp1 = 0 ;
11521 int res1 = 0 ;
11522 PyObject *swig_obj[1] ;
11523
11524 if (!args) SWIG_fail;
11525 swig_obj[0] = args;
11526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11527 if (!SWIG_IsOK(res1)) {
11528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11529 }
11530 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (bool)(arg1)->eof();
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 {
11538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11539 }
11540 return resultobj;
11541 fail:
11542 return NULL;
11543 }
11544
11545
11546 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11547 PyObject *resultobj = 0;
11548 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11549 int arg2 = (int) -1 ;
11550 PyObject *result = 0 ;
11551 void *argp1 = 0 ;
11552 int res1 = 0 ;
11553 int val2 ;
11554 int ecode2 = 0 ;
11555 PyObject * obj0 = 0 ;
11556 PyObject * obj1 = 0 ;
11557 char * kwnames[] = {
11558 (char *) "self",(char *) "size", NULL
11559 };
11560
11561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11563 if (!SWIG_IsOK(res1)) {
11564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11565 }
11566 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11567 if (obj1) {
11568 ecode2 = SWIG_AsVal_int(obj1, &val2);
11569 if (!SWIG_IsOK(ecode2)) {
11570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11571 }
11572 arg2 = static_cast< int >(val2);
11573 }
11574 {
11575 PyThreadState* __tstate = wxPyBeginAllowThreads();
11576 result = (PyObject *)(arg1)->read(arg2);
11577 wxPyEndAllowThreads(__tstate);
11578 if (PyErr_Occurred()) SWIG_fail;
11579 }
11580 resultobj = result;
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11588 PyObject *resultobj = 0;
11589 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11590 int arg2 = (int) -1 ;
11591 PyObject *result = 0 ;
11592 void *argp1 = 0 ;
11593 int res1 = 0 ;
11594 int val2 ;
11595 int ecode2 = 0 ;
11596 PyObject * obj0 = 0 ;
11597 PyObject * obj1 = 0 ;
11598 char * kwnames[] = {
11599 (char *) "self",(char *) "size", NULL
11600 };
11601
11602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11604 if (!SWIG_IsOK(res1)) {
11605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11606 }
11607 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11608 if (obj1) {
11609 ecode2 = SWIG_AsVal_int(obj1, &val2);
11610 if (!SWIG_IsOK(ecode2)) {
11611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11612 }
11613 arg2 = static_cast< int >(val2);
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (PyObject *)(arg1)->readline(arg2);
11618 wxPyEndAllowThreads(__tstate);
11619 if (PyErr_Occurred()) SWIG_fail;
11620 }
11621 resultobj = result;
11622 return resultobj;
11623 fail:
11624 return NULL;
11625 }
11626
11627
11628 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11629 PyObject *resultobj = 0;
11630 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11631 int arg2 = (int) -1 ;
11632 PyObject *result = 0 ;
11633 void *argp1 = 0 ;
11634 int res1 = 0 ;
11635 int val2 ;
11636 int ecode2 = 0 ;
11637 PyObject * obj0 = 0 ;
11638 PyObject * obj1 = 0 ;
11639 char * kwnames[] = {
11640 (char *) "self",(char *) "sizehint", NULL
11641 };
11642
11643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11645 if (!SWIG_IsOK(res1)) {
11646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11647 }
11648 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11649 if (obj1) {
11650 ecode2 = SWIG_AsVal_int(obj1, &val2);
11651 if (!SWIG_IsOK(ecode2)) {
11652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11653 }
11654 arg2 = static_cast< int >(val2);
11655 }
11656 {
11657 PyThreadState* __tstate = wxPyBeginAllowThreads();
11658 result = (PyObject *)(arg1)->readlines(arg2);
11659 wxPyEndAllowThreads(__tstate);
11660 if (PyErr_Occurred()) SWIG_fail;
11661 }
11662 resultobj = result;
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj = 0;
11671 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11672 int arg2 ;
11673 int arg3 = (int) 0 ;
11674 void *argp1 = 0 ;
11675 int res1 = 0 ;
11676 int val2 ;
11677 int ecode2 = 0 ;
11678 int val3 ;
11679 int ecode3 = 0 ;
11680 PyObject * obj0 = 0 ;
11681 PyObject * obj1 = 0 ;
11682 PyObject * obj2 = 0 ;
11683 char * kwnames[] = {
11684 (char *) "self",(char *) "offset",(char *) "whence", NULL
11685 };
11686
11687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11691 }
11692 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11693 ecode2 = SWIG_AsVal_int(obj1, &val2);
11694 if (!SWIG_IsOK(ecode2)) {
11695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11696 }
11697 arg2 = static_cast< int >(val2);
11698 if (obj2) {
11699 ecode3 = SWIG_AsVal_int(obj2, &val3);
11700 if (!SWIG_IsOK(ecode3)) {
11701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11702 }
11703 arg3 = static_cast< int >(val3);
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 (arg1)->seek(arg2,arg3);
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = SWIG_Py_Void();
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 PyObject *resultobj = 0;
11720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11721 int result;
11722 void *argp1 = 0 ;
11723 int res1 = 0 ;
11724 PyObject *swig_obj[1] ;
11725
11726 if (!args) SWIG_fail;
11727 swig_obj[0] = args;
11728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11729 if (!SWIG_IsOK(res1)) {
11730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11731 }
11732 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11733 {
11734 PyThreadState* __tstate = wxPyBeginAllowThreads();
11735 result = (int)(arg1)->tell();
11736 wxPyEndAllowThreads(__tstate);
11737 if (PyErr_Occurred()) SWIG_fail;
11738 }
11739 resultobj = SWIG_From_int(static_cast< int >(result));
11740 return resultobj;
11741 fail:
11742 return NULL;
11743 }
11744
11745
11746 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11747 PyObject *resultobj = 0;
11748 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11749 char result;
11750 void *argp1 = 0 ;
11751 int res1 = 0 ;
11752 PyObject *swig_obj[1] ;
11753
11754 if (!args) SWIG_fail;
11755 swig_obj[0] = args;
11756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11757 if (!SWIG_IsOK(res1)) {
11758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11759 }
11760 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11761 {
11762 PyThreadState* __tstate = wxPyBeginAllowThreads();
11763 result = (char)(arg1)->Peek();
11764 wxPyEndAllowThreads(__tstate);
11765 if (PyErr_Occurred()) SWIG_fail;
11766 }
11767 resultobj = SWIG_From_char(static_cast< char >(result));
11768 return resultobj;
11769 fail:
11770 return NULL;
11771 }
11772
11773
11774 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11775 PyObject *resultobj = 0;
11776 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11777 char result;
11778 void *argp1 = 0 ;
11779 int res1 = 0 ;
11780 PyObject *swig_obj[1] ;
11781
11782 if (!args) SWIG_fail;
11783 swig_obj[0] = args;
11784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11785 if (!SWIG_IsOK(res1)) {
11786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11787 }
11788 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11789 {
11790 PyThreadState* __tstate = wxPyBeginAllowThreads();
11791 result = (char)(arg1)->GetC();
11792 wxPyEndAllowThreads(__tstate);
11793 if (PyErr_Occurred()) SWIG_fail;
11794 }
11795 resultobj = SWIG_From_char(static_cast< char >(result));
11796 return resultobj;
11797 fail:
11798 return NULL;
11799 }
11800
11801
11802 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11803 PyObject *resultobj = 0;
11804 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11805 size_t result;
11806 void *argp1 = 0 ;
11807 int res1 = 0 ;
11808 PyObject *swig_obj[1] ;
11809
11810 if (!args) SWIG_fail;
11811 swig_obj[0] = args;
11812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11813 if (!SWIG_IsOK(res1)) {
11814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11815 }
11816 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11817 {
11818 PyThreadState* __tstate = wxPyBeginAllowThreads();
11819 result = (size_t)(arg1)->LastRead();
11820 wxPyEndAllowThreads(__tstate);
11821 if (PyErr_Occurred()) SWIG_fail;
11822 }
11823 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11831 PyObject *resultobj = 0;
11832 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11833 bool result;
11834 void *argp1 = 0 ;
11835 int res1 = 0 ;
11836 PyObject *swig_obj[1] ;
11837
11838 if (!args) SWIG_fail;
11839 swig_obj[0] = args;
11840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11841 if (!SWIG_IsOK(res1)) {
11842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11843 }
11844 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (bool)(arg1)->CanRead();
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11853 }
11854 return resultobj;
11855 fail:
11856 return NULL;
11857 }
11858
11859
11860 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11861 PyObject *resultobj = 0;
11862 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11863 bool result;
11864 void *argp1 = 0 ;
11865 int res1 = 0 ;
11866 PyObject *swig_obj[1] ;
11867
11868 if (!args) SWIG_fail;
11869 swig_obj[0] = args;
11870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11871 if (!SWIG_IsOK(res1)) {
11872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11873 }
11874 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11875 {
11876 PyThreadState* __tstate = wxPyBeginAllowThreads();
11877 result = (bool)(arg1)->Eof();
11878 wxPyEndAllowThreads(__tstate);
11879 if (PyErr_Occurred()) SWIG_fail;
11880 }
11881 {
11882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11883 }
11884 return resultobj;
11885 fail:
11886 return NULL;
11887 }
11888
11889
11890 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = 0;
11892 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11893 char arg2 ;
11894 bool result;
11895 void *argp1 = 0 ;
11896 int res1 = 0 ;
11897 char val2 ;
11898 int ecode2 = 0 ;
11899 PyObject * obj0 = 0 ;
11900 PyObject * obj1 = 0 ;
11901 char * kwnames[] = {
11902 (char *) "self",(char *) "c", NULL
11903 };
11904
11905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11907 if (!SWIG_IsOK(res1)) {
11908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11909 }
11910 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11911 ecode2 = SWIG_AsVal_char(obj1, &val2);
11912 if (!SWIG_IsOK(ecode2)) {
11913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11914 }
11915 arg2 = static_cast< char >(val2);
11916 {
11917 PyThreadState* __tstate = wxPyBeginAllowThreads();
11918 result = (bool)(arg1)->Ungetch(arg2);
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11924 }
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11932 PyObject *resultobj = 0;
11933 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11934 long arg2 ;
11935 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11936 long result;
11937 void *argp1 = 0 ;
11938 int res1 = 0 ;
11939 long val2 ;
11940 int ecode2 = 0 ;
11941 int val3 ;
11942 int ecode3 = 0 ;
11943 PyObject * obj0 = 0 ;
11944 PyObject * obj1 = 0 ;
11945 PyObject * obj2 = 0 ;
11946 char * kwnames[] = {
11947 (char *) "self",(char *) "pos",(char *) "mode", NULL
11948 };
11949
11950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11952 if (!SWIG_IsOK(res1)) {
11953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11954 }
11955 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11956 ecode2 = SWIG_AsVal_long(obj1, &val2);
11957 if (!SWIG_IsOK(ecode2)) {
11958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11959 }
11960 arg2 = static_cast< long >(val2);
11961 if (obj2) {
11962 ecode3 = SWIG_AsVal_int(obj2, &val3);
11963 if (!SWIG_IsOK(ecode3)) {
11964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11965 }
11966 arg3 = static_cast< wxSeekMode >(val3);
11967 }
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 result = (long)(arg1)->SeekI(arg2,arg3);
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 resultobj = SWIG_From_long(static_cast< long >(result));
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11982 PyObject *resultobj = 0;
11983 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11984 long result;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 PyObject *swig_obj[1] ;
11988
11989 if (!args) SWIG_fail;
11990 swig_obj[0] = args;
11991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11994 }
11995 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (long)(arg1)->TellI();
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_From_long(static_cast< long >(result));
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12010 PyObject *obj;
12011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12012 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12013 return SWIG_Py_Void();
12014 }
12015
12016 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12017 return SWIG_Python_InitShadowInstance(args);
12018 }
12019
12020 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12021 PyObject *resultobj = 0;
12022 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12023 PyObject *arg2 = (PyObject *) 0 ;
12024 void *argp1 = 0 ;
12025 int res1 = 0 ;
12026 PyObject * obj0 = 0 ;
12027 PyObject * obj1 = 0 ;
12028 char * kwnames[] = {
12029 (char *) "self",(char *) "obj", NULL
12030 };
12031
12032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12034 if (!SWIG_IsOK(res1)) {
12035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12036 }
12037 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12038 arg2 = obj1;
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 wxOutputStream_write(arg1,arg2);
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_Py_Void();
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12053 PyObject *resultobj = 0;
12054 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12055 size_t result;
12056 void *argp1 = 0 ;
12057 int res1 = 0 ;
12058 PyObject *swig_obj[1] ;
12059
12060 if (!args) SWIG_fail;
12061 swig_obj[0] = args;
12062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12065 }
12066 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12067 {
12068 PyThreadState* __tstate = wxPyBeginAllowThreads();
12069 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12070 wxPyEndAllowThreads(__tstate);
12071 if (PyErr_Occurred()) SWIG_fail;
12072 }
12073 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12074 return resultobj;
12075 fail:
12076 return NULL;
12077 }
12078
12079
12080 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12081 PyObject *obj;
12082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12083 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12084 return SWIG_Py_Void();
12085 }
12086
12087 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj = 0;
12089 wxInputStream *arg1 = (wxInputStream *) 0 ;
12090 wxString *arg2 = 0 ;
12091 wxString *arg3 = 0 ;
12092 wxString *arg4 = 0 ;
12093 wxDateTime arg5 ;
12094 wxFSFile *result = 0 ;
12095 wxPyInputStream *temp1 ;
12096 bool temp2 = false ;
12097 bool temp3 = false ;
12098 bool temp4 = false ;
12099 void *argp5 ;
12100 int res5 = 0 ;
12101 PyObject * obj0 = 0 ;
12102 PyObject * obj1 = 0 ;
12103 PyObject * obj2 = 0 ;
12104 PyObject * obj3 = 0 ;
12105 PyObject * obj4 = 0 ;
12106 char * kwnames[] = {
12107 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12108 };
12109
12110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12111 {
12112 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12113 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12114 } else {
12115 PyErr_Clear(); // clear the failure of the wxPyConvert above
12116 arg1 = wxPyCBInputStream_create(obj0, true);
12117 if (arg1 == NULL) {
12118 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12119 SWIG_fail;
12120 }
12121 }
12122 }
12123 {
12124 arg2 = wxString_in_helper(obj1);
12125 if (arg2 == NULL) SWIG_fail;
12126 temp2 = true;
12127 }
12128 {
12129 arg3 = wxString_in_helper(obj2);
12130 if (arg3 == NULL) SWIG_fail;
12131 temp3 = true;
12132 }
12133 {
12134 arg4 = wxString_in_helper(obj3);
12135 if (arg4 == NULL) SWIG_fail;
12136 temp4 = true;
12137 }
12138 {
12139 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12140 if (!SWIG_IsOK(res5)) {
12141 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12142 }
12143 if (!argp5) {
12144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12145 } else {
12146 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12147 arg5 = *temp;
12148 if (SWIG_IsNewObj(res5)) delete temp;
12149 }
12150 }
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12158 {
12159 if (temp2)
12160 delete arg2;
12161 }
12162 {
12163 if (temp3)
12164 delete arg3;
12165 }
12166 {
12167 if (temp4)
12168 delete arg4;
12169 }
12170 return resultobj;
12171 fail:
12172 {
12173 if (temp2)
12174 delete arg2;
12175 }
12176 {
12177 if (temp3)
12178 delete arg3;
12179 }
12180 {
12181 if (temp4)
12182 delete arg4;
12183 }
12184 return NULL;
12185 }
12186
12187
12188 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12189 PyObject *resultobj = 0;
12190 wxFSFile *arg1 = (wxFSFile *) 0 ;
12191 void *argp1 = 0 ;
12192 int res1 = 0 ;
12193 PyObject *swig_obj[1] ;
12194
12195 if (!args) SWIG_fail;
12196 swig_obj[0] = args;
12197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12198 if (!SWIG_IsOK(res1)) {
12199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12200 }
12201 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 delete arg1;
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_Py_Void();
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12217 PyObject *resultobj = 0;
12218 wxFSFile *arg1 = (wxFSFile *) 0 ;
12219 wxInputStream *result = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 PyObject *swig_obj[1] ;
12223
12224 if (!args) SWIG_fail;
12225 swig_obj[0] = args;
12226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12227 if (!SWIG_IsOK(res1)) {
12228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12229 }
12230 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12231 {
12232 PyThreadState* __tstate = wxPyBeginAllowThreads();
12233 result = (wxInputStream *)(arg1)->GetStream();
12234 wxPyEndAllowThreads(__tstate);
12235 if (PyErr_Occurred()) SWIG_fail;
12236 }
12237 {
12238 wxPyInputStream * _ptr = NULL;
12239
12240 if (result) {
12241 _ptr = new wxPyInputStream(result);
12242 }
12243 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12244 }
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12252 PyObject *resultobj = 0;
12253 wxFSFile *arg1 = (wxFSFile *) 0 ;
12254 void *argp1 = 0 ;
12255 int res1 = 0 ;
12256 PyObject *swig_obj[1] ;
12257
12258 if (!args) SWIG_fail;
12259 swig_obj[0] = args;
12260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12261 if (!SWIG_IsOK(res1)) {
12262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12263 }
12264 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12265 {
12266 PyThreadState* __tstate = wxPyBeginAllowThreads();
12267 (arg1)->DetachStream();
12268 wxPyEndAllowThreads(__tstate);
12269 if (PyErr_Occurred()) SWIG_fail;
12270 }
12271 resultobj = SWIG_Py_Void();
12272 return resultobj;
12273 fail:
12274 return NULL;
12275 }
12276
12277
12278 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12279 PyObject *resultobj = 0;
12280 wxFSFile *arg1 = (wxFSFile *) 0 ;
12281 wxString *result = 0 ;
12282 void *argp1 = 0 ;
12283 int res1 = 0 ;
12284 PyObject *swig_obj[1] ;
12285
12286 if (!args) SWIG_fail;
12287 swig_obj[0] = args;
12288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12289 if (!SWIG_IsOK(res1)) {
12290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12291 }
12292 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 {
12296 wxString const &_result_ref = (arg1)->GetMimeType();
12297 result = (wxString *) &_result_ref;
12298 }
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 #if wxUSE_UNICODE
12304 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12305 #else
12306 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12307 #endif
12308 }
12309 return resultobj;
12310 fail:
12311 return NULL;
12312 }
12313
12314
12315 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12316 PyObject *resultobj = 0;
12317 wxFSFile *arg1 = (wxFSFile *) 0 ;
12318 wxString *result = 0 ;
12319 void *argp1 = 0 ;
12320 int res1 = 0 ;
12321 PyObject *swig_obj[1] ;
12322
12323 if (!args) SWIG_fail;
12324 swig_obj[0] = args;
12325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12326 if (!SWIG_IsOK(res1)) {
12327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12328 }
12329 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 {
12333 wxString const &_result_ref = (arg1)->GetLocation();
12334 result = (wxString *) &_result_ref;
12335 }
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 {
12340 #if wxUSE_UNICODE
12341 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12342 #else
12343 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12344 #endif
12345 }
12346 return resultobj;
12347 fail:
12348 return NULL;
12349 }
12350
12351
12352 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12353 PyObject *resultobj = 0;
12354 wxFSFile *arg1 = (wxFSFile *) 0 ;
12355 wxString *result = 0 ;
12356 void *argp1 = 0 ;
12357 int res1 = 0 ;
12358 PyObject *swig_obj[1] ;
12359
12360 if (!args) SWIG_fail;
12361 swig_obj[0] = args;
12362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12363 if (!SWIG_IsOK(res1)) {
12364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12365 }
12366 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 {
12370 wxString const &_result_ref = (arg1)->GetAnchor();
12371 result = (wxString *) &_result_ref;
12372 }
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 #if wxUSE_UNICODE
12378 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12379 #else
12380 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12381 #endif
12382 }
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12390 PyObject *resultobj = 0;
12391 wxFSFile *arg1 = (wxFSFile *) 0 ;
12392 wxDateTime result;
12393 void *argp1 = 0 ;
12394 int res1 = 0 ;
12395 PyObject *swig_obj[1] ;
12396
12397 if (!args) SWIG_fail;
12398 swig_obj[0] = args;
12399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12400 if (!SWIG_IsOK(res1)) {
12401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12402 }
12403 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12404 {
12405 PyThreadState* __tstate = wxPyBeginAllowThreads();
12406 result = (arg1)->GetModificationTime();
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12411 return resultobj;
12412 fail:
12413 return NULL;
12414 }
12415
12416
12417 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12418 PyObject *obj;
12419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12420 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12421 return SWIG_Py_Void();
12422 }
12423
12424 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12425 return SWIG_Python_InitShadowInstance(args);
12426 }
12427
12428 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 PyObject *resultobj = 0;
12430 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12431 void *argp1 = 0 ;
12432 int res1 = 0 ;
12433 PyObject *swig_obj[1] ;
12434
12435 if (!args) SWIG_fail;
12436 swig_obj[0] = args;
12437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12440 }
12441 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 delete arg1;
12445
12446 wxPyEndAllowThreads(__tstate);
12447 if (PyErr_Occurred()) SWIG_fail;
12448 }
12449 resultobj = SWIG_Py_Void();
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457 PyObject *obj;
12458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12459 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12460 return SWIG_Py_Void();
12461 }
12462
12463 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12464 PyObject *resultobj = 0;
12465 wxPyFileSystemHandler *result = 0 ;
12466
12467 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12468 {
12469 PyThreadState* __tstate = wxPyBeginAllowThreads();
12470 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12471 wxPyEndAllowThreads(__tstate);
12472 if (PyErr_Occurred()) SWIG_fail;
12473 }
12474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12475 return resultobj;
12476 fail:
12477 return NULL;
12478 }
12479
12480
12481 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12482 PyObject *resultobj = 0;
12483 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12484 PyObject *arg2 = (PyObject *) 0 ;
12485 PyObject *arg3 = (PyObject *) 0 ;
12486 void *argp1 = 0 ;
12487 int res1 = 0 ;
12488 PyObject * obj0 = 0 ;
12489 PyObject * obj1 = 0 ;
12490 PyObject * obj2 = 0 ;
12491 char * kwnames[] = {
12492 (char *) "self",(char *) "self",(char *) "_class", NULL
12493 };
12494
12495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12497 if (!SWIG_IsOK(res1)) {
12498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12499 }
12500 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12501 arg2 = obj1;
12502 arg3 = obj2;
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 (arg1)->_setCallbackInfo(arg2,arg3);
12506 wxPyEndAllowThreads(__tstate);
12507 if (PyErr_Occurred()) SWIG_fail;
12508 }
12509 resultobj = SWIG_Py_Void();
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj = 0;
12518 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12519 wxString *arg2 = 0 ;
12520 bool result;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 bool temp2 = false ;
12524 PyObject * obj0 = 0 ;
12525 PyObject * obj1 = 0 ;
12526 char * kwnames[] = {
12527 (char *) "self",(char *) "location", NULL
12528 };
12529
12530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12532 if (!SWIG_IsOK(res1)) {
12533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12534 }
12535 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12536 {
12537 arg2 = wxString_in_helper(obj1);
12538 if (arg2 == NULL) SWIG_fail;
12539 temp2 = true;
12540 }
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 {
12548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12549 }
12550 {
12551 if (temp2)
12552 delete arg2;
12553 }
12554 return resultobj;
12555 fail:
12556 {
12557 if (temp2)
12558 delete arg2;
12559 }
12560 return NULL;
12561 }
12562
12563
12564 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12565 PyObject *resultobj = 0;
12566 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12567 wxFileSystem *arg2 = 0 ;
12568 wxString *arg3 = 0 ;
12569 wxFSFile *result = 0 ;
12570 void *argp1 = 0 ;
12571 int res1 = 0 ;
12572 void *argp2 = 0 ;
12573 int res2 = 0 ;
12574 bool temp3 = false ;
12575 PyObject * obj0 = 0 ;
12576 PyObject * obj1 = 0 ;
12577 PyObject * obj2 = 0 ;
12578 char * kwnames[] = {
12579 (char *) "self",(char *) "fs",(char *) "location", NULL
12580 };
12581
12582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12584 if (!SWIG_IsOK(res1)) {
12585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12586 }
12587 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12588 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12589 if (!SWIG_IsOK(res2)) {
12590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12591 }
12592 if (!argp2) {
12593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12594 }
12595 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12596 {
12597 arg3 = wxString_in_helper(obj2);
12598 if (arg3 == NULL) SWIG_fail;
12599 temp3 = true;
12600 }
12601 {
12602 PyThreadState* __tstate = wxPyBeginAllowThreads();
12603 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12604 wxPyEndAllowThreads(__tstate);
12605 if (PyErr_Occurred()) SWIG_fail;
12606 }
12607 {
12608 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12609 }
12610 {
12611 if (temp3)
12612 delete arg3;
12613 }
12614 return resultobj;
12615 fail:
12616 {
12617 if (temp3)
12618 delete arg3;
12619 }
12620 return NULL;
12621 }
12622
12623
12624 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj = 0;
12626 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12627 wxString *arg2 = 0 ;
12628 int arg3 = (int) 0 ;
12629 wxString result;
12630 void *argp1 = 0 ;
12631 int res1 = 0 ;
12632 bool temp2 = false ;
12633 int val3 ;
12634 int ecode3 = 0 ;
12635 PyObject * obj0 = 0 ;
12636 PyObject * obj1 = 0 ;
12637 PyObject * obj2 = 0 ;
12638 char * kwnames[] = {
12639 (char *) "self",(char *) "spec",(char *) "flags", NULL
12640 };
12641
12642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12644 if (!SWIG_IsOK(res1)) {
12645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12646 }
12647 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12648 {
12649 arg2 = wxString_in_helper(obj1);
12650 if (arg2 == NULL) SWIG_fail;
12651 temp2 = true;
12652 }
12653 if (obj2) {
12654 ecode3 = SWIG_AsVal_int(obj2, &val3);
12655 if (!SWIG_IsOK(ecode3)) {
12656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12657 }
12658 arg3 = static_cast< int >(val3);
12659 }
12660 {
12661 PyThreadState* __tstate = wxPyBeginAllowThreads();
12662 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 {
12667 #if wxUSE_UNICODE
12668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12669 #else
12670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12671 #endif
12672 }
12673 {
12674 if (temp2)
12675 delete arg2;
12676 }
12677 return resultobj;
12678 fail:
12679 {
12680 if (temp2)
12681 delete arg2;
12682 }
12683 return NULL;
12684 }
12685
12686
12687 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12688 PyObject *resultobj = 0;
12689 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12690 wxString result;
12691 void *argp1 = 0 ;
12692 int res1 = 0 ;
12693 PyObject *swig_obj[1] ;
12694
12695 if (!args) SWIG_fail;
12696 swig_obj[0] = args;
12697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12698 if (!SWIG_IsOK(res1)) {
12699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12700 }
12701 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12702 {
12703 PyThreadState* __tstate = wxPyBeginAllowThreads();
12704 result = (arg1)->FindNext();
12705 wxPyEndAllowThreads(__tstate);
12706 if (PyErr_Occurred()) SWIG_fail;
12707 }
12708 {
12709 #if wxUSE_UNICODE
12710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12711 #else
12712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12713 #endif
12714 }
12715 return resultobj;
12716 fail:
12717 return NULL;
12718 }
12719
12720
12721 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12722 PyObject *resultobj = 0;
12723 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12724 wxString *arg2 = 0 ;
12725 wxString result;
12726 void *argp1 = 0 ;
12727 int res1 = 0 ;
12728 bool temp2 = false ;
12729 PyObject * obj0 = 0 ;
12730 PyObject * obj1 = 0 ;
12731 char * kwnames[] = {
12732 (char *) "self",(char *) "location", NULL
12733 };
12734
12735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12737 if (!SWIG_IsOK(res1)) {
12738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12739 }
12740 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12741 {
12742 arg2 = wxString_in_helper(obj1);
12743 if (arg2 == NULL) SWIG_fail;
12744 temp2 = true;
12745 }
12746 {
12747 PyThreadState* __tstate = wxPyBeginAllowThreads();
12748 result = (arg1)->GetProtocol((wxString const &)*arg2);
12749 wxPyEndAllowThreads(__tstate);
12750 if (PyErr_Occurred()) SWIG_fail;
12751 }
12752 {
12753 #if wxUSE_UNICODE
12754 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12755 #else
12756 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12757 #endif
12758 }
12759 {
12760 if (temp2)
12761 delete arg2;
12762 }
12763 return resultobj;
12764 fail:
12765 {
12766 if (temp2)
12767 delete arg2;
12768 }
12769 return NULL;
12770 }
12771
12772
12773 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12774 PyObject *resultobj = 0;
12775 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12776 wxString *arg2 = 0 ;
12777 wxString result;
12778 void *argp1 = 0 ;
12779 int res1 = 0 ;
12780 bool temp2 = false ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 char * kwnames[] = {
12784 (char *) "self",(char *) "location", NULL
12785 };
12786
12787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12789 if (!SWIG_IsOK(res1)) {
12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12791 }
12792 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12793 {
12794 arg2 = wxString_in_helper(obj1);
12795 if (arg2 == NULL) SWIG_fail;
12796 temp2 = true;
12797 }
12798 {
12799 PyThreadState* __tstate = wxPyBeginAllowThreads();
12800 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12801 wxPyEndAllowThreads(__tstate);
12802 if (PyErr_Occurred()) SWIG_fail;
12803 }
12804 {
12805 #if wxUSE_UNICODE
12806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12807 #else
12808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12809 #endif
12810 }
12811 {
12812 if (temp2)
12813 delete arg2;
12814 }
12815 return resultobj;
12816 fail:
12817 {
12818 if (temp2)
12819 delete arg2;
12820 }
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12826 PyObject *resultobj = 0;
12827 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12828 wxString *arg2 = 0 ;
12829 wxString result;
12830 void *argp1 = 0 ;
12831 int res1 = 0 ;
12832 bool temp2 = false ;
12833 PyObject * obj0 = 0 ;
12834 PyObject * obj1 = 0 ;
12835 char * kwnames[] = {
12836 (char *) "self",(char *) "location", NULL
12837 };
12838
12839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12841 if (!SWIG_IsOK(res1)) {
12842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12843 }
12844 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12845 {
12846 arg2 = wxString_in_helper(obj1);
12847 if (arg2 == NULL) SWIG_fail;
12848 temp2 = true;
12849 }
12850 {
12851 PyThreadState* __tstate = wxPyBeginAllowThreads();
12852 result = (arg1)->GetAnchor((wxString const &)*arg2);
12853 wxPyEndAllowThreads(__tstate);
12854 if (PyErr_Occurred()) SWIG_fail;
12855 }
12856 {
12857 #if wxUSE_UNICODE
12858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12859 #else
12860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12861 #endif
12862 }
12863 {
12864 if (temp2)
12865 delete arg2;
12866 }
12867 return resultobj;
12868 fail:
12869 {
12870 if (temp2)
12871 delete arg2;
12872 }
12873 return NULL;
12874 }
12875
12876
12877 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12878 PyObject *resultobj = 0;
12879 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12880 wxString *arg2 = 0 ;
12881 wxString result;
12882 void *argp1 = 0 ;
12883 int res1 = 0 ;
12884 bool temp2 = false ;
12885 PyObject * obj0 = 0 ;
12886 PyObject * obj1 = 0 ;
12887 char * kwnames[] = {
12888 (char *) "self",(char *) "location", NULL
12889 };
12890
12891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12893 if (!SWIG_IsOK(res1)) {
12894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12895 }
12896 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12897 {
12898 arg2 = wxString_in_helper(obj1);
12899 if (arg2 == NULL) SWIG_fail;
12900 temp2 = true;
12901 }
12902 {
12903 PyThreadState* __tstate = wxPyBeginAllowThreads();
12904 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12905 wxPyEndAllowThreads(__tstate);
12906 if (PyErr_Occurred()) SWIG_fail;
12907 }
12908 {
12909 #if wxUSE_UNICODE
12910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12911 #else
12912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12913 #endif
12914 }
12915 {
12916 if (temp2)
12917 delete arg2;
12918 }
12919 return resultobj;
12920 fail:
12921 {
12922 if (temp2)
12923 delete arg2;
12924 }
12925 return NULL;
12926 }
12927
12928
12929 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12930 PyObject *resultobj = 0;
12931 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12932 wxString *arg2 = 0 ;
12933 wxString result;
12934 void *argp1 = 0 ;
12935 int res1 = 0 ;
12936 bool temp2 = false ;
12937 PyObject * obj0 = 0 ;
12938 PyObject * obj1 = 0 ;
12939 char * kwnames[] = {
12940 (char *) "self",(char *) "location", NULL
12941 };
12942
12943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12945 if (!SWIG_IsOK(res1)) {
12946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12947 }
12948 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12949 {
12950 arg2 = wxString_in_helper(obj1);
12951 if (arg2 == NULL) SWIG_fail;
12952 temp2 = true;
12953 }
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12957 wxPyEndAllowThreads(__tstate);
12958 if (PyErr_Occurred()) SWIG_fail;
12959 }
12960 {
12961 #if wxUSE_UNICODE
12962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12963 #else
12964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12965 #endif
12966 }
12967 {
12968 if (temp2)
12969 delete arg2;
12970 }
12971 return resultobj;
12972 fail:
12973 {
12974 if (temp2)
12975 delete arg2;
12976 }
12977 return NULL;
12978 }
12979
12980
12981 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12982 PyObject *obj;
12983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12984 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12985 return SWIG_Py_Void();
12986 }
12987
12988 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 return SWIG_Python_InitShadowInstance(args);
12990 }
12991
12992 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 PyObject *resultobj = 0;
12994 wxFileSystem *result = 0 ;
12995
12996 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
12997 {
12998 PyThreadState* __tstate = wxPyBeginAllowThreads();
12999 result = (wxFileSystem *)new wxFileSystem();
13000 wxPyEndAllowThreads(__tstate);
13001 if (PyErr_Occurred()) SWIG_fail;
13002 }
13003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13004 return resultobj;
13005 fail:
13006 return NULL;
13007 }
13008
13009
13010 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13011 PyObject *resultobj = 0;
13012 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13013 void *argp1 = 0 ;
13014 int res1 = 0 ;
13015 PyObject *swig_obj[1] ;
13016
13017 if (!args) SWIG_fail;
13018 swig_obj[0] = args;
13019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13020 if (!SWIG_IsOK(res1)) {
13021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13022 }
13023 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13024 {
13025 PyThreadState* __tstate = wxPyBeginAllowThreads();
13026 delete arg1;
13027
13028 wxPyEndAllowThreads(__tstate);
13029 if (PyErr_Occurred()) SWIG_fail;
13030 }
13031 resultobj = SWIG_Py_Void();
13032 return resultobj;
13033 fail:
13034 return NULL;
13035 }
13036
13037
13038 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj = 0;
13040 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13041 wxString *arg2 = 0 ;
13042 bool arg3 = (bool) false ;
13043 void *argp1 = 0 ;
13044 int res1 = 0 ;
13045 bool temp2 = false ;
13046 bool val3 ;
13047 int ecode3 = 0 ;
13048 PyObject * obj0 = 0 ;
13049 PyObject * obj1 = 0 ;
13050 PyObject * obj2 = 0 ;
13051 char * kwnames[] = {
13052 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13053 };
13054
13055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13057 if (!SWIG_IsOK(res1)) {
13058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13059 }
13060 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13061 {
13062 arg2 = wxString_in_helper(obj1);
13063 if (arg2 == NULL) SWIG_fail;
13064 temp2 = true;
13065 }
13066 if (obj2) {
13067 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13068 if (!SWIG_IsOK(ecode3)) {
13069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13070 }
13071 arg3 = static_cast< bool >(val3);
13072 }
13073 {
13074 PyThreadState* __tstate = wxPyBeginAllowThreads();
13075 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13076 wxPyEndAllowThreads(__tstate);
13077 if (PyErr_Occurred()) SWIG_fail;
13078 }
13079 resultobj = SWIG_Py_Void();
13080 {
13081 if (temp2)
13082 delete arg2;
13083 }
13084 return resultobj;
13085 fail:
13086 {
13087 if (temp2)
13088 delete arg2;
13089 }
13090 return NULL;
13091 }
13092
13093
13094 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13095 PyObject *resultobj = 0;
13096 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13097 wxString result;
13098 void *argp1 = 0 ;
13099 int res1 = 0 ;
13100 PyObject *swig_obj[1] ;
13101
13102 if (!args) SWIG_fail;
13103 swig_obj[0] = args;
13104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13105 if (!SWIG_IsOK(res1)) {
13106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13107 }
13108 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 result = (arg1)->GetPath();
13112 wxPyEndAllowThreads(__tstate);
13113 if (PyErr_Occurred()) SWIG_fail;
13114 }
13115 {
13116 #if wxUSE_UNICODE
13117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13118 #else
13119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13120 #endif
13121 }
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13131 wxString *arg2 = 0 ;
13132 wxFSFile *result = 0 ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 bool temp2 = false ;
13136 PyObject * obj0 = 0 ;
13137 PyObject * obj1 = 0 ;
13138 char * kwnames[] = {
13139 (char *) "self",(char *) "location", NULL
13140 };
13141
13142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13144 if (!SWIG_IsOK(res1)) {
13145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13146 }
13147 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13148 {
13149 arg2 = wxString_in_helper(obj1);
13150 if (arg2 == NULL) SWIG_fail;
13151 temp2 = true;
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 {
13160 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13161 }
13162 {
13163 if (temp2)
13164 delete arg2;
13165 }
13166 return resultobj;
13167 fail:
13168 {
13169 if (temp2)
13170 delete arg2;
13171 }
13172 return NULL;
13173 }
13174
13175
13176 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = 0;
13178 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13179 wxString *arg2 = 0 ;
13180 int arg3 = (int) 0 ;
13181 wxString result;
13182 void *argp1 = 0 ;
13183 int res1 = 0 ;
13184 bool temp2 = false ;
13185 int val3 ;
13186 int ecode3 = 0 ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "self",(char *) "spec",(char *) "flags", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13198 }
13199 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13200 {
13201 arg2 = wxString_in_helper(obj1);
13202 if (arg2 == NULL) SWIG_fail;
13203 temp2 = true;
13204 }
13205 if (obj2) {
13206 ecode3 = SWIG_AsVal_int(obj2, &val3);
13207 if (!SWIG_IsOK(ecode3)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13209 }
13210 arg3 = static_cast< int >(val3);
13211 }
13212 {
13213 PyThreadState* __tstate = wxPyBeginAllowThreads();
13214 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 {
13219 #if wxUSE_UNICODE
13220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13221 #else
13222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13223 #endif
13224 }
13225 {
13226 if (temp2)
13227 delete arg2;
13228 }
13229 return resultobj;
13230 fail:
13231 {
13232 if (temp2)
13233 delete arg2;
13234 }
13235 return NULL;
13236 }
13237
13238
13239 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13240 PyObject *resultobj = 0;
13241 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13242 wxString result;
13243 void *argp1 = 0 ;
13244 int res1 = 0 ;
13245 PyObject *swig_obj[1] ;
13246
13247 if (!args) SWIG_fail;
13248 swig_obj[0] = args;
13249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13250 if (!SWIG_IsOK(res1)) {
13251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13252 }
13253 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13254 {
13255 PyThreadState* __tstate = wxPyBeginAllowThreads();
13256 result = (arg1)->FindNext();
13257 wxPyEndAllowThreads(__tstate);
13258 if (PyErr_Occurred()) SWIG_fail;
13259 }
13260 {
13261 #if wxUSE_UNICODE
13262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13263 #else
13264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13265 #endif
13266 }
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj = 0;
13275 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13276 int res1 = 0 ;
13277 PyObject * obj0 = 0 ;
13278 char * kwnames[] = {
13279 (char *) "handler", NULL
13280 };
13281
13282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13283 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13284 if (!SWIG_IsOK(res1)) {
13285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 wxFileSystem::AddHandler(arg1);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 resultobj = SWIG_Py_Void();
13294 return resultobj;
13295 fail:
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13301 PyObject *resultobj = 0;
13302 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13303 wxFileSystemHandler *result = 0 ;
13304 void *argp1 = 0 ;
13305 int res1 = 0 ;
13306 PyObject * obj0 = 0 ;
13307 char * kwnames[] = {
13308 (char *) "handler", NULL
13309 };
13310
13311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13313 if (!SWIG_IsOK(res1)) {
13314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13315 }
13316 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13317 {
13318 PyThreadState* __tstate = wxPyBeginAllowThreads();
13319 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13324 return resultobj;
13325 fail:
13326 return NULL;
13327 }
13328
13329
13330 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331 PyObject *resultobj = 0;
13332
13333 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13334 {
13335 PyThreadState* __tstate = wxPyBeginAllowThreads();
13336 wxFileSystem::CleanUpHandlers();
13337 wxPyEndAllowThreads(__tstate);
13338 if (PyErr_Occurred()) SWIG_fail;
13339 }
13340 resultobj = SWIG_Py_Void();
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13348 PyObject *resultobj = 0;
13349 wxString *arg1 = 0 ;
13350 wxString result;
13351 bool temp1 = false ;
13352 PyObject * obj0 = 0 ;
13353 char * kwnames[] = {
13354 (char *) "filename", NULL
13355 };
13356
13357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13358 {
13359 arg1 = wxString_in_helper(obj0);
13360 if (arg1 == NULL) SWIG_fail;
13361 temp1 = true;
13362 }
13363 {
13364 PyThreadState* __tstate = wxPyBeginAllowThreads();
13365 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 #if wxUSE_UNICODE
13371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13372 #else
13373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13374 #endif
13375 }
13376 {
13377 if (temp1)
13378 delete arg1;
13379 }
13380 return resultobj;
13381 fail:
13382 {
13383 if (temp1)
13384 delete arg1;
13385 }
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj = 0;
13392 wxString *arg1 = 0 ;
13393 wxString result;
13394 bool temp1 = false ;
13395 PyObject * obj0 = 0 ;
13396 char * kwnames[] = {
13397 (char *) "url", NULL
13398 };
13399
13400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13401 {
13402 arg1 = wxString_in_helper(obj0);
13403 if (arg1 == NULL) SWIG_fail;
13404 temp1 = true;
13405 }
13406 {
13407 PyThreadState* __tstate = wxPyBeginAllowThreads();
13408 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 {
13413 #if wxUSE_UNICODE
13414 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13415 #else
13416 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13417 #endif
13418 }
13419 {
13420 if (temp1)
13421 delete arg1;
13422 }
13423 return resultobj;
13424 fail:
13425 {
13426 if (temp1)
13427 delete arg1;
13428 }
13429 return NULL;
13430 }
13431
13432
13433 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13434 PyObject *obj;
13435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13436 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13437 return SWIG_Py_Void();
13438 }
13439
13440 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13441 return SWIG_Python_InitShadowInstance(args);
13442 }
13443
13444 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 PyObject *resultobj = 0;
13446 wxInternetFSHandler *result = 0 ;
13447
13448 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13449 {
13450 PyThreadState* __tstate = wxPyBeginAllowThreads();
13451 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13456 return resultobj;
13457 fail:
13458 return NULL;
13459 }
13460
13461
13462 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13463 PyObject *resultobj = 0;
13464 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13465 wxString *arg2 = 0 ;
13466 bool result;
13467 void *argp1 = 0 ;
13468 int res1 = 0 ;
13469 bool temp2 = false ;
13470 PyObject * obj0 = 0 ;
13471 PyObject * obj1 = 0 ;
13472 char * kwnames[] = {
13473 (char *) "self",(char *) "location", NULL
13474 };
13475
13476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13478 if (!SWIG_IsOK(res1)) {
13479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13480 }
13481 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13482 {
13483 arg2 = wxString_in_helper(obj1);
13484 if (arg2 == NULL) SWIG_fail;
13485 temp2 = true;
13486 }
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 {
13494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13495 }
13496 {
13497 if (temp2)
13498 delete arg2;
13499 }
13500 return resultobj;
13501 fail:
13502 {
13503 if (temp2)
13504 delete arg2;
13505 }
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13513 wxFileSystem *arg2 = 0 ;
13514 wxString *arg3 = 0 ;
13515 wxFSFile *result = 0 ;
13516 void *argp1 = 0 ;
13517 int res1 = 0 ;
13518 void *argp2 = 0 ;
13519 int res2 = 0 ;
13520 bool temp3 = false ;
13521 PyObject * obj0 = 0 ;
13522 PyObject * obj1 = 0 ;
13523 PyObject * obj2 = 0 ;
13524 char * kwnames[] = {
13525 (char *) "self",(char *) "fs",(char *) "location", NULL
13526 };
13527
13528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13530 if (!SWIG_IsOK(res1)) {
13531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13532 }
13533 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13535 if (!SWIG_IsOK(res2)) {
13536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13537 }
13538 if (!argp2) {
13539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13540 }
13541 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13542 {
13543 arg3 = wxString_in_helper(obj2);
13544 if (arg3 == NULL) SWIG_fail;
13545 temp3 = true;
13546 }
13547 {
13548 PyThreadState* __tstate = wxPyBeginAllowThreads();
13549 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13555 }
13556 {
13557 if (temp3)
13558 delete arg3;
13559 }
13560 return resultobj;
13561 fail:
13562 {
13563 if (temp3)
13564 delete arg3;
13565 }
13566 return NULL;
13567 }
13568
13569
13570 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13571 PyObject *obj;
13572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13573 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13574 return SWIG_Py_Void();
13575 }
13576
13577 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13578 return SWIG_Python_InitShadowInstance(args);
13579 }
13580
13581 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13582 PyObject *resultobj = 0;
13583 wxZipFSHandler *result = 0 ;
13584
13585 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13586 {
13587 PyThreadState* __tstate = wxPyBeginAllowThreads();
13588 result = (wxZipFSHandler *)new wxZipFSHandler();
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13593 return resultobj;
13594 fail:
13595 return NULL;
13596 }
13597
13598
13599 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13600 PyObject *resultobj = 0;
13601 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13602 wxString *arg2 = 0 ;
13603 bool result;
13604 void *argp1 = 0 ;
13605 int res1 = 0 ;
13606 bool temp2 = false ;
13607 PyObject * obj0 = 0 ;
13608 PyObject * obj1 = 0 ;
13609 char * kwnames[] = {
13610 (char *) "self",(char *) "location", NULL
13611 };
13612
13613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13615 if (!SWIG_IsOK(res1)) {
13616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13617 }
13618 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13619 {
13620 arg2 = wxString_in_helper(obj1);
13621 if (arg2 == NULL) SWIG_fail;
13622 temp2 = true;
13623 }
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 {
13631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13632 }
13633 {
13634 if (temp2)
13635 delete arg2;
13636 }
13637 return resultobj;
13638 fail:
13639 {
13640 if (temp2)
13641 delete arg2;
13642 }
13643 return NULL;
13644 }
13645
13646
13647 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj = 0;
13649 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13650 wxFileSystem *arg2 = 0 ;
13651 wxString *arg3 = 0 ;
13652 wxFSFile *result = 0 ;
13653 void *argp1 = 0 ;
13654 int res1 = 0 ;
13655 void *argp2 = 0 ;
13656 int res2 = 0 ;
13657 bool temp3 = false ;
13658 PyObject * obj0 = 0 ;
13659 PyObject * obj1 = 0 ;
13660 PyObject * obj2 = 0 ;
13661 char * kwnames[] = {
13662 (char *) "self",(char *) "fs",(char *) "location", NULL
13663 };
13664
13665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13667 if (!SWIG_IsOK(res1)) {
13668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13669 }
13670 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13671 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13672 if (!SWIG_IsOK(res2)) {
13673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13674 }
13675 if (!argp2) {
13676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13677 }
13678 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13679 {
13680 arg3 = wxString_in_helper(obj2);
13681 if (arg3 == NULL) SWIG_fail;
13682 temp3 = true;
13683 }
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 {
13691 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13692 }
13693 {
13694 if (temp3)
13695 delete arg3;
13696 }
13697 return resultobj;
13698 fail:
13699 {
13700 if (temp3)
13701 delete arg3;
13702 }
13703 return NULL;
13704 }
13705
13706
13707 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13708 PyObject *resultobj = 0;
13709 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13710 wxString *arg2 = 0 ;
13711 int arg3 = (int) 0 ;
13712 wxString result;
13713 void *argp1 = 0 ;
13714 int res1 = 0 ;
13715 bool temp2 = false ;
13716 int val3 ;
13717 int ecode3 = 0 ;
13718 PyObject * obj0 = 0 ;
13719 PyObject * obj1 = 0 ;
13720 PyObject * obj2 = 0 ;
13721 char * kwnames[] = {
13722 (char *) "self",(char *) "spec",(char *) "flags", NULL
13723 };
13724
13725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13727 if (!SWIG_IsOK(res1)) {
13728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13729 }
13730 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13731 {
13732 arg2 = wxString_in_helper(obj1);
13733 if (arg2 == NULL) SWIG_fail;
13734 temp2 = true;
13735 }
13736 if (obj2) {
13737 ecode3 = SWIG_AsVal_int(obj2, &val3);
13738 if (!SWIG_IsOK(ecode3)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13740 }
13741 arg3 = static_cast< int >(val3);
13742 }
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 {
13750 #if wxUSE_UNICODE
13751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13752 #else
13753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13754 #endif
13755 }
13756 {
13757 if (temp2)
13758 delete arg2;
13759 }
13760 return resultobj;
13761 fail:
13762 {
13763 if (temp2)
13764 delete arg2;
13765 }
13766 return NULL;
13767 }
13768
13769
13770 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13771 PyObject *resultobj = 0;
13772 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13773 wxString result;
13774 void *argp1 = 0 ;
13775 int res1 = 0 ;
13776 PyObject *swig_obj[1] ;
13777
13778 if (!args) SWIG_fail;
13779 swig_obj[0] = args;
13780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13781 if (!SWIG_IsOK(res1)) {
13782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13783 }
13784 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13785 {
13786 PyThreadState* __tstate = wxPyBeginAllowThreads();
13787 result = (arg1)->FindNext();
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 {
13792 #if wxUSE_UNICODE
13793 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13794 #else
13795 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13796 #endif
13797 }
13798 return resultobj;
13799 fail:
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13805 PyObject *obj;
13806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13807 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13808 return SWIG_Py_Void();
13809 }
13810
13811 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13812 return SWIG_Python_InitShadowInstance(args);
13813 }
13814
13815 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13816 PyObject *resultobj = 0;
13817 wxString *arg1 = 0 ;
13818 wxImage *arg2 = 0 ;
13819 long arg3 ;
13820 bool temp1 = false ;
13821 void *argp2 = 0 ;
13822 int res2 = 0 ;
13823 long val3 ;
13824 int ecode3 = 0 ;
13825 PyObject * obj0 = 0 ;
13826 PyObject * obj1 = 0 ;
13827 PyObject * obj2 = 0 ;
13828 char * kwnames[] = {
13829 (char *) "filename",(char *) "image",(char *) "type", NULL
13830 };
13831
13832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13833 {
13834 arg1 = wxString_in_helper(obj0);
13835 if (arg1 == NULL) SWIG_fail;
13836 temp1 = true;
13837 }
13838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13839 if (!SWIG_IsOK(res2)) {
13840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13841 }
13842 if (!argp2) {
13843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13844 }
13845 arg2 = reinterpret_cast< wxImage * >(argp2);
13846 ecode3 = SWIG_AsVal_long(obj2, &val3);
13847 if (!SWIG_IsOK(ecode3)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13849 }
13850 arg3 = static_cast< long >(val3);
13851 {
13852 PyThreadState* __tstate = wxPyBeginAllowThreads();
13853 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13854 wxPyEndAllowThreads(__tstate);
13855 if (PyErr_Occurred()) SWIG_fail;
13856 }
13857 resultobj = SWIG_Py_Void();
13858 {
13859 if (temp1)
13860 delete arg1;
13861 }
13862 return resultobj;
13863 fail:
13864 {
13865 if (temp1)
13866 delete arg1;
13867 }
13868 return NULL;
13869 }
13870
13871
13872 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13873 PyObject *resultobj = 0;
13874 wxString *arg1 = 0 ;
13875 wxBitmap *arg2 = 0 ;
13876 long arg3 ;
13877 bool temp1 = false ;
13878 void *argp2 = 0 ;
13879 int res2 = 0 ;
13880 long val3 ;
13881 int ecode3 = 0 ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 PyObject * obj2 = 0 ;
13885 char * kwnames[] = {
13886 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13887 };
13888
13889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13890 {
13891 arg1 = wxString_in_helper(obj0);
13892 if (arg1 == NULL) SWIG_fail;
13893 temp1 = true;
13894 }
13895 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13896 if (!SWIG_IsOK(res2)) {
13897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13898 }
13899 if (!argp2) {
13900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13901 }
13902 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13903 ecode3 = SWIG_AsVal_long(obj2, &val3);
13904 if (!SWIG_IsOK(ecode3)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13906 }
13907 arg3 = static_cast< long >(val3);
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_Py_Void();
13915 {
13916 if (temp1)
13917 delete arg1;
13918 }
13919 return resultobj;
13920 fail:
13921 {
13922 if (temp1)
13923 delete arg1;
13924 }
13925 return NULL;
13926 }
13927
13928
13929 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13930 PyObject *resultobj = 0;
13931 wxString *arg1 = 0 ;
13932 PyObject *arg2 = (PyObject *) 0 ;
13933 bool temp1 = false ;
13934 PyObject * obj0 = 0 ;
13935 PyObject * obj1 = 0 ;
13936 char * kwnames[] = {
13937 (char *) "filename",(char *) "data", NULL
13938 };
13939
13940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13941 {
13942 arg1 = wxString_in_helper(obj0);
13943 if (arg1 == NULL) SWIG_fail;
13944 temp1 = true;
13945 }
13946 arg2 = obj1;
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 resultobj = SWIG_Py_Void();
13954 {
13955 if (temp1)
13956 delete arg1;
13957 }
13958 return resultobj;
13959 fail:
13960 {
13961 if (temp1)
13962 delete arg1;
13963 }
13964 return NULL;
13965 }
13966
13967
13968 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13969 PyObject *resultobj = 0;
13970 wxMemoryFSHandler *result = 0 ;
13971
13972 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13973 {
13974 PyThreadState* __tstate = wxPyBeginAllowThreads();
13975 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13976 wxPyEndAllowThreads(__tstate);
13977 if (PyErr_Occurred()) SWIG_fail;
13978 }
13979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13980 return resultobj;
13981 fail:
13982 return NULL;
13983 }
13984
13985
13986 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13987 PyObject *resultobj = 0;
13988 wxString *arg1 = 0 ;
13989 bool temp1 = false ;
13990 PyObject * obj0 = 0 ;
13991 char * kwnames[] = {
13992 (char *) "filename", NULL
13993 };
13994
13995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
13996 {
13997 arg1 = wxString_in_helper(obj0);
13998 if (arg1 == NULL) SWIG_fail;
13999 temp1 = true;
14000 }
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 resultobj = SWIG_Py_Void();
14008 {
14009 if (temp1)
14010 delete arg1;
14011 }
14012 return resultobj;
14013 fail:
14014 {
14015 if (temp1)
14016 delete arg1;
14017 }
14018 return NULL;
14019 }
14020
14021
14022 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14023 PyObject *resultobj = 0;
14024 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14025 wxString *arg2 = 0 ;
14026 bool result;
14027 void *argp1 = 0 ;
14028 int res1 = 0 ;
14029 bool temp2 = false ;
14030 PyObject * obj0 = 0 ;
14031 PyObject * obj1 = 0 ;
14032 char * kwnames[] = {
14033 (char *) "self",(char *) "location", NULL
14034 };
14035
14036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14038 if (!SWIG_IsOK(res1)) {
14039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14040 }
14041 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14042 {
14043 arg2 = wxString_in_helper(obj1);
14044 if (arg2 == NULL) SWIG_fail;
14045 temp2 = true;
14046 }
14047 {
14048 PyThreadState* __tstate = wxPyBeginAllowThreads();
14049 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14050 wxPyEndAllowThreads(__tstate);
14051 if (PyErr_Occurred()) SWIG_fail;
14052 }
14053 {
14054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14055 }
14056 {
14057 if (temp2)
14058 delete arg2;
14059 }
14060 return resultobj;
14061 fail:
14062 {
14063 if (temp2)
14064 delete arg2;
14065 }
14066 return NULL;
14067 }
14068
14069
14070 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj = 0;
14072 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14073 wxFileSystem *arg2 = 0 ;
14074 wxString *arg3 = 0 ;
14075 wxFSFile *result = 0 ;
14076 void *argp1 = 0 ;
14077 int res1 = 0 ;
14078 void *argp2 = 0 ;
14079 int res2 = 0 ;
14080 bool temp3 = false ;
14081 PyObject * obj0 = 0 ;
14082 PyObject * obj1 = 0 ;
14083 PyObject * obj2 = 0 ;
14084 char * kwnames[] = {
14085 (char *) "self",(char *) "fs",(char *) "location", NULL
14086 };
14087
14088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14090 if (!SWIG_IsOK(res1)) {
14091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14092 }
14093 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14095 if (!SWIG_IsOK(res2)) {
14096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14097 }
14098 if (!argp2) {
14099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14100 }
14101 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14102 {
14103 arg3 = wxString_in_helper(obj2);
14104 if (arg3 == NULL) SWIG_fail;
14105 temp3 = true;
14106 }
14107 {
14108 PyThreadState* __tstate = wxPyBeginAllowThreads();
14109 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14110 wxPyEndAllowThreads(__tstate);
14111 if (PyErr_Occurred()) SWIG_fail;
14112 }
14113 {
14114 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14115 }
14116 {
14117 if (temp3)
14118 delete arg3;
14119 }
14120 return resultobj;
14121 fail:
14122 {
14123 if (temp3)
14124 delete arg3;
14125 }
14126 return NULL;
14127 }
14128
14129
14130 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14131 PyObject *resultobj = 0;
14132 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14133 wxString *arg2 = 0 ;
14134 int arg3 = (int) 0 ;
14135 wxString result;
14136 void *argp1 = 0 ;
14137 int res1 = 0 ;
14138 bool temp2 = false ;
14139 int val3 ;
14140 int ecode3 = 0 ;
14141 PyObject * obj0 = 0 ;
14142 PyObject * obj1 = 0 ;
14143 PyObject * obj2 = 0 ;
14144 char * kwnames[] = {
14145 (char *) "self",(char *) "spec",(char *) "flags", NULL
14146 };
14147
14148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14150 if (!SWIG_IsOK(res1)) {
14151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14152 }
14153 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14154 {
14155 arg2 = wxString_in_helper(obj1);
14156 if (arg2 == NULL) SWIG_fail;
14157 temp2 = true;
14158 }
14159 if (obj2) {
14160 ecode3 = SWIG_AsVal_int(obj2, &val3);
14161 if (!SWIG_IsOK(ecode3)) {
14162 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14163 }
14164 arg3 = static_cast< int >(val3);
14165 }
14166 {
14167 PyThreadState* __tstate = wxPyBeginAllowThreads();
14168 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 {
14173 #if wxUSE_UNICODE
14174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14175 #else
14176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14177 #endif
14178 }
14179 {
14180 if (temp2)
14181 delete arg2;
14182 }
14183 return resultobj;
14184 fail:
14185 {
14186 if (temp2)
14187 delete arg2;
14188 }
14189 return NULL;
14190 }
14191
14192
14193 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14194 PyObject *resultobj = 0;
14195 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14196 wxString result;
14197 void *argp1 = 0 ;
14198 int res1 = 0 ;
14199 PyObject *swig_obj[1] ;
14200
14201 if (!args) SWIG_fail;
14202 swig_obj[0] = args;
14203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14204 if (!SWIG_IsOK(res1)) {
14205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14206 }
14207 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (arg1)->FindNext();
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 {
14215 #if wxUSE_UNICODE
14216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14217 #else
14218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14219 #endif
14220 }
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14228 PyObject *obj;
14229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14230 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14231 return SWIG_Py_Void();
14232 }
14233
14234 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14235 return SWIG_Python_InitShadowInstance(args);
14236 }
14237
14238 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 PyObject *resultobj = 0;
14240 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14241 wxString result;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 PyObject *swig_obj[1] ;
14245
14246 if (!args) SWIG_fail;
14247 swig_obj[0] = args;
14248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14249 if (!SWIG_IsOK(res1)) {
14250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14251 }
14252 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14253 {
14254 PyThreadState* __tstate = wxPyBeginAllowThreads();
14255 result = (arg1)->GetName();
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 {
14260 #if wxUSE_UNICODE
14261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14262 #else
14263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14264 #endif
14265 }
14266 return resultobj;
14267 fail:
14268 return NULL;
14269 }
14270
14271
14272 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14273 PyObject *resultobj = 0;
14274 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14275 wxString result;
14276 void *argp1 = 0 ;
14277 int res1 = 0 ;
14278 PyObject *swig_obj[1] ;
14279
14280 if (!args) SWIG_fail;
14281 swig_obj[0] = args;
14282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14283 if (!SWIG_IsOK(res1)) {
14284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14285 }
14286 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14287 {
14288 PyThreadState* __tstate = wxPyBeginAllowThreads();
14289 result = (arg1)->GetExtension();
14290 wxPyEndAllowThreads(__tstate);
14291 if (PyErr_Occurred()) SWIG_fail;
14292 }
14293 {
14294 #if wxUSE_UNICODE
14295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14296 #else
14297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14298 #endif
14299 }
14300 return resultobj;
14301 fail:
14302 return NULL;
14303 }
14304
14305
14306 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14307 PyObject *resultobj = 0;
14308 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14309 long result;
14310 void *argp1 = 0 ;
14311 int res1 = 0 ;
14312 PyObject *swig_obj[1] ;
14313
14314 if (!args) SWIG_fail;
14315 swig_obj[0] = args;
14316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14317 if (!SWIG_IsOK(res1)) {
14318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14319 }
14320 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 result = (long)(arg1)->GetType();
14324 wxPyEndAllowThreads(__tstate);
14325 if (PyErr_Occurred()) SWIG_fail;
14326 }
14327 resultobj = SWIG_From_long(static_cast< long >(result));
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14335 PyObject *resultobj = 0;
14336 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14337 wxString result;
14338 void *argp1 = 0 ;
14339 int res1 = 0 ;
14340 PyObject *swig_obj[1] ;
14341
14342 if (!args) SWIG_fail;
14343 swig_obj[0] = args;
14344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14345 if (!SWIG_IsOK(res1)) {
14346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14347 }
14348 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (arg1)->GetMimeType();
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 {
14356 #if wxUSE_UNICODE
14357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14358 #else
14359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14360 #endif
14361 }
14362 return resultobj;
14363 fail:
14364 return NULL;
14365 }
14366
14367
14368 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14369 PyObject *resultobj = 0;
14370 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14371 wxString *arg2 = 0 ;
14372 bool result;
14373 void *argp1 = 0 ;
14374 int res1 = 0 ;
14375 bool temp2 = false ;
14376 PyObject * obj0 = 0 ;
14377 PyObject * obj1 = 0 ;
14378 char * kwnames[] = {
14379 (char *) "self",(char *) "name", NULL
14380 };
14381
14382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14384 if (!SWIG_IsOK(res1)) {
14385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14386 }
14387 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14388 {
14389 arg2 = wxString_in_helper(obj1);
14390 if (arg2 == NULL) SWIG_fail;
14391 temp2 = true;
14392 }
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 {
14400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14401 }
14402 {
14403 if (temp2)
14404 delete arg2;
14405 }
14406 return resultobj;
14407 fail:
14408 {
14409 if (temp2)
14410 delete arg2;
14411 }
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14417 PyObject *resultobj = 0;
14418 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14419 wxInputStream *arg2 = 0 ;
14420 bool result;
14421 void *argp1 = 0 ;
14422 int res1 = 0 ;
14423 wxPyInputStream *temp2 ;
14424 bool created2 ;
14425 PyObject * obj0 = 0 ;
14426 PyObject * obj1 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "stream", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14435 }
14436 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14437 {
14438 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14439 arg2 = temp2->m_wxis;
14440 created2 = false;
14441 } else {
14442 PyErr_Clear(); // clear the failure of the wxPyConvert above
14443 arg2 = wxPyCBInputStream_create(obj1, false);
14444 if (arg2 == NULL) {
14445 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14446 SWIG_fail;
14447 }
14448 created2 = true;
14449 }
14450 }
14451 {
14452 PyThreadState* __tstate = wxPyBeginAllowThreads();
14453 result = (bool)(arg1)->CanRead(*arg2);
14454 wxPyEndAllowThreads(__tstate);
14455 if (PyErr_Occurred()) SWIG_fail;
14456 }
14457 {
14458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14459 }
14460 {
14461 if (created2) delete arg2;
14462 }
14463 return resultobj;
14464 fail:
14465 {
14466 if (created2) delete arg2;
14467 }
14468 return NULL;
14469 }
14470
14471
14472 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14473 PyObject *resultobj = 0;
14474 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14475 wxString *arg2 = 0 ;
14476 void *argp1 = 0 ;
14477 int res1 = 0 ;
14478 bool temp2 = false ;
14479 PyObject * obj0 = 0 ;
14480 PyObject * obj1 = 0 ;
14481 char * kwnames[] = {
14482 (char *) "self",(char *) "name", NULL
14483 };
14484
14485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14487 if (!SWIG_IsOK(res1)) {
14488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14489 }
14490 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14491 {
14492 arg2 = wxString_in_helper(obj1);
14493 if (arg2 == NULL) SWIG_fail;
14494 temp2 = true;
14495 }
14496 {
14497 PyThreadState* __tstate = wxPyBeginAllowThreads();
14498 (arg1)->SetName((wxString const &)*arg2);
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_Py_Void();
14503 {
14504 if (temp2)
14505 delete arg2;
14506 }
14507 return resultobj;
14508 fail:
14509 {
14510 if (temp2)
14511 delete arg2;
14512 }
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14520 wxString *arg2 = 0 ;
14521 void *argp1 = 0 ;
14522 int res1 = 0 ;
14523 bool temp2 = false ;
14524 PyObject * obj0 = 0 ;
14525 PyObject * obj1 = 0 ;
14526 char * kwnames[] = {
14527 (char *) "self",(char *) "extension", NULL
14528 };
14529
14530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14532 if (!SWIG_IsOK(res1)) {
14533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14534 }
14535 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14536 {
14537 arg2 = wxString_in_helper(obj1);
14538 if (arg2 == NULL) SWIG_fail;
14539 temp2 = true;
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 (arg1)->SetExtension((wxString const &)*arg2);
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = SWIG_Py_Void();
14548 {
14549 if (temp2)
14550 delete arg2;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14565 long arg2 ;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 long val2 ;
14569 int ecode2 = 0 ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 char * kwnames[] = {
14573 (char *) "self",(char *) "type", NULL
14574 };
14575
14576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14578 if (!SWIG_IsOK(res1)) {
14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14580 }
14581 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14582 ecode2 = SWIG_AsVal_long(obj1, &val2);
14583 if (!SWIG_IsOK(ecode2)) {
14584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14585 }
14586 arg2 = static_cast< long >(val2);
14587 {
14588 PyThreadState* __tstate = wxPyBeginAllowThreads();
14589 (arg1)->SetType(arg2);
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 resultobj = SWIG_Py_Void();
14594 return resultobj;
14595 fail:
14596 return NULL;
14597 }
14598
14599
14600 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14601 PyObject *resultobj = 0;
14602 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14603 wxString *arg2 = 0 ;
14604 void *argp1 = 0 ;
14605 int res1 = 0 ;
14606 bool temp2 = false ;
14607 PyObject * obj0 = 0 ;
14608 PyObject * obj1 = 0 ;
14609 char * kwnames[] = {
14610 (char *) "self",(char *) "mimetype", NULL
14611 };
14612
14613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14615 if (!SWIG_IsOK(res1)) {
14616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14617 }
14618 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14619 {
14620 arg2 = wxString_in_helper(obj1);
14621 if (arg2 == NULL) SWIG_fail;
14622 temp2 = true;
14623 }
14624 {
14625 PyThreadState* __tstate = wxPyBeginAllowThreads();
14626 (arg1)->SetMimeType((wxString const &)*arg2);
14627 wxPyEndAllowThreads(__tstate);
14628 if (PyErr_Occurred()) SWIG_fail;
14629 }
14630 resultobj = SWIG_Py_Void();
14631 {
14632 if (temp2)
14633 delete arg2;
14634 }
14635 return resultobj;
14636 fail:
14637 {
14638 if (temp2)
14639 delete arg2;
14640 }
14641 return NULL;
14642 }
14643
14644
14645 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14646 PyObject *obj;
14647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14648 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14649 return SWIG_Py_Void();
14650 }
14651
14652 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14653 PyObject *resultobj = 0;
14654 wxPyImageHandler *result = 0 ;
14655
14656 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (wxPyImageHandler *)new wxPyImageHandler();
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14664 return resultobj;
14665 fail:
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = 0;
14672 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14673 PyObject *arg2 = (PyObject *) 0 ;
14674 void *argp1 = 0 ;
14675 int res1 = 0 ;
14676 PyObject * obj0 = 0 ;
14677 PyObject * obj1 = 0 ;
14678 char * kwnames[] = {
14679 (char *) "self",(char *) "self", NULL
14680 };
14681
14682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14684 if (!SWIG_IsOK(res1)) {
14685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14686 }
14687 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14688 arg2 = obj1;
14689 {
14690 PyThreadState* __tstate = wxPyBeginAllowThreads();
14691 (arg1)->_SetSelf(arg2);
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 resultobj = SWIG_Py_Void();
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14703 PyObject *obj;
14704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14705 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14706 return SWIG_Py_Void();
14707 }
14708
14709 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14710 return SWIG_Python_InitShadowInstance(args);
14711 }
14712
14713 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14714 PyObject *resultobj = 0;
14715 wxImageHistogram *result = 0 ;
14716
14717 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (wxImageHistogram *)new wxImageHistogram();
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14725 return resultobj;
14726 fail:
14727 return NULL;
14728 }
14729
14730
14731 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj = 0;
14733 byte arg1 ;
14734 byte arg2 ;
14735 byte arg3 ;
14736 unsigned long result;
14737 unsigned char val1 ;
14738 int ecode1 = 0 ;
14739 unsigned char val2 ;
14740 int ecode2 = 0 ;
14741 unsigned char val3 ;
14742 int ecode3 = 0 ;
14743 PyObject * obj0 = 0 ;
14744 PyObject * obj1 = 0 ;
14745 PyObject * obj2 = 0 ;
14746 char * kwnames[] = {
14747 (char *) "r",(char *) "g",(char *) "b", NULL
14748 };
14749
14750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14751 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14752 if (!SWIG_IsOK(ecode1)) {
14753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14754 }
14755 arg1 = static_cast< byte >(val1);
14756 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14757 if (!SWIG_IsOK(ecode2)) {
14758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14759 }
14760 arg2 = static_cast< byte >(val2);
14761 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14762 if (!SWIG_IsOK(ecode3)) {
14763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14764 }
14765 arg3 = static_cast< byte >(val3);
14766 {
14767 PyThreadState* __tstate = wxPyBeginAllowThreads();
14768 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14769 wxPyEndAllowThreads(__tstate);
14770 if (PyErr_Occurred()) SWIG_fail;
14771 }
14772 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14773 return resultobj;
14774 fail:
14775 return NULL;
14776 }
14777
14778
14779 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14780 PyObject *resultobj = 0;
14781 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14782 byte *arg2 = (byte *) 0 ;
14783 byte *arg3 = (byte *) 0 ;
14784 byte *arg4 = (byte *) 0 ;
14785 byte arg5 = (byte) 1 ;
14786 byte arg6 = (byte) 0 ;
14787 byte arg7 = (byte) 0 ;
14788 bool result;
14789 void *argp1 = 0 ;
14790 int res1 = 0 ;
14791 byte temp2 ;
14792 int res2 = SWIG_TMPOBJ ;
14793 byte temp3 ;
14794 int res3 = SWIG_TMPOBJ ;
14795 byte temp4 ;
14796 int res4 = SWIG_TMPOBJ ;
14797 unsigned char val5 ;
14798 int ecode5 = 0 ;
14799 unsigned char val6 ;
14800 int ecode6 = 0 ;
14801 unsigned char val7 ;
14802 int ecode7 = 0 ;
14803 PyObject * obj0 = 0 ;
14804 PyObject * obj1 = 0 ;
14805 PyObject * obj2 = 0 ;
14806 PyObject * obj3 = 0 ;
14807 char * kwnames[] = {
14808 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14809 };
14810
14811 arg2 = &temp2;
14812 arg3 = &temp3;
14813 arg4 = &temp4;
14814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14818 }
14819 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14820 if (obj1) {
14821 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14822 if (!SWIG_IsOK(ecode5)) {
14823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14824 }
14825 arg5 = static_cast< byte >(val5);
14826 }
14827 if (obj2) {
14828 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14829 if (!SWIG_IsOK(ecode6)) {
14830 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14831 }
14832 arg6 = static_cast< byte >(val6);
14833 }
14834 if (obj3) {
14835 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14836 if (!SWIG_IsOK(ecode7)) {
14837 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14838 }
14839 arg7 = static_cast< byte >(val7);
14840 }
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 {
14848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14849 }
14850 if (SWIG_IsTmpObj(res2)) {
14851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14852 } else {
14853 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14854 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14855 }
14856 if (SWIG_IsTmpObj(res3)) {
14857 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14858 } else {
14859 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14860 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14861 }
14862 if (SWIG_IsTmpObj(res4)) {
14863 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14864 } else {
14865 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14866 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14867 }
14868 return resultobj;
14869 fail:
14870 return NULL;
14871 }
14872
14873
14874 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14875 PyObject *resultobj = 0;
14876 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14877 unsigned long arg2 ;
14878 unsigned long result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 unsigned long val2 ;
14882 int ecode2 = 0 ;
14883 PyObject * obj0 = 0 ;
14884 PyObject * obj1 = 0 ;
14885 char * kwnames[] = {
14886 (char *) "self",(char *) "key", NULL
14887 };
14888
14889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14891 if (!SWIG_IsOK(res1)) {
14892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14893 }
14894 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14895 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14896 if (!SWIG_IsOK(ecode2)) {
14897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14898 }
14899 arg2 = static_cast< unsigned long >(val2);
14900 {
14901 PyThreadState* __tstate = wxPyBeginAllowThreads();
14902 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14903 wxPyEndAllowThreads(__tstate);
14904 if (PyErr_Occurred()) SWIG_fail;
14905 }
14906 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14907 return resultobj;
14908 fail:
14909 return NULL;
14910 }
14911
14912
14913 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14914 PyObject *resultobj = 0;
14915 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14916 byte arg2 ;
14917 byte arg3 ;
14918 byte arg4 ;
14919 unsigned long result;
14920 void *argp1 = 0 ;
14921 int res1 = 0 ;
14922 unsigned char val2 ;
14923 int ecode2 = 0 ;
14924 unsigned char val3 ;
14925 int ecode3 = 0 ;
14926 unsigned char val4 ;
14927 int ecode4 = 0 ;
14928 PyObject * obj0 = 0 ;
14929 PyObject * obj1 = 0 ;
14930 PyObject * obj2 = 0 ;
14931 PyObject * obj3 = 0 ;
14932 char * kwnames[] = {
14933 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14934 };
14935
14936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14938 if (!SWIG_IsOK(res1)) {
14939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14940 }
14941 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14942 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14943 if (!SWIG_IsOK(ecode2)) {
14944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14945 }
14946 arg2 = static_cast< byte >(val2);
14947 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14948 if (!SWIG_IsOK(ecode3)) {
14949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14950 }
14951 arg3 = static_cast< byte >(val3);
14952 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14953 if (!SWIG_IsOK(ecode4)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14955 }
14956 arg4 = static_cast< byte >(val4);
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14964 return resultobj;
14965 fail:
14966 return NULL;
14967 }
14968
14969
14970 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14971 PyObject *resultobj = 0;
14972 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14973 wxColour *arg2 = 0 ;
14974 unsigned long result;
14975 void *argp1 = 0 ;
14976 int res1 = 0 ;
14977 wxColour temp2 ;
14978 PyObject * obj0 = 0 ;
14979 PyObject * obj1 = 0 ;
14980 char * kwnames[] = {
14981 (char *) "self",(char *) "colour", NULL
14982 };
14983
14984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14986 if (!SWIG_IsOK(res1)) {
14987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14988 }
14989 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14990 {
14991 arg2 = &temp2;
14992 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14993 }
14994 {
14995 PyThreadState* __tstate = wxPyBeginAllowThreads();
14996 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
14997 wxPyEndAllowThreads(__tstate);
14998 if (PyErr_Occurred()) SWIG_fail;
14999 }
15000 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15001 return resultobj;
15002 fail:
15003 return NULL;
15004 }
15005
15006
15007 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15008 PyObject *obj;
15009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15010 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15011 return SWIG_Py_Void();
15012 }
15013
15014 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15015 return SWIG_Python_InitShadowInstance(args);
15016 }
15017
15018 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15019 PyObject *resultobj = 0;
15020 byte arg1 = (byte) 0 ;
15021 byte arg2 = (byte) 0 ;
15022 byte arg3 = (byte) 0 ;
15023 wxImage_RGBValue *result = 0 ;
15024 unsigned char val1 ;
15025 int ecode1 = 0 ;
15026 unsigned char val2 ;
15027 int ecode2 = 0 ;
15028 unsigned char val3 ;
15029 int ecode3 = 0 ;
15030 PyObject * obj0 = 0 ;
15031 PyObject * obj1 = 0 ;
15032 PyObject * obj2 = 0 ;
15033 char * kwnames[] = {
15034 (char *) "r",(char *) "g",(char *) "b", NULL
15035 };
15036
15037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15038 if (obj0) {
15039 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15040 if (!SWIG_IsOK(ecode1)) {
15041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15042 }
15043 arg1 = static_cast< byte >(val1);
15044 }
15045 if (obj1) {
15046 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15047 if (!SWIG_IsOK(ecode2)) {
15048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15049 }
15050 arg2 = static_cast< byte >(val2);
15051 }
15052 if (obj2) {
15053 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15054 if (!SWIG_IsOK(ecode3)) {
15055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15056 }
15057 arg3 = static_cast< byte >(val3);
15058 }
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15062 wxPyEndAllowThreads(__tstate);
15063 if (PyErr_Occurred()) SWIG_fail;
15064 }
15065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15066 return resultobj;
15067 fail:
15068 return NULL;
15069 }
15070
15071
15072 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15073 PyObject *resultobj = 0;
15074 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15075 byte arg2 ;
15076 void *argp1 = 0 ;
15077 int res1 = 0 ;
15078 unsigned char val2 ;
15079 int ecode2 = 0 ;
15080 PyObject *swig_obj[2] ;
15081
15082 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15084 if (!SWIG_IsOK(res1)) {
15085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15086 }
15087 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15088 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15089 if (!SWIG_IsOK(ecode2)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15091 }
15092 arg2 = static_cast< byte >(val2);
15093 if (arg1) (arg1)->red = arg2;
15094
15095 resultobj = SWIG_Py_Void();
15096 return resultobj;
15097 fail:
15098 return NULL;
15099 }
15100
15101
15102 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15103 PyObject *resultobj = 0;
15104 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15105 byte result;
15106 void *argp1 = 0 ;
15107 int res1 = 0 ;
15108 PyObject *swig_obj[1] ;
15109
15110 if (!args) SWIG_fail;
15111 swig_obj[0] = args;
15112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15113 if (!SWIG_IsOK(res1)) {
15114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15115 }
15116 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15117 result = (byte) ((arg1)->red);
15118 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15119 return resultobj;
15120 fail:
15121 return NULL;
15122 }
15123
15124
15125 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15126 PyObject *resultobj = 0;
15127 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15128 byte arg2 ;
15129 void *argp1 = 0 ;
15130 int res1 = 0 ;
15131 unsigned char val2 ;
15132 int ecode2 = 0 ;
15133 PyObject *swig_obj[2] ;
15134
15135 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15137 if (!SWIG_IsOK(res1)) {
15138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15139 }
15140 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15141 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15142 if (!SWIG_IsOK(ecode2)) {
15143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15144 }
15145 arg2 = static_cast< byte >(val2);
15146 if (arg1) (arg1)->green = arg2;
15147
15148 resultobj = SWIG_Py_Void();
15149 return resultobj;
15150 fail:
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15156 PyObject *resultobj = 0;
15157 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15158 byte result;
15159 void *argp1 = 0 ;
15160 int res1 = 0 ;
15161 PyObject *swig_obj[1] ;
15162
15163 if (!args) SWIG_fail;
15164 swig_obj[0] = args;
15165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15166 if (!SWIG_IsOK(res1)) {
15167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15168 }
15169 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15170 result = (byte) ((arg1)->green);
15171 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15172 return resultobj;
15173 fail:
15174 return NULL;
15175 }
15176
15177
15178 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15179 PyObject *resultobj = 0;
15180 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15181 byte arg2 ;
15182 void *argp1 = 0 ;
15183 int res1 = 0 ;
15184 unsigned char val2 ;
15185 int ecode2 = 0 ;
15186 PyObject *swig_obj[2] ;
15187
15188 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15190 if (!SWIG_IsOK(res1)) {
15191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15192 }
15193 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15194 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15195 if (!SWIG_IsOK(ecode2)) {
15196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15197 }
15198 arg2 = static_cast< byte >(val2);
15199 if (arg1) (arg1)->blue = arg2;
15200
15201 resultobj = SWIG_Py_Void();
15202 return resultobj;
15203 fail:
15204 return NULL;
15205 }
15206
15207
15208 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15209 PyObject *resultobj = 0;
15210 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15211 byte result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 PyObject *swig_obj[1] ;
15215
15216 if (!args) SWIG_fail;
15217 swig_obj[0] = args;
15218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15219 if (!SWIG_IsOK(res1)) {
15220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15221 }
15222 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15223 result = (byte) ((arg1)->blue);
15224 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15232 PyObject *obj;
15233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15234 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15235 return SWIG_Py_Void();
15236 }
15237
15238 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15239 return SWIG_Python_InitShadowInstance(args);
15240 }
15241
15242 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15243 PyObject *resultobj = 0;
15244 double arg1 = (double) 0.0 ;
15245 double arg2 = (double) 0.0 ;
15246 double arg3 = (double) 0.0 ;
15247 wxImage_HSVValue *result = 0 ;
15248 double val1 ;
15249 int ecode1 = 0 ;
15250 double val2 ;
15251 int ecode2 = 0 ;
15252 double val3 ;
15253 int ecode3 = 0 ;
15254 PyObject * obj0 = 0 ;
15255 PyObject * obj1 = 0 ;
15256 PyObject * obj2 = 0 ;
15257 char * kwnames[] = {
15258 (char *) "h",(char *) "s",(char *) "v", NULL
15259 };
15260
15261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15262 if (obj0) {
15263 ecode1 = SWIG_AsVal_double(obj0, &val1);
15264 if (!SWIG_IsOK(ecode1)) {
15265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15266 }
15267 arg1 = static_cast< double >(val1);
15268 }
15269 if (obj1) {
15270 ecode2 = SWIG_AsVal_double(obj1, &val2);
15271 if (!SWIG_IsOK(ecode2)) {
15272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15273 }
15274 arg2 = static_cast< double >(val2);
15275 }
15276 if (obj2) {
15277 ecode3 = SWIG_AsVal_double(obj2, &val3);
15278 if (!SWIG_IsOK(ecode3)) {
15279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15280 }
15281 arg3 = static_cast< double >(val3);
15282 }
15283 {
15284 PyThreadState* __tstate = wxPyBeginAllowThreads();
15285 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15286 wxPyEndAllowThreads(__tstate);
15287 if (PyErr_Occurred()) SWIG_fail;
15288 }
15289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15297 PyObject *resultobj = 0;
15298 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15299 double arg2 ;
15300 void *argp1 = 0 ;
15301 int res1 = 0 ;
15302 double val2 ;
15303 int ecode2 = 0 ;
15304 PyObject *swig_obj[2] ;
15305
15306 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15308 if (!SWIG_IsOK(res1)) {
15309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15310 }
15311 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15312 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15313 if (!SWIG_IsOK(ecode2)) {
15314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15315 }
15316 arg2 = static_cast< double >(val2);
15317 if (arg1) (arg1)->hue = arg2;
15318
15319 resultobj = SWIG_Py_Void();
15320 return resultobj;
15321 fail:
15322 return NULL;
15323 }
15324
15325
15326 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15327 PyObject *resultobj = 0;
15328 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15329 double result;
15330 void *argp1 = 0 ;
15331 int res1 = 0 ;
15332 PyObject *swig_obj[1] ;
15333
15334 if (!args) SWIG_fail;
15335 swig_obj[0] = args;
15336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15337 if (!SWIG_IsOK(res1)) {
15338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15339 }
15340 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15341 result = (double) ((arg1)->hue);
15342 resultobj = SWIG_From_double(static_cast< double >(result));
15343 return resultobj;
15344 fail:
15345 return NULL;
15346 }
15347
15348
15349 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15350 PyObject *resultobj = 0;
15351 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15352 double arg2 ;
15353 void *argp1 = 0 ;
15354 int res1 = 0 ;
15355 double val2 ;
15356 int ecode2 = 0 ;
15357 PyObject *swig_obj[2] ;
15358
15359 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15363 }
15364 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15366 if (!SWIG_IsOK(ecode2)) {
15367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15368 }
15369 arg2 = static_cast< double >(val2);
15370 if (arg1) (arg1)->saturation = arg2;
15371
15372 resultobj = SWIG_Py_Void();
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15380 PyObject *resultobj = 0;
15381 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15382 double result;
15383 void *argp1 = 0 ;
15384 int res1 = 0 ;
15385 PyObject *swig_obj[1] ;
15386
15387 if (!args) SWIG_fail;
15388 swig_obj[0] = args;
15389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15394 result = (double) ((arg1)->saturation);
15395 resultobj = SWIG_From_double(static_cast< double >(result));
15396 return resultobj;
15397 fail:
15398 return NULL;
15399 }
15400
15401
15402 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15403 PyObject *resultobj = 0;
15404 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15405 double arg2 ;
15406 void *argp1 = 0 ;
15407 int res1 = 0 ;
15408 double val2 ;
15409 int ecode2 = 0 ;
15410 PyObject *swig_obj[2] ;
15411
15412 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15414 if (!SWIG_IsOK(res1)) {
15415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15416 }
15417 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15418 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15419 if (!SWIG_IsOK(ecode2)) {
15420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15421 }
15422 arg2 = static_cast< double >(val2);
15423 if (arg1) (arg1)->value = arg2;
15424
15425 resultobj = SWIG_Py_Void();
15426 return resultobj;
15427 fail:
15428 return NULL;
15429 }
15430
15431
15432 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15433 PyObject *resultobj = 0;
15434 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15435 double result;
15436 void *argp1 = 0 ;
15437 int res1 = 0 ;
15438 PyObject *swig_obj[1] ;
15439
15440 if (!args) SWIG_fail;
15441 swig_obj[0] = args;
15442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15443 if (!SWIG_IsOK(res1)) {
15444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15445 }
15446 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15447 result = (double) ((arg1)->value);
15448 resultobj = SWIG_From_double(static_cast< double >(result));
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15456 PyObject *obj;
15457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15458 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15459 return SWIG_Py_Void();
15460 }
15461
15462 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463 return SWIG_Python_InitShadowInstance(args);
15464 }
15465
15466 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15467 PyObject *resultobj = 0;
15468 wxString *arg1 = 0 ;
15469 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15470 int arg3 = (int) -1 ;
15471 wxImage *result = 0 ;
15472 bool temp1 = false ;
15473 long val2 ;
15474 int ecode2 = 0 ;
15475 int val3 ;
15476 int ecode3 = 0 ;
15477 PyObject * obj0 = 0 ;
15478 PyObject * obj1 = 0 ;
15479 PyObject * obj2 = 0 ;
15480 char * kwnames[] = {
15481 (char *) "name",(char *) "type",(char *) "index", NULL
15482 };
15483
15484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15485 {
15486 arg1 = wxString_in_helper(obj0);
15487 if (arg1 == NULL) SWIG_fail;
15488 temp1 = true;
15489 }
15490 if (obj1) {
15491 ecode2 = SWIG_AsVal_long(obj1, &val2);
15492 if (!SWIG_IsOK(ecode2)) {
15493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15494 }
15495 arg2 = static_cast< long >(val2);
15496 }
15497 if (obj2) {
15498 ecode3 = SWIG_AsVal_int(obj2, &val3);
15499 if (!SWIG_IsOK(ecode3)) {
15500 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15501 }
15502 arg3 = static_cast< int >(val3);
15503 }
15504 {
15505 PyThreadState* __tstate = wxPyBeginAllowThreads();
15506 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15507 wxPyEndAllowThreads(__tstate);
15508 if (PyErr_Occurred()) SWIG_fail;
15509 }
15510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15511 {
15512 if (temp1)
15513 delete arg1;
15514 }
15515 return resultobj;
15516 fail:
15517 {
15518 if (temp1)
15519 delete arg1;
15520 }
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxImage *arg1 = (wxImage *) 0 ;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 PyObject *swig_obj[1] ;
15531
15532 if (!args) SWIG_fail;
15533 swig_obj[0] = args;
15534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15535 if (!SWIG_IsOK(res1)) {
15536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15537 }
15538 arg1 = reinterpret_cast< wxImage * >(argp1);
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 delete arg1;
15542
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = SWIG_Py_Void();
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxString *arg1 = 0 ;
15556 wxString *arg2 = 0 ;
15557 int arg3 = (int) -1 ;
15558 wxImage *result = 0 ;
15559 bool temp1 = false ;
15560 bool temp2 = false ;
15561 int val3 ;
15562 int ecode3 = 0 ;
15563 PyObject * obj0 = 0 ;
15564 PyObject * obj1 = 0 ;
15565 PyObject * obj2 = 0 ;
15566 char * kwnames[] = {
15567 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15568 };
15569
15570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15571 {
15572 arg1 = wxString_in_helper(obj0);
15573 if (arg1 == NULL) SWIG_fail;
15574 temp1 = true;
15575 }
15576 {
15577 arg2 = wxString_in_helper(obj1);
15578 if (arg2 == NULL) SWIG_fail;
15579 temp2 = true;
15580 }
15581 if (obj2) {
15582 ecode3 = SWIG_AsVal_int(obj2, &val3);
15583 if (!SWIG_IsOK(ecode3)) {
15584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15585 }
15586 arg3 = static_cast< int >(val3);
15587 }
15588 {
15589 PyThreadState* __tstate = wxPyBeginAllowThreads();
15590 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15591 wxPyEndAllowThreads(__tstate);
15592 if (PyErr_Occurred()) SWIG_fail;
15593 }
15594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15595 {
15596 if (temp1)
15597 delete arg1;
15598 }
15599 {
15600 if (temp2)
15601 delete arg2;
15602 }
15603 return resultobj;
15604 fail:
15605 {
15606 if (temp1)
15607 delete arg1;
15608 }
15609 {
15610 if (temp2)
15611 delete arg2;
15612 }
15613 return NULL;
15614 }
15615
15616
15617 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj = 0;
15619 wxInputStream *arg1 = 0 ;
15620 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15621 int arg3 = (int) -1 ;
15622 wxImage *result = 0 ;
15623 wxPyInputStream *temp1 ;
15624 bool created1 ;
15625 long val2 ;
15626 int ecode2 = 0 ;
15627 int val3 ;
15628 int ecode3 = 0 ;
15629 PyObject * obj0 = 0 ;
15630 PyObject * obj1 = 0 ;
15631 PyObject * obj2 = 0 ;
15632 char * kwnames[] = {
15633 (char *) "stream",(char *) "type",(char *) "index", NULL
15634 };
15635
15636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15637 {
15638 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15639 arg1 = temp1->m_wxis;
15640 created1 = false;
15641 } else {
15642 PyErr_Clear(); // clear the failure of the wxPyConvert above
15643 arg1 = wxPyCBInputStream_create(obj0, false);
15644 if (arg1 == NULL) {
15645 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15646 SWIG_fail;
15647 }
15648 created1 = true;
15649 }
15650 }
15651 if (obj1) {
15652 ecode2 = SWIG_AsVal_long(obj1, &val2);
15653 if (!SWIG_IsOK(ecode2)) {
15654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15655 }
15656 arg2 = static_cast< long >(val2);
15657 }
15658 if (obj2) {
15659 ecode3 = SWIG_AsVal_int(obj2, &val3);
15660 if (!SWIG_IsOK(ecode3)) {
15661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15662 }
15663 arg3 = static_cast< int >(val3);
15664 }
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15672 {
15673 if (created1) delete arg1;
15674 }
15675 return resultobj;
15676 fail:
15677 {
15678 if (created1) delete arg1;
15679 }
15680 return NULL;
15681 }
15682
15683
15684 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15685 PyObject *resultobj = 0;
15686 wxInputStream *arg1 = 0 ;
15687 wxString *arg2 = 0 ;
15688 int arg3 = (int) -1 ;
15689 wxImage *result = 0 ;
15690 wxPyInputStream *temp1 ;
15691 bool created1 ;
15692 bool temp2 = false ;
15693 int val3 ;
15694 int ecode3 = 0 ;
15695 PyObject * obj0 = 0 ;
15696 PyObject * obj1 = 0 ;
15697 PyObject * obj2 = 0 ;
15698 char * kwnames[] = {
15699 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15700 };
15701
15702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15703 {
15704 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15705 arg1 = temp1->m_wxis;
15706 created1 = false;
15707 } else {
15708 PyErr_Clear(); // clear the failure of the wxPyConvert above
15709 arg1 = wxPyCBInputStream_create(obj0, false);
15710 if (arg1 == NULL) {
15711 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15712 SWIG_fail;
15713 }
15714 created1 = true;
15715 }
15716 }
15717 {
15718 arg2 = wxString_in_helper(obj1);
15719 if (arg2 == NULL) SWIG_fail;
15720 temp2 = true;
15721 }
15722 if (obj2) {
15723 ecode3 = SWIG_AsVal_int(obj2, &val3);
15724 if (!SWIG_IsOK(ecode3)) {
15725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15726 }
15727 arg3 = static_cast< int >(val3);
15728 }
15729 {
15730 PyThreadState* __tstate = wxPyBeginAllowThreads();
15731 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15732 wxPyEndAllowThreads(__tstate);
15733 if (PyErr_Occurred()) SWIG_fail;
15734 }
15735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15736 {
15737 if (created1) delete arg1;
15738 }
15739 {
15740 if (temp2)
15741 delete arg2;
15742 }
15743 return resultobj;
15744 fail:
15745 {
15746 if (created1) delete arg1;
15747 }
15748 {
15749 if (temp2)
15750 delete arg2;
15751 }
15752 return NULL;
15753 }
15754
15755
15756 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj = 0;
15758 int arg1 = (int) 0 ;
15759 int arg2 = (int) 0 ;
15760 bool arg3 = (bool) true ;
15761 wxImage *result = 0 ;
15762 int val1 ;
15763 int ecode1 = 0 ;
15764 int val2 ;
15765 int ecode2 = 0 ;
15766 bool val3 ;
15767 int ecode3 = 0 ;
15768 PyObject * obj0 = 0 ;
15769 PyObject * obj1 = 0 ;
15770 PyObject * obj2 = 0 ;
15771 char * kwnames[] = {
15772 (char *) "width",(char *) "height",(char *) "clear", NULL
15773 };
15774
15775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15776 if (obj0) {
15777 ecode1 = SWIG_AsVal_int(obj0, &val1);
15778 if (!SWIG_IsOK(ecode1)) {
15779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15780 }
15781 arg1 = static_cast< int >(val1);
15782 }
15783 if (obj1) {
15784 ecode2 = SWIG_AsVal_int(obj1, &val2);
15785 if (!SWIG_IsOK(ecode2)) {
15786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15787 }
15788 arg2 = static_cast< int >(val2);
15789 }
15790 if (obj2) {
15791 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15792 if (!SWIG_IsOK(ecode3)) {
15793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15794 }
15795 arg3 = static_cast< bool >(val3);
15796 }
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15804 return resultobj;
15805 fail:
15806 return NULL;
15807 }
15808
15809
15810 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15811 PyObject *resultobj = 0;
15812 wxBitmap *arg1 = 0 ;
15813 wxImage *result = 0 ;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 PyObject * obj0 = 0 ;
15817 char * kwnames[] = {
15818 (char *) "bitmap", NULL
15819 };
15820
15821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15822 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15823 if (!SWIG_IsOK(res1)) {
15824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15825 }
15826 if (!argp1) {
15827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15828 }
15829 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15830 {
15831 if (!wxPyCheckForApp()) SWIG_fail;
15832 PyThreadState* __tstate = wxPyBeginAllowThreads();
15833 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15838 return resultobj;
15839 fail:
15840 return NULL;
15841 }
15842
15843
15844 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15845 PyObject *resultobj = 0;
15846 int arg1 ;
15847 int arg2 ;
15848 buffer arg3 ;
15849 int arg4 ;
15850 wxImage *result = 0 ;
15851 int val1 ;
15852 int ecode1 = 0 ;
15853 int val2 ;
15854 int ecode2 = 0 ;
15855 Py_ssize_t temp3 ;
15856 PyObject * obj0 = 0 ;
15857 PyObject * obj1 = 0 ;
15858 PyObject * obj2 = 0 ;
15859 char * kwnames[] = {
15860 (char *) "width",(char *) "height",(char *) "data", NULL
15861 };
15862
15863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15864 ecode1 = SWIG_AsVal_int(obj0, &val1);
15865 if (!SWIG_IsOK(ecode1)) {
15866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15867 }
15868 arg1 = static_cast< int >(val1);
15869 ecode2 = SWIG_AsVal_int(obj1, &val2);
15870 if (!SWIG_IsOK(ecode2)) {
15871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15872 }
15873 arg2 = static_cast< int >(val2);
15874 {
15875 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15876 arg4 = (int)temp3;
15877 }
15878 {
15879 PyThreadState* __tstate = wxPyBeginAllowThreads();
15880 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15881 wxPyEndAllowThreads(__tstate);
15882 if (PyErr_Occurred()) SWIG_fail;
15883 }
15884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15885 return resultobj;
15886 fail:
15887 return NULL;
15888 }
15889
15890
15891 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15892 PyObject *resultobj = 0;
15893 int arg1 ;
15894 int arg2 ;
15895 buffer arg3 ;
15896 int arg4 ;
15897 buffer arg5 ;
15898 int arg6 ;
15899 wxImage *result = 0 ;
15900 int val1 ;
15901 int ecode1 = 0 ;
15902 int val2 ;
15903 int ecode2 = 0 ;
15904 Py_ssize_t temp3 ;
15905 Py_ssize_t temp5 ;
15906 PyObject * obj0 = 0 ;
15907 PyObject * obj1 = 0 ;
15908 PyObject * obj2 = 0 ;
15909 PyObject * obj3 = 0 ;
15910 char * kwnames[] = {
15911 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15912 };
15913
15914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15915 ecode1 = SWIG_AsVal_int(obj0, &val1);
15916 if (!SWIG_IsOK(ecode1)) {
15917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15918 }
15919 arg1 = static_cast< int >(val1);
15920 ecode2 = SWIG_AsVal_int(obj1, &val2);
15921 if (!SWIG_IsOK(ecode2)) {
15922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15923 }
15924 arg2 = static_cast< int >(val2);
15925 {
15926 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15927 arg4 = (int)temp3;
15928 }
15929 {
15930 if (obj3 != Py_None) {
15931 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15932 arg6 = (int)temp5;
15933 }
15934 }
15935 {
15936 PyThreadState* __tstate = wxPyBeginAllowThreads();
15937 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15938 wxPyEndAllowThreads(__tstate);
15939 if (PyErr_Occurred()) SWIG_fail;
15940 }
15941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15942 return resultobj;
15943 fail:
15944 return NULL;
15945 }
15946
15947
15948 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15949 PyObject *resultobj = 0;
15950 wxImage *arg1 = (wxImage *) 0 ;
15951 int arg2 ;
15952 int arg3 ;
15953 bool arg4 = (bool) true ;
15954 void *argp1 = 0 ;
15955 int res1 = 0 ;
15956 int val2 ;
15957 int ecode2 = 0 ;
15958 int val3 ;
15959 int ecode3 = 0 ;
15960 bool val4 ;
15961 int ecode4 = 0 ;
15962 PyObject * obj0 = 0 ;
15963 PyObject * obj1 = 0 ;
15964 PyObject * obj2 = 0 ;
15965 PyObject * obj3 = 0 ;
15966 char * kwnames[] = {
15967 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15968 };
15969
15970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15974 }
15975 arg1 = reinterpret_cast< wxImage * >(argp1);
15976 ecode2 = SWIG_AsVal_int(obj1, &val2);
15977 if (!SWIG_IsOK(ecode2)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15979 }
15980 arg2 = static_cast< int >(val2);
15981 ecode3 = SWIG_AsVal_int(obj2, &val3);
15982 if (!SWIG_IsOK(ecode3)) {
15983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15984 }
15985 arg3 = static_cast< int >(val3);
15986 if (obj3) {
15987 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15988 if (!SWIG_IsOK(ecode4)) {
15989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15990 }
15991 arg4 = static_cast< bool >(val4);
15992 }
15993 {
15994 PyThreadState* __tstate = wxPyBeginAllowThreads();
15995 (arg1)->Create(arg2,arg3,arg4);
15996 wxPyEndAllowThreads(__tstate);
15997 if (PyErr_Occurred()) SWIG_fail;
15998 }
15999 resultobj = SWIG_Py_Void();
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16007 PyObject *resultobj = 0;
16008 wxImage *arg1 = (wxImage *) 0 ;
16009 void *argp1 = 0 ;
16010 int res1 = 0 ;
16011 PyObject *swig_obj[1] ;
16012
16013 if (!args) SWIG_fail;
16014 swig_obj[0] = args;
16015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16016 if (!SWIG_IsOK(res1)) {
16017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16018 }
16019 arg1 = reinterpret_cast< wxImage * >(argp1);
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 (arg1)->Destroy();
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 resultobj = SWIG_Py_Void();
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj = 0;
16035 wxImage *arg1 = (wxImage *) 0 ;
16036 int arg2 ;
16037 int arg3 ;
16038 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16039 SwigValueWrapper<wxImage > result;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 int val2 ;
16043 int ecode2 = 0 ;
16044 int val3 ;
16045 int ecode3 = 0 ;
16046 int val4 ;
16047 int ecode4 = 0 ;
16048 PyObject * obj0 = 0 ;
16049 PyObject * obj1 = 0 ;
16050 PyObject * obj2 = 0 ;
16051 PyObject * obj3 = 0 ;
16052 char * kwnames[] = {
16053 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16054 };
16055
16056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16058 if (!SWIG_IsOK(res1)) {
16059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16060 }
16061 arg1 = reinterpret_cast< wxImage * >(argp1);
16062 ecode2 = SWIG_AsVal_int(obj1, &val2);
16063 if (!SWIG_IsOK(ecode2)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16065 }
16066 arg2 = static_cast< int >(val2);
16067 ecode3 = SWIG_AsVal_int(obj2, &val3);
16068 if (!SWIG_IsOK(ecode3)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16070 }
16071 arg3 = static_cast< int >(val3);
16072 if (obj3) {
16073 ecode4 = SWIG_AsVal_int(obj3, &val4);
16074 if (!SWIG_IsOK(ecode4)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16076 }
16077 arg4 = static_cast< int >(val4);
16078 }
16079 {
16080 PyThreadState* __tstate = wxPyBeginAllowThreads();
16081 result = (arg1)->Scale(arg2,arg3,arg4);
16082 wxPyEndAllowThreads(__tstate);
16083 if (PyErr_Occurred()) SWIG_fail;
16084 }
16085 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16086 return resultobj;
16087 fail:
16088 return NULL;
16089 }
16090
16091
16092 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16093 PyObject *resultobj = 0;
16094 wxImage *arg1 = (wxImage *) 0 ;
16095 int arg2 ;
16096 int arg3 ;
16097 SwigValueWrapper<wxImage > result;
16098 void *argp1 = 0 ;
16099 int res1 = 0 ;
16100 int val2 ;
16101 int ecode2 = 0 ;
16102 int val3 ;
16103 int ecode3 = 0 ;
16104 PyObject * obj0 = 0 ;
16105 PyObject * obj1 = 0 ;
16106 PyObject * obj2 = 0 ;
16107 char * kwnames[] = {
16108 (char *) "self",(char *) "width",(char *) "height", NULL
16109 };
16110
16111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16113 if (!SWIG_IsOK(res1)) {
16114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16115 }
16116 arg1 = reinterpret_cast< wxImage * >(argp1);
16117 ecode2 = SWIG_AsVal_int(obj1, &val2);
16118 if (!SWIG_IsOK(ecode2)) {
16119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16120 }
16121 arg2 = static_cast< int >(val2);
16122 ecode3 = SWIG_AsVal_int(obj2, &val3);
16123 if (!SWIG_IsOK(ecode3)) {
16124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16125 }
16126 arg3 = static_cast< int >(val3);
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj = 0;
16142 wxImage *arg1 = (wxImage *) 0 ;
16143 int arg2 ;
16144 int arg3 ;
16145 SwigValueWrapper<wxImage > result;
16146 void *argp1 = 0 ;
16147 int res1 = 0 ;
16148 int val2 ;
16149 int ecode2 = 0 ;
16150 int val3 ;
16151 int ecode3 = 0 ;
16152 PyObject * obj0 = 0 ;
16153 PyObject * obj1 = 0 ;
16154 PyObject * obj2 = 0 ;
16155 char * kwnames[] = {
16156 (char *) "self",(char *) "width",(char *) "height", NULL
16157 };
16158
16159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16161 if (!SWIG_IsOK(res1)) {
16162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16163 }
16164 arg1 = reinterpret_cast< wxImage * >(argp1);
16165 ecode2 = SWIG_AsVal_int(obj1, &val2);
16166 if (!SWIG_IsOK(ecode2)) {
16167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16168 }
16169 arg2 = static_cast< int >(val2);
16170 ecode3 = SWIG_AsVal_int(obj2, &val3);
16171 if (!SWIG_IsOK(ecode3)) {
16172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16173 }
16174 arg3 = static_cast< int >(val3);
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16189 PyObject *resultobj = 0;
16190 wxImage *arg1 = (wxImage *) 0 ;
16191 int arg2 ;
16192 SwigValueWrapper<wxImage > result;
16193 void *argp1 = 0 ;
16194 int res1 = 0 ;
16195 int val2 ;
16196 int ecode2 = 0 ;
16197 PyObject * obj0 = 0 ;
16198 PyObject * obj1 = 0 ;
16199 char * kwnames[] = {
16200 (char *) "self",(char *) "radius", NULL
16201 };
16202
16203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16205 if (!SWIG_IsOK(res1)) {
16206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16207 }
16208 arg1 = reinterpret_cast< wxImage * >(argp1);
16209 ecode2 = SWIG_AsVal_int(obj1, &val2);
16210 if (!SWIG_IsOK(ecode2)) {
16211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16212 }
16213 arg2 = static_cast< int >(val2);
16214 {
16215 PyThreadState* __tstate = wxPyBeginAllowThreads();
16216 result = (arg1)->Blur(arg2);
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16221 return resultobj;
16222 fail:
16223 return NULL;
16224 }
16225
16226
16227 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16228 PyObject *resultobj = 0;
16229 wxImage *arg1 = (wxImage *) 0 ;
16230 int arg2 ;
16231 SwigValueWrapper<wxImage > result;
16232 void *argp1 = 0 ;
16233 int res1 = 0 ;
16234 int val2 ;
16235 int ecode2 = 0 ;
16236 PyObject * obj0 = 0 ;
16237 PyObject * obj1 = 0 ;
16238 char * kwnames[] = {
16239 (char *) "self",(char *) "radius", NULL
16240 };
16241
16242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16244 if (!SWIG_IsOK(res1)) {
16245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16246 }
16247 arg1 = reinterpret_cast< wxImage * >(argp1);
16248 ecode2 = SWIG_AsVal_int(obj1, &val2);
16249 if (!SWIG_IsOK(ecode2)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16251 }
16252 arg2 = static_cast< int >(val2);
16253 {
16254 PyThreadState* __tstate = wxPyBeginAllowThreads();
16255 result = (arg1)->BlurHorizontal(arg2);
16256 wxPyEndAllowThreads(__tstate);
16257 if (PyErr_Occurred()) SWIG_fail;
16258 }
16259 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16260 return resultobj;
16261 fail:
16262 return NULL;
16263 }
16264
16265
16266 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16267 PyObject *resultobj = 0;
16268 wxImage *arg1 = (wxImage *) 0 ;
16269 int arg2 ;
16270 SwigValueWrapper<wxImage > result;
16271 void *argp1 = 0 ;
16272 int res1 = 0 ;
16273 int val2 ;
16274 int ecode2 = 0 ;
16275 PyObject * obj0 = 0 ;
16276 PyObject * obj1 = 0 ;
16277 char * kwnames[] = {
16278 (char *) "self",(char *) "radius", NULL
16279 };
16280
16281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16283 if (!SWIG_IsOK(res1)) {
16284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16285 }
16286 arg1 = reinterpret_cast< wxImage * >(argp1);
16287 ecode2 = SWIG_AsVal_int(obj1, &val2);
16288 if (!SWIG_IsOK(ecode2)) {
16289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16290 }
16291 arg2 = static_cast< int >(val2);
16292 {
16293 PyThreadState* __tstate = wxPyBeginAllowThreads();
16294 result = (arg1)->BlurVertical(arg2);
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16299 return resultobj;
16300 fail:
16301 return NULL;
16302 }
16303
16304
16305 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16306 PyObject *resultobj = 0;
16307 wxImage *arg1 = (wxImage *) 0 ;
16308 int arg2 ;
16309 int arg3 ;
16310 SwigValueWrapper<wxImage > result;
16311 void *argp1 = 0 ;
16312 int res1 = 0 ;
16313 int val2 ;
16314 int ecode2 = 0 ;
16315 int val3 ;
16316 int ecode3 = 0 ;
16317 PyObject * obj0 = 0 ;
16318 PyObject * obj1 = 0 ;
16319 PyObject * obj2 = 0 ;
16320 char * kwnames[] = {
16321 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16322 };
16323
16324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16326 if (!SWIG_IsOK(res1)) {
16327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16328 }
16329 arg1 = reinterpret_cast< wxImage * >(argp1);
16330 ecode2 = SWIG_AsVal_int(obj1, &val2);
16331 if (!SWIG_IsOK(ecode2)) {
16332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16333 }
16334 arg2 = static_cast< int >(val2);
16335 ecode3 = SWIG_AsVal_int(obj2, &val3);
16336 if (!SWIG_IsOK(ecode3)) {
16337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16338 }
16339 arg3 = static_cast< int >(val3);
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16343 wxPyEndAllowThreads(__tstate);
16344 if (PyErr_Occurred()) SWIG_fail;
16345 }
16346 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16347 return resultobj;
16348 fail:
16349 return NULL;
16350 }
16351
16352
16353 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16354 PyObject *resultobj = 0;
16355 wxImage *arg1 = (wxImage *) 0 ;
16356 int arg2 ;
16357 int arg3 ;
16358 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16359 wxImage *result = 0 ;
16360 void *argp1 = 0 ;
16361 int res1 = 0 ;
16362 int val2 ;
16363 int ecode2 = 0 ;
16364 int val3 ;
16365 int ecode3 = 0 ;
16366 int val4 ;
16367 int ecode4 = 0 ;
16368 PyObject * obj0 = 0 ;
16369 PyObject * obj1 = 0 ;
16370 PyObject * obj2 = 0 ;
16371 PyObject * obj3 = 0 ;
16372 char * kwnames[] = {
16373 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16374 };
16375
16376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16378 if (!SWIG_IsOK(res1)) {
16379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16380 }
16381 arg1 = reinterpret_cast< wxImage * >(argp1);
16382 ecode2 = SWIG_AsVal_int(obj1, &val2);
16383 if (!SWIG_IsOK(ecode2)) {
16384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16385 }
16386 arg2 = static_cast< int >(val2);
16387 ecode3 = SWIG_AsVal_int(obj2, &val3);
16388 if (!SWIG_IsOK(ecode3)) {
16389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16390 }
16391 arg3 = static_cast< int >(val3);
16392 if (obj3) {
16393 ecode4 = SWIG_AsVal_int(obj3, &val4);
16394 if (!SWIG_IsOK(ecode4)) {
16395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16396 }
16397 arg4 = static_cast< int >(val4);
16398 }
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 {
16402 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16403 result = (wxImage *) &_result_ref;
16404 }
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16416 PyObject *resultobj = 0;
16417 wxImage *arg1 = (wxImage *) 0 ;
16418 wxSize *arg2 = 0 ;
16419 wxPoint *arg3 = 0 ;
16420 int arg4 = (int) -1 ;
16421 int arg5 = (int) -1 ;
16422 int arg6 = (int) -1 ;
16423 wxImage *result = 0 ;
16424 void *argp1 = 0 ;
16425 int res1 = 0 ;
16426 wxSize temp2 ;
16427 wxPoint temp3 ;
16428 int val4 ;
16429 int ecode4 = 0 ;
16430 int val5 ;
16431 int ecode5 = 0 ;
16432 int val6 ;
16433 int ecode6 = 0 ;
16434 PyObject * obj0 = 0 ;
16435 PyObject * obj1 = 0 ;
16436 PyObject * obj2 = 0 ;
16437 PyObject * obj3 = 0 ;
16438 PyObject * obj4 = 0 ;
16439 PyObject * obj5 = 0 ;
16440 char * kwnames[] = {
16441 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16442 };
16443
16444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16446 if (!SWIG_IsOK(res1)) {
16447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16448 }
16449 arg1 = reinterpret_cast< wxImage * >(argp1);
16450 {
16451 arg2 = &temp2;
16452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16453 }
16454 {
16455 arg3 = &temp3;
16456 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16457 }
16458 if (obj3) {
16459 ecode4 = SWIG_AsVal_int(obj3, &val4);
16460 if (!SWIG_IsOK(ecode4)) {
16461 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16462 }
16463 arg4 = static_cast< int >(val4);
16464 }
16465 if (obj4) {
16466 ecode5 = SWIG_AsVal_int(obj4, &val5);
16467 if (!SWIG_IsOK(ecode5)) {
16468 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16469 }
16470 arg5 = static_cast< int >(val5);
16471 }
16472 if (obj5) {
16473 ecode6 = SWIG_AsVal_int(obj5, &val6);
16474 if (!SWIG_IsOK(ecode6)) {
16475 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16476 }
16477 arg6 = static_cast< int >(val6);
16478 }
16479 {
16480 PyThreadState* __tstate = wxPyBeginAllowThreads();
16481 {
16482 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16483 result = (wxImage *) &_result_ref;
16484 }
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16496 PyObject *resultobj = 0;
16497 wxImage *arg1 = (wxImage *) 0 ;
16498 int arg2 ;
16499 int arg3 ;
16500 byte arg4 ;
16501 byte arg5 ;
16502 byte arg6 ;
16503 void *argp1 = 0 ;
16504 int res1 = 0 ;
16505 int val2 ;
16506 int ecode2 = 0 ;
16507 int val3 ;
16508 int ecode3 = 0 ;
16509 unsigned char val4 ;
16510 int ecode4 = 0 ;
16511 unsigned char val5 ;
16512 int ecode5 = 0 ;
16513 unsigned char val6 ;
16514 int ecode6 = 0 ;
16515 PyObject * obj0 = 0 ;
16516 PyObject * obj1 = 0 ;
16517 PyObject * obj2 = 0 ;
16518 PyObject * obj3 = 0 ;
16519 PyObject * obj4 = 0 ;
16520 PyObject * obj5 = 0 ;
16521 char * kwnames[] = {
16522 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16523 };
16524
16525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16527 if (!SWIG_IsOK(res1)) {
16528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16529 }
16530 arg1 = reinterpret_cast< wxImage * >(argp1);
16531 ecode2 = SWIG_AsVal_int(obj1, &val2);
16532 if (!SWIG_IsOK(ecode2)) {
16533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16534 }
16535 arg2 = static_cast< int >(val2);
16536 ecode3 = SWIG_AsVal_int(obj2, &val3);
16537 if (!SWIG_IsOK(ecode3)) {
16538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16539 }
16540 arg3 = static_cast< int >(val3);
16541 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16542 if (!SWIG_IsOK(ecode4)) {
16543 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16544 }
16545 arg4 = static_cast< byte >(val4);
16546 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16547 if (!SWIG_IsOK(ecode5)) {
16548 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16549 }
16550 arg5 = static_cast< byte >(val5);
16551 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16552 if (!SWIG_IsOK(ecode6)) {
16553 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16554 }
16555 arg6 = static_cast< byte >(val6);
16556 {
16557 PyThreadState* __tstate = wxPyBeginAllowThreads();
16558 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16559 wxPyEndAllowThreads(__tstate);
16560 if (PyErr_Occurred()) SWIG_fail;
16561 }
16562 resultobj = SWIG_Py_Void();
16563 return resultobj;
16564 fail:
16565 return NULL;
16566 }
16567
16568
16569 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16570 PyObject *resultobj = 0;
16571 wxImage *arg1 = (wxImage *) 0 ;
16572 wxRect *arg2 = 0 ;
16573 byte arg3 ;
16574 byte arg4 ;
16575 byte arg5 ;
16576 void *argp1 = 0 ;
16577 int res1 = 0 ;
16578 wxRect temp2 ;
16579 unsigned char val3 ;
16580 int ecode3 = 0 ;
16581 unsigned char val4 ;
16582 int ecode4 = 0 ;
16583 unsigned char val5 ;
16584 int ecode5 = 0 ;
16585 PyObject * obj0 = 0 ;
16586 PyObject * obj1 = 0 ;
16587 PyObject * obj2 = 0 ;
16588 PyObject * obj3 = 0 ;
16589 PyObject * obj4 = 0 ;
16590 char * kwnames[] = {
16591 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16592 };
16593
16594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16596 if (!SWIG_IsOK(res1)) {
16597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16598 }
16599 arg1 = reinterpret_cast< wxImage * >(argp1);
16600 {
16601 arg2 = &temp2;
16602 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16603 }
16604 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16605 if (!SWIG_IsOK(ecode3)) {
16606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16607 }
16608 arg3 = static_cast< byte >(val3);
16609 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16610 if (!SWIG_IsOK(ecode4)) {
16611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16612 }
16613 arg4 = static_cast< byte >(val4);
16614 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16615 if (!SWIG_IsOK(ecode5)) {
16616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16617 }
16618 arg5 = static_cast< byte >(val5);
16619 {
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 resultobj = SWIG_Py_Void();
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj = 0;
16634 wxImage *arg1 = (wxImage *) 0 ;
16635 int arg2 ;
16636 int arg3 ;
16637 byte result;
16638 void *argp1 = 0 ;
16639 int res1 = 0 ;
16640 int val2 ;
16641 int ecode2 = 0 ;
16642 int val3 ;
16643 int ecode3 = 0 ;
16644 PyObject * obj0 = 0 ;
16645 PyObject * obj1 = 0 ;
16646 PyObject * obj2 = 0 ;
16647 char * kwnames[] = {
16648 (char *) "self",(char *) "x",(char *) "y", NULL
16649 };
16650
16651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16653 if (!SWIG_IsOK(res1)) {
16654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16655 }
16656 arg1 = reinterpret_cast< wxImage * >(argp1);
16657 ecode2 = SWIG_AsVal_int(obj1, &val2);
16658 if (!SWIG_IsOK(ecode2)) {
16659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16660 }
16661 arg2 = static_cast< int >(val2);
16662 ecode3 = SWIG_AsVal_int(obj2, &val3);
16663 if (!SWIG_IsOK(ecode3)) {
16664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16665 }
16666 arg3 = static_cast< int >(val3);
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 result = (byte)(arg1)->GetRed(arg2,arg3);
16670 wxPyEndAllowThreads(__tstate);
16671 if (PyErr_Occurred()) SWIG_fail;
16672 }
16673 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16681 PyObject *resultobj = 0;
16682 wxImage *arg1 = (wxImage *) 0 ;
16683 int arg2 ;
16684 int arg3 ;
16685 byte result;
16686 void *argp1 = 0 ;
16687 int res1 = 0 ;
16688 int val2 ;
16689 int ecode2 = 0 ;
16690 int val3 ;
16691 int ecode3 = 0 ;
16692 PyObject * obj0 = 0 ;
16693 PyObject * obj1 = 0 ;
16694 PyObject * obj2 = 0 ;
16695 char * kwnames[] = {
16696 (char *) "self",(char *) "x",(char *) "y", NULL
16697 };
16698
16699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16701 if (!SWIG_IsOK(res1)) {
16702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16703 }
16704 arg1 = reinterpret_cast< wxImage * >(argp1);
16705 ecode2 = SWIG_AsVal_int(obj1, &val2);
16706 if (!SWIG_IsOK(ecode2)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16708 }
16709 arg2 = static_cast< int >(val2);
16710 ecode3 = SWIG_AsVal_int(obj2, &val3);
16711 if (!SWIG_IsOK(ecode3)) {
16712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16713 }
16714 arg3 = static_cast< int >(val3);
16715 {
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 result = (byte)(arg1)->GetGreen(arg2,arg3);
16718 wxPyEndAllowThreads(__tstate);
16719 if (PyErr_Occurred()) SWIG_fail;
16720 }
16721 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16729 PyObject *resultobj = 0;
16730 wxImage *arg1 = (wxImage *) 0 ;
16731 int arg2 ;
16732 int arg3 ;
16733 byte result;
16734 void *argp1 = 0 ;
16735 int res1 = 0 ;
16736 int val2 ;
16737 int ecode2 = 0 ;
16738 int val3 ;
16739 int ecode3 = 0 ;
16740 PyObject * obj0 = 0 ;
16741 PyObject * obj1 = 0 ;
16742 PyObject * obj2 = 0 ;
16743 char * kwnames[] = {
16744 (char *) "self",(char *) "x",(char *) "y", NULL
16745 };
16746
16747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16749 if (!SWIG_IsOK(res1)) {
16750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16751 }
16752 arg1 = reinterpret_cast< wxImage * >(argp1);
16753 ecode2 = SWIG_AsVal_int(obj1, &val2);
16754 if (!SWIG_IsOK(ecode2)) {
16755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16756 }
16757 arg2 = static_cast< int >(val2);
16758 ecode3 = SWIG_AsVal_int(obj2, &val3);
16759 if (!SWIG_IsOK(ecode3)) {
16760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16761 }
16762 arg3 = static_cast< int >(val3);
16763 {
16764 PyThreadState* __tstate = wxPyBeginAllowThreads();
16765 result = (byte)(arg1)->GetBlue(arg2,arg3);
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj = 0;
16778 wxImage *arg1 = (wxImage *) 0 ;
16779 int arg2 ;
16780 int arg3 ;
16781 byte arg4 ;
16782 void *argp1 = 0 ;
16783 int res1 = 0 ;
16784 int val2 ;
16785 int ecode2 = 0 ;
16786 int val3 ;
16787 int ecode3 = 0 ;
16788 unsigned char val4 ;
16789 int ecode4 = 0 ;
16790 PyObject * obj0 = 0 ;
16791 PyObject * obj1 = 0 ;
16792 PyObject * obj2 = 0 ;
16793 PyObject * obj3 = 0 ;
16794 char * kwnames[] = {
16795 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16796 };
16797
16798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16800 if (!SWIG_IsOK(res1)) {
16801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16802 }
16803 arg1 = reinterpret_cast< wxImage * >(argp1);
16804 ecode2 = SWIG_AsVal_int(obj1, &val2);
16805 if (!SWIG_IsOK(ecode2)) {
16806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16807 }
16808 arg2 = static_cast< int >(val2);
16809 ecode3 = SWIG_AsVal_int(obj2, &val3);
16810 if (!SWIG_IsOK(ecode3)) {
16811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16812 }
16813 arg3 = static_cast< int >(val3);
16814 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16815 if (!SWIG_IsOK(ecode4)) {
16816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16817 }
16818 arg4 = static_cast< byte >(val4);
16819 {
16820 PyThreadState* __tstate = wxPyBeginAllowThreads();
16821 (arg1)->SetAlpha(arg2,arg3,arg4);
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 resultobj = SWIG_Py_Void();
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj = 0;
16834 wxImage *arg1 = (wxImage *) 0 ;
16835 int arg2 ;
16836 int arg3 ;
16837 byte result;
16838 void *argp1 = 0 ;
16839 int res1 = 0 ;
16840 int val2 ;
16841 int ecode2 = 0 ;
16842 int val3 ;
16843 int ecode3 = 0 ;
16844 PyObject * obj0 = 0 ;
16845 PyObject * obj1 = 0 ;
16846 PyObject * obj2 = 0 ;
16847 char * kwnames[] = {
16848 (char *) "self",(char *) "x",(char *) "y", NULL
16849 };
16850
16851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16853 if (!SWIG_IsOK(res1)) {
16854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16855 }
16856 arg1 = reinterpret_cast< wxImage * >(argp1);
16857 ecode2 = SWIG_AsVal_int(obj1, &val2);
16858 if (!SWIG_IsOK(ecode2)) {
16859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16860 }
16861 arg2 = static_cast< int >(val2);
16862 ecode3 = SWIG_AsVal_int(obj2, &val3);
16863 if (!SWIG_IsOK(ecode3)) {
16864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16865 }
16866 arg3 = static_cast< int >(val3);
16867 {
16868 PyThreadState* __tstate = wxPyBeginAllowThreads();
16869 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16881 PyObject *resultobj = 0;
16882 wxImage *arg1 = (wxImage *) 0 ;
16883 bool result;
16884 void *argp1 = 0 ;
16885 int res1 = 0 ;
16886 PyObject *swig_obj[1] ;
16887
16888 if (!args) SWIG_fail;
16889 swig_obj[0] = args;
16890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16893 }
16894 arg1 = reinterpret_cast< wxImage * >(argp1);
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 result = (bool)(arg1)->HasAlpha();
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 {
16902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16903 }
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16911 PyObject *resultobj = 0;
16912 wxImage *arg1 = (wxImage *) 0 ;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 PyObject *swig_obj[1] ;
16916
16917 if (!args) SWIG_fail;
16918 swig_obj[0] = args;
16919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16920 if (!SWIG_IsOK(res1)) {
16921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16922 }
16923 arg1 = reinterpret_cast< wxImage * >(argp1);
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 (arg1)->InitAlpha();
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 resultobj = SWIG_Py_Void();
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16938 PyObject *resultobj = 0;
16939 wxImage *arg1 = (wxImage *) 0 ;
16940 int arg2 ;
16941 int arg3 ;
16942 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16943 bool result;
16944 void *argp1 = 0 ;
16945 int res1 = 0 ;
16946 int val2 ;
16947 int ecode2 = 0 ;
16948 int val3 ;
16949 int ecode3 = 0 ;
16950 unsigned char val4 ;
16951 int ecode4 = 0 ;
16952 PyObject * obj0 = 0 ;
16953 PyObject * obj1 = 0 ;
16954 PyObject * obj2 = 0 ;
16955 PyObject * obj3 = 0 ;
16956 char * kwnames[] = {
16957 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16958 };
16959
16960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16962 if (!SWIG_IsOK(res1)) {
16963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16964 }
16965 arg1 = reinterpret_cast< wxImage * >(argp1);
16966 ecode2 = SWIG_AsVal_int(obj1, &val2);
16967 if (!SWIG_IsOK(ecode2)) {
16968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16969 }
16970 arg2 = static_cast< int >(val2);
16971 ecode3 = SWIG_AsVal_int(obj2, &val3);
16972 if (!SWIG_IsOK(ecode3)) {
16973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16974 }
16975 arg3 = static_cast< int >(val3);
16976 if (obj3) {
16977 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16978 if (!SWIG_IsOK(ecode4)) {
16979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16980 }
16981 arg4 = static_cast< byte >(val4);
16982 }
16983 {
16984 PyThreadState* __tstate = wxPyBeginAllowThreads();
16985 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16986 wxPyEndAllowThreads(__tstate);
16987 if (PyErr_Occurred()) SWIG_fail;
16988 }
16989 {
16990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16991 }
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16999 PyObject *resultobj = 0;
17000 wxImage *arg1 = (wxImage *) 0 ;
17001 byte *arg2 = (byte *) 0 ;
17002 byte *arg3 = (byte *) 0 ;
17003 byte *arg4 = (byte *) 0 ;
17004 byte arg5 = (byte) 0 ;
17005 byte arg6 = (byte) 0 ;
17006 byte arg7 = (byte) 0 ;
17007 bool result;
17008 void *argp1 = 0 ;
17009 int res1 = 0 ;
17010 byte temp2 ;
17011 int res2 = SWIG_TMPOBJ ;
17012 byte temp3 ;
17013 int res3 = SWIG_TMPOBJ ;
17014 byte temp4 ;
17015 int res4 = SWIG_TMPOBJ ;
17016 unsigned char val5 ;
17017 int ecode5 = 0 ;
17018 unsigned char val6 ;
17019 int ecode6 = 0 ;
17020 unsigned char val7 ;
17021 int ecode7 = 0 ;
17022 PyObject * obj0 = 0 ;
17023 PyObject * obj1 = 0 ;
17024 PyObject * obj2 = 0 ;
17025 PyObject * obj3 = 0 ;
17026 char * kwnames[] = {
17027 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17028 };
17029
17030 arg2 = &temp2;
17031 arg3 = &temp3;
17032 arg4 = &temp4;
17033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17035 if (!SWIG_IsOK(res1)) {
17036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17037 }
17038 arg1 = reinterpret_cast< wxImage * >(argp1);
17039 if (obj1) {
17040 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17041 if (!SWIG_IsOK(ecode5)) {
17042 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17043 }
17044 arg5 = static_cast< byte >(val5);
17045 }
17046 if (obj2) {
17047 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17048 if (!SWIG_IsOK(ecode6)) {
17049 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17050 }
17051 arg6 = static_cast< byte >(val6);
17052 }
17053 if (obj3) {
17054 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17055 if (!SWIG_IsOK(ecode7)) {
17056 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17057 }
17058 arg7 = static_cast< byte >(val7);
17059 }
17060 {
17061 PyThreadState* __tstate = wxPyBeginAllowThreads();
17062 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17063 wxPyEndAllowThreads(__tstate);
17064 if (PyErr_Occurred()) SWIG_fail;
17065 }
17066 {
17067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17068 }
17069 if (SWIG_IsTmpObj(res2)) {
17070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17071 } else {
17072 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17074 }
17075 if (SWIG_IsTmpObj(res3)) {
17076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17077 } else {
17078 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17080 }
17081 if (SWIG_IsTmpObj(res4)) {
17082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17083 } else {
17084 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17086 }
17087 return resultobj;
17088 fail:
17089 return NULL;
17090 }
17091
17092
17093 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17094 PyObject *resultobj = 0;
17095 wxImage *arg1 = (wxImage *) 0 ;
17096 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17097 bool result;
17098 void *argp1 = 0 ;
17099 int res1 = 0 ;
17100 unsigned char val2 ;
17101 int ecode2 = 0 ;
17102 PyObject * obj0 = 0 ;
17103 PyObject * obj1 = 0 ;
17104 char * kwnames[] = {
17105 (char *) "self",(char *) "threshold", NULL
17106 };
17107
17108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17110 if (!SWIG_IsOK(res1)) {
17111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17112 }
17113 arg1 = reinterpret_cast< wxImage * >(argp1);
17114 if (obj1) {
17115 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17116 if (!SWIG_IsOK(ecode2)) {
17117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17118 }
17119 arg2 = static_cast< byte >(val2);
17120 }
17121 {
17122 PyThreadState* __tstate = wxPyBeginAllowThreads();
17123 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17129 }
17130 return resultobj;
17131 fail:
17132 return NULL;
17133 }
17134
17135
17136 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17137 PyObject *resultobj = 0;
17138 wxImage *arg1 = (wxImage *) 0 ;
17139 byte arg2 ;
17140 byte arg3 ;
17141 byte arg4 ;
17142 bool result;
17143 void *argp1 = 0 ;
17144 int res1 = 0 ;
17145 unsigned char val2 ;
17146 int ecode2 = 0 ;
17147 unsigned char val3 ;
17148 int ecode3 = 0 ;
17149 unsigned char val4 ;
17150 int ecode4 = 0 ;
17151 PyObject * obj0 = 0 ;
17152 PyObject * obj1 = 0 ;
17153 PyObject * obj2 = 0 ;
17154 PyObject * obj3 = 0 ;
17155 char * kwnames[] = {
17156 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17157 };
17158
17159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17161 if (!SWIG_IsOK(res1)) {
17162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17163 }
17164 arg1 = reinterpret_cast< wxImage * >(argp1);
17165 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17166 if (!SWIG_IsOK(ecode2)) {
17167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17168 }
17169 arg2 = static_cast< byte >(val2);
17170 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17171 if (!SWIG_IsOK(ecode3)) {
17172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17173 }
17174 arg3 = static_cast< byte >(val3);
17175 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17176 if (!SWIG_IsOK(ecode4)) {
17177 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17178 }
17179 arg4 = static_cast< byte >(val4);
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 {
17187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17188 }
17189 return resultobj;
17190 fail:
17191 return NULL;
17192 }
17193
17194
17195 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17196 PyObject *resultobj = 0;
17197 wxImage *arg1 = (wxImage *) 0 ;
17198 wxImage *arg2 = 0 ;
17199 byte arg3 ;
17200 byte arg4 ;
17201 byte arg5 ;
17202 bool result;
17203 void *argp1 = 0 ;
17204 int res1 = 0 ;
17205 void *argp2 = 0 ;
17206 int res2 = 0 ;
17207 unsigned char val3 ;
17208 int ecode3 = 0 ;
17209 unsigned char val4 ;
17210 int ecode4 = 0 ;
17211 unsigned char val5 ;
17212 int ecode5 = 0 ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 PyObject * obj2 = 0 ;
17216 PyObject * obj3 = 0 ;
17217 PyObject * obj4 = 0 ;
17218 char * kwnames[] = {
17219 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17220 };
17221
17222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17224 if (!SWIG_IsOK(res1)) {
17225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17226 }
17227 arg1 = reinterpret_cast< wxImage * >(argp1);
17228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17229 if (!SWIG_IsOK(res2)) {
17230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17231 }
17232 if (!argp2) {
17233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17234 }
17235 arg2 = reinterpret_cast< wxImage * >(argp2);
17236 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17237 if (!SWIG_IsOK(ecode3)) {
17238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17239 }
17240 arg3 = static_cast< byte >(val3);
17241 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17242 if (!SWIG_IsOK(ecode4)) {
17243 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17244 }
17245 arg4 = static_cast< byte >(val4);
17246 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17247 if (!SWIG_IsOK(ecode5)) {
17248 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17249 }
17250 arg5 = static_cast< byte >(val5);
17251 {
17252 PyThreadState* __tstate = wxPyBeginAllowThreads();
17253 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj = 0;
17268 wxString *arg1 = 0 ;
17269 bool result;
17270 bool temp1 = false ;
17271 PyObject * obj0 = 0 ;
17272 char * kwnames[] = {
17273 (char *) "filename", NULL
17274 };
17275
17276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17277 {
17278 arg1 = wxString_in_helper(obj0);
17279 if (arg1 == NULL) SWIG_fail;
17280 temp1 = true;
17281 }
17282 {
17283 PyThreadState* __tstate = wxPyBeginAllowThreads();
17284 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 {
17289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17290 }
17291 {
17292 if (temp1)
17293 delete arg1;
17294 }
17295 return resultobj;
17296 fail:
17297 {
17298 if (temp1)
17299 delete arg1;
17300 }
17301 return NULL;
17302 }
17303
17304
17305 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17306 PyObject *resultobj = 0;
17307 wxString *arg1 = 0 ;
17308 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17309 int result;
17310 bool temp1 = false ;
17311 long val2 ;
17312 int ecode2 = 0 ;
17313 PyObject * obj0 = 0 ;
17314 PyObject * obj1 = 0 ;
17315 char * kwnames[] = {
17316 (char *) "filename",(char *) "type", NULL
17317 };
17318
17319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17320 {
17321 arg1 = wxString_in_helper(obj0);
17322 if (arg1 == NULL) SWIG_fail;
17323 temp1 = true;
17324 }
17325 if (obj1) {
17326 ecode2 = SWIG_AsVal_long(obj1, &val2);
17327 if (!SWIG_IsOK(ecode2)) {
17328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17329 }
17330 arg2 = static_cast< long >(val2);
17331 }
17332 {
17333 PyThreadState* __tstate = wxPyBeginAllowThreads();
17334 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17335 wxPyEndAllowThreads(__tstate);
17336 if (PyErr_Occurred()) SWIG_fail;
17337 }
17338 resultobj = SWIG_From_int(static_cast< int >(result));
17339 {
17340 if (temp1)
17341 delete arg1;
17342 }
17343 return resultobj;
17344 fail:
17345 {
17346 if (temp1)
17347 delete arg1;
17348 }
17349 return NULL;
17350 }
17351
17352
17353 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17354 PyObject *resultobj = 0;
17355 wxImage *arg1 = (wxImage *) 0 ;
17356 wxString *arg2 = 0 ;
17357 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17358 int arg4 = (int) -1 ;
17359 bool result;
17360 void *argp1 = 0 ;
17361 int res1 = 0 ;
17362 bool temp2 = false ;
17363 long val3 ;
17364 int ecode3 = 0 ;
17365 int val4 ;
17366 int ecode4 = 0 ;
17367 PyObject * obj0 = 0 ;
17368 PyObject * obj1 = 0 ;
17369 PyObject * obj2 = 0 ;
17370 PyObject * obj3 = 0 ;
17371 char * kwnames[] = {
17372 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17373 };
17374
17375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17377 if (!SWIG_IsOK(res1)) {
17378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17379 }
17380 arg1 = reinterpret_cast< wxImage * >(argp1);
17381 {
17382 arg2 = wxString_in_helper(obj1);
17383 if (arg2 == NULL) SWIG_fail;
17384 temp2 = true;
17385 }
17386 if (obj2) {
17387 ecode3 = SWIG_AsVal_long(obj2, &val3);
17388 if (!SWIG_IsOK(ecode3)) {
17389 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17390 }
17391 arg3 = static_cast< long >(val3);
17392 }
17393 if (obj3) {
17394 ecode4 = SWIG_AsVal_int(obj3, &val4);
17395 if (!SWIG_IsOK(ecode4)) {
17396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17397 }
17398 arg4 = static_cast< int >(val4);
17399 }
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17403 wxPyEndAllowThreads(__tstate);
17404 if (PyErr_Occurred()) SWIG_fail;
17405 }
17406 {
17407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17408 }
17409 {
17410 if (temp2)
17411 delete arg2;
17412 }
17413 return resultobj;
17414 fail:
17415 {
17416 if (temp2)
17417 delete arg2;
17418 }
17419 return NULL;
17420 }
17421
17422
17423 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17424 PyObject *resultobj = 0;
17425 wxImage *arg1 = (wxImage *) 0 ;
17426 wxString *arg2 = 0 ;
17427 wxString *arg3 = 0 ;
17428 int arg4 = (int) -1 ;
17429 bool result;
17430 void *argp1 = 0 ;
17431 int res1 = 0 ;
17432 bool temp2 = false ;
17433 bool temp3 = false ;
17434 int val4 ;
17435 int ecode4 = 0 ;
17436 PyObject * obj0 = 0 ;
17437 PyObject * obj1 = 0 ;
17438 PyObject * obj2 = 0 ;
17439 PyObject * obj3 = 0 ;
17440 char * kwnames[] = {
17441 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17442 };
17443
17444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17446 if (!SWIG_IsOK(res1)) {
17447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17448 }
17449 arg1 = reinterpret_cast< wxImage * >(argp1);
17450 {
17451 arg2 = wxString_in_helper(obj1);
17452 if (arg2 == NULL) SWIG_fail;
17453 temp2 = true;
17454 }
17455 {
17456 arg3 = wxString_in_helper(obj2);
17457 if (arg3 == NULL) SWIG_fail;
17458 temp3 = true;
17459 }
17460 if (obj3) {
17461 ecode4 = SWIG_AsVal_int(obj3, &val4);
17462 if (!SWIG_IsOK(ecode4)) {
17463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17464 }
17465 arg4 = static_cast< int >(val4);
17466 }
17467 {
17468 PyThreadState* __tstate = wxPyBeginAllowThreads();
17469 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17470 wxPyEndAllowThreads(__tstate);
17471 if (PyErr_Occurred()) SWIG_fail;
17472 }
17473 {
17474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17475 }
17476 {
17477 if (temp2)
17478 delete arg2;
17479 }
17480 {
17481 if (temp3)
17482 delete arg3;
17483 }
17484 return resultobj;
17485 fail:
17486 {
17487 if (temp2)
17488 delete arg2;
17489 }
17490 {
17491 if (temp3)
17492 delete arg3;
17493 }
17494 return NULL;
17495 }
17496
17497
17498 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = 0;
17500 wxImage *arg1 = (wxImage *) 0 ;
17501 wxString *arg2 = 0 ;
17502 int arg3 ;
17503 bool result;
17504 void *argp1 = 0 ;
17505 int res1 = 0 ;
17506 bool temp2 = false ;
17507 int val3 ;
17508 int ecode3 = 0 ;
17509 PyObject * obj0 = 0 ;
17510 PyObject * obj1 = 0 ;
17511 PyObject * obj2 = 0 ;
17512 char * kwnames[] = {
17513 (char *) "self",(char *) "name",(char *) "type", NULL
17514 };
17515
17516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17518 if (!SWIG_IsOK(res1)) {
17519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17520 }
17521 arg1 = reinterpret_cast< wxImage * >(argp1);
17522 {
17523 arg2 = wxString_in_helper(obj1);
17524 if (arg2 == NULL) SWIG_fail;
17525 temp2 = true;
17526 }
17527 ecode3 = SWIG_AsVal_int(obj2, &val3);
17528 if (!SWIG_IsOK(ecode3)) {
17529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17530 }
17531 arg3 = static_cast< int >(val3);
17532 {
17533 PyThreadState* __tstate = wxPyBeginAllowThreads();
17534 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 {
17539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17540 }
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 return resultobj;
17546 fail:
17547 {
17548 if (temp2)
17549 delete arg2;
17550 }
17551 return NULL;
17552 }
17553
17554
17555 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj = 0;
17557 wxImage *arg1 = (wxImage *) 0 ;
17558 wxString *arg2 = 0 ;
17559 wxString *arg3 = 0 ;
17560 bool result;
17561 void *argp1 = 0 ;
17562 int res1 = 0 ;
17563 bool temp2 = false ;
17564 bool temp3 = false ;
17565 PyObject * obj0 = 0 ;
17566 PyObject * obj1 = 0 ;
17567 PyObject * obj2 = 0 ;
17568 char * kwnames[] = {
17569 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17570 };
17571
17572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17574 if (!SWIG_IsOK(res1)) {
17575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17576 }
17577 arg1 = reinterpret_cast< wxImage * >(argp1);
17578 {
17579 arg2 = wxString_in_helper(obj1);
17580 if (arg2 == NULL) SWIG_fail;
17581 temp2 = true;
17582 }
17583 {
17584 arg3 = wxString_in_helper(obj2);
17585 if (arg3 == NULL) SWIG_fail;
17586 temp3 = true;
17587 }
17588 {
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17591 wxPyEndAllowThreads(__tstate);
17592 if (PyErr_Occurred()) SWIG_fail;
17593 }
17594 {
17595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17596 }
17597 {
17598 if (temp2)
17599 delete arg2;
17600 }
17601 {
17602 if (temp3)
17603 delete arg3;
17604 }
17605 return resultobj;
17606 fail:
17607 {
17608 if (temp2)
17609 delete arg2;
17610 }
17611 {
17612 if (temp3)
17613 delete arg3;
17614 }
17615 return NULL;
17616 }
17617
17618
17619 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17620 PyObject *resultobj = 0;
17621 wxInputStream *arg1 = 0 ;
17622 bool result;
17623 wxPyInputStream *temp1 ;
17624 bool created1 ;
17625 PyObject * obj0 = 0 ;
17626 char * kwnames[] = {
17627 (char *) "stream", NULL
17628 };
17629
17630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17631 {
17632 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17633 arg1 = temp1->m_wxis;
17634 created1 = false;
17635 } else {
17636 PyErr_Clear(); // clear the failure of the wxPyConvert above
17637 arg1 = wxPyCBInputStream_create(obj0, false);
17638 if (arg1 == NULL) {
17639 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17640 SWIG_fail;
17641 }
17642 created1 = true;
17643 }
17644 }
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (bool)wxImage::CanRead(*arg1);
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 {
17652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17653 }
17654 {
17655 if (created1) delete arg1;
17656 }
17657 return resultobj;
17658 fail:
17659 {
17660 if (created1) delete arg1;
17661 }
17662 return NULL;
17663 }
17664
17665
17666 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17667 PyObject *resultobj = 0;
17668 wxImage *arg1 = (wxImage *) 0 ;
17669 wxInputStream *arg2 = 0 ;
17670 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17671 int arg4 = (int) -1 ;
17672 bool result;
17673 void *argp1 = 0 ;
17674 int res1 = 0 ;
17675 wxPyInputStream *temp2 ;
17676 bool created2 ;
17677 long val3 ;
17678 int ecode3 = 0 ;
17679 int val4 ;
17680 int ecode4 = 0 ;
17681 PyObject * obj0 = 0 ;
17682 PyObject * obj1 = 0 ;
17683 PyObject * obj2 = 0 ;
17684 PyObject * obj3 = 0 ;
17685 char * kwnames[] = {
17686 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17687 };
17688
17689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17691 if (!SWIG_IsOK(res1)) {
17692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17693 }
17694 arg1 = reinterpret_cast< wxImage * >(argp1);
17695 {
17696 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17697 arg2 = temp2->m_wxis;
17698 created2 = false;
17699 } else {
17700 PyErr_Clear(); // clear the failure of the wxPyConvert above
17701 arg2 = wxPyCBInputStream_create(obj1, false);
17702 if (arg2 == NULL) {
17703 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17704 SWIG_fail;
17705 }
17706 created2 = true;
17707 }
17708 }
17709 if (obj2) {
17710 ecode3 = SWIG_AsVal_long(obj2, &val3);
17711 if (!SWIG_IsOK(ecode3)) {
17712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17713 }
17714 arg3 = static_cast< long >(val3);
17715 }
17716 if (obj3) {
17717 ecode4 = SWIG_AsVal_int(obj3, &val4);
17718 if (!SWIG_IsOK(ecode4)) {
17719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17720 }
17721 arg4 = static_cast< int >(val4);
17722 }
17723 {
17724 PyThreadState* __tstate = wxPyBeginAllowThreads();
17725 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17726 wxPyEndAllowThreads(__tstate);
17727 if (PyErr_Occurred()) SWIG_fail;
17728 }
17729 {
17730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17731 }
17732 {
17733 if (created2) delete arg2;
17734 }
17735 return resultobj;
17736 fail:
17737 {
17738 if (created2) delete arg2;
17739 }
17740 return NULL;
17741 }
17742
17743
17744 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj = 0;
17746 wxImage *arg1 = (wxImage *) 0 ;
17747 wxInputStream *arg2 = 0 ;
17748 wxString *arg3 = 0 ;
17749 int arg4 = (int) -1 ;
17750 bool result;
17751 void *argp1 = 0 ;
17752 int res1 = 0 ;
17753 wxPyInputStream *temp2 ;
17754 bool created2 ;
17755 bool temp3 = false ;
17756 int val4 ;
17757 int ecode4 = 0 ;
17758 PyObject * obj0 = 0 ;
17759 PyObject * obj1 = 0 ;
17760 PyObject * obj2 = 0 ;
17761 PyObject * obj3 = 0 ;
17762 char * kwnames[] = {
17763 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17764 };
17765
17766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17768 if (!SWIG_IsOK(res1)) {
17769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17770 }
17771 arg1 = reinterpret_cast< wxImage * >(argp1);
17772 {
17773 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17774 arg2 = temp2->m_wxis;
17775 created2 = false;
17776 } else {
17777 PyErr_Clear(); // clear the failure of the wxPyConvert above
17778 arg2 = wxPyCBInputStream_create(obj1, false);
17779 if (arg2 == NULL) {
17780 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17781 SWIG_fail;
17782 }
17783 created2 = true;
17784 }
17785 }
17786 {
17787 arg3 = wxString_in_helper(obj2);
17788 if (arg3 == NULL) SWIG_fail;
17789 temp3 = true;
17790 }
17791 if (obj3) {
17792 ecode4 = SWIG_AsVal_int(obj3, &val4);
17793 if (!SWIG_IsOK(ecode4)) {
17794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17795 }
17796 arg4 = static_cast< int >(val4);
17797 }
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17806 }
17807 {
17808 if (created2) delete arg2;
17809 }
17810 {
17811 if (temp3)
17812 delete arg3;
17813 }
17814 return resultobj;
17815 fail:
17816 {
17817 if (created2) delete arg2;
17818 }
17819 {
17820 if (temp3)
17821 delete arg3;
17822 }
17823 return NULL;
17824 }
17825
17826
17827 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17828 PyObject *resultobj = 0;
17829 wxImage *arg1 = (wxImage *) 0 ;
17830 bool result;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 PyObject *swig_obj[1] ;
17834
17835 if (!args) SWIG_fail;
17836 swig_obj[0] = args;
17837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17838 if (!SWIG_IsOK(res1)) {
17839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17840 }
17841 arg1 = reinterpret_cast< wxImage * >(argp1);
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (bool)(arg1)->IsOk();
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17858 PyObject *resultobj = 0;
17859 wxImage *arg1 = (wxImage *) 0 ;
17860 int result;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 PyObject *swig_obj[1] ;
17864
17865 if (!args) SWIG_fail;
17866 swig_obj[0] = args;
17867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17868 if (!SWIG_IsOK(res1)) {
17869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17870 }
17871 arg1 = reinterpret_cast< wxImage * >(argp1);
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (int)(arg1)->GetWidth();
17875 wxPyEndAllowThreads(__tstate);
17876 if (PyErr_Occurred()) SWIG_fail;
17877 }
17878 resultobj = SWIG_From_int(static_cast< int >(result));
17879 return resultobj;
17880 fail:
17881 return NULL;
17882 }
17883
17884
17885 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17886 PyObject *resultobj = 0;
17887 wxImage *arg1 = (wxImage *) 0 ;
17888 int result;
17889 void *argp1 = 0 ;
17890 int res1 = 0 ;
17891 PyObject *swig_obj[1] ;
17892
17893 if (!args) SWIG_fail;
17894 swig_obj[0] = args;
17895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17896 if (!SWIG_IsOK(res1)) {
17897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17898 }
17899 arg1 = reinterpret_cast< wxImage * >(argp1);
17900 {
17901 PyThreadState* __tstate = wxPyBeginAllowThreads();
17902 result = (int)(arg1)->GetHeight();
17903 wxPyEndAllowThreads(__tstate);
17904 if (PyErr_Occurred()) SWIG_fail;
17905 }
17906 resultobj = SWIG_From_int(static_cast< int >(result));
17907 return resultobj;
17908 fail:
17909 return NULL;
17910 }
17911
17912
17913 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17914 PyObject *resultobj = 0;
17915 wxImage *arg1 = (wxImage *) 0 ;
17916 wxSize result;
17917 void *argp1 = 0 ;
17918 int res1 = 0 ;
17919 PyObject *swig_obj[1] ;
17920
17921 if (!args) SWIG_fail;
17922 swig_obj[0] = args;
17923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17924 if (!SWIG_IsOK(res1)) {
17925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17926 }
17927 arg1 = reinterpret_cast< wxImage * >(argp1);
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 result = wxImage_GetSize(arg1);
17931 wxPyEndAllowThreads(__tstate);
17932 if (PyErr_Occurred()) SWIG_fail;
17933 }
17934 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj = 0;
17943 wxImage *arg1 = (wxImage *) 0 ;
17944 wxRect *arg2 = 0 ;
17945 SwigValueWrapper<wxImage > result;
17946 void *argp1 = 0 ;
17947 int res1 = 0 ;
17948 wxRect temp2 ;
17949 PyObject * obj0 = 0 ;
17950 PyObject * obj1 = 0 ;
17951 char * kwnames[] = {
17952 (char *) "self",(char *) "rect", NULL
17953 };
17954
17955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17959 }
17960 arg1 = reinterpret_cast< wxImage * >(argp1);
17961 {
17962 arg2 = &temp2;
17963 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17964 }
17965 {
17966 PyThreadState* __tstate = wxPyBeginAllowThreads();
17967 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17979 PyObject *resultobj = 0;
17980 wxImage *arg1 = (wxImage *) 0 ;
17981 wxSize *arg2 = 0 ;
17982 wxPoint *arg3 = 0 ;
17983 int arg4 = (int) -1 ;
17984 int arg5 = (int) -1 ;
17985 int arg6 = (int) -1 ;
17986 SwigValueWrapper<wxImage > result;
17987 void *argp1 = 0 ;
17988 int res1 = 0 ;
17989 wxSize temp2 ;
17990 wxPoint temp3 ;
17991 int val4 ;
17992 int ecode4 = 0 ;
17993 int val5 ;
17994 int ecode5 = 0 ;
17995 int val6 ;
17996 int ecode6 = 0 ;
17997 PyObject * obj0 = 0 ;
17998 PyObject * obj1 = 0 ;
17999 PyObject * obj2 = 0 ;
18000 PyObject * obj3 = 0 ;
18001 PyObject * obj4 = 0 ;
18002 PyObject * obj5 = 0 ;
18003 char * kwnames[] = {
18004 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18005 };
18006
18007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18009 if (!SWIG_IsOK(res1)) {
18010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18011 }
18012 arg1 = reinterpret_cast< wxImage * >(argp1);
18013 {
18014 arg2 = &temp2;
18015 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18016 }
18017 {
18018 arg3 = &temp3;
18019 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18020 }
18021 if (obj3) {
18022 ecode4 = SWIG_AsVal_int(obj3, &val4);
18023 if (!SWIG_IsOK(ecode4)) {
18024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18025 }
18026 arg4 = static_cast< int >(val4);
18027 }
18028 if (obj4) {
18029 ecode5 = SWIG_AsVal_int(obj4, &val5);
18030 if (!SWIG_IsOK(ecode5)) {
18031 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18032 }
18033 arg5 = static_cast< int >(val5);
18034 }
18035 if (obj5) {
18036 ecode6 = SWIG_AsVal_int(obj5, &val6);
18037 if (!SWIG_IsOK(ecode6)) {
18038 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18039 }
18040 arg6 = static_cast< int >(val6);
18041 }
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18045 wxPyEndAllowThreads(__tstate);
18046 if (PyErr_Occurred()) SWIG_fail;
18047 }
18048 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18049 return resultobj;
18050 fail:
18051 return NULL;
18052 }
18053
18054
18055 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18056 PyObject *resultobj = 0;
18057 wxImage *arg1 = (wxImage *) 0 ;
18058 SwigValueWrapper<wxImage > result;
18059 void *argp1 = 0 ;
18060 int res1 = 0 ;
18061 PyObject *swig_obj[1] ;
18062
18063 if (!args) SWIG_fail;
18064 swig_obj[0] = args;
18065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18066 if (!SWIG_IsOK(res1)) {
18067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18068 }
18069 arg1 = reinterpret_cast< wxImage * >(argp1);
18070 {
18071 PyThreadState* __tstate = wxPyBeginAllowThreads();
18072 result = (arg1)->Copy();
18073 wxPyEndAllowThreads(__tstate);
18074 if (PyErr_Occurred()) SWIG_fail;
18075 }
18076 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18077 return resultobj;
18078 fail:
18079 return NULL;
18080 }
18081
18082
18083 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18084 PyObject *resultobj = 0;
18085 wxImage *arg1 = (wxImage *) 0 ;
18086 wxImage *arg2 = 0 ;
18087 int arg3 ;
18088 int arg4 ;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 void *argp2 = 0 ;
18092 int res2 = 0 ;
18093 int val3 ;
18094 int ecode3 = 0 ;
18095 int val4 ;
18096 int ecode4 = 0 ;
18097 PyObject * obj0 = 0 ;
18098 PyObject * obj1 = 0 ;
18099 PyObject * obj2 = 0 ;
18100 PyObject * obj3 = 0 ;
18101 char * kwnames[] = {
18102 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18103 };
18104
18105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18107 if (!SWIG_IsOK(res1)) {
18108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18109 }
18110 arg1 = reinterpret_cast< wxImage * >(argp1);
18111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18112 if (!SWIG_IsOK(res2)) {
18113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18114 }
18115 if (!argp2) {
18116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18117 }
18118 arg2 = reinterpret_cast< wxImage * >(argp2);
18119 ecode3 = SWIG_AsVal_int(obj2, &val3);
18120 if (!SWIG_IsOK(ecode3)) {
18121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18122 }
18123 arg3 = static_cast< int >(val3);
18124 ecode4 = SWIG_AsVal_int(obj3, &val4);
18125 if (!SWIG_IsOK(ecode4)) {
18126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18127 }
18128 arg4 = static_cast< int >(val4);
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 resultobj = SWIG_Py_Void();
18136 return resultobj;
18137 fail:
18138 return NULL;
18139 }
18140
18141
18142 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18143 PyObject *resultobj = 0;
18144 wxImage *arg1 = (wxImage *) 0 ;
18145 PyObject *result = 0 ;
18146 void *argp1 = 0 ;
18147 int res1 = 0 ;
18148 PyObject *swig_obj[1] ;
18149
18150 if (!args) SWIG_fail;
18151 swig_obj[0] = args;
18152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18153 if (!SWIG_IsOK(res1)) {
18154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18155 }
18156 arg1 = reinterpret_cast< wxImage * >(argp1);
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 result = (PyObject *)wxImage_GetData(arg1);
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = result;
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18171 PyObject *resultobj = 0;
18172 wxImage *arg1 = (wxImage *) 0 ;
18173 buffer arg2 ;
18174 int arg3 ;
18175 void *argp1 = 0 ;
18176 int res1 = 0 ;
18177 Py_ssize_t temp2 ;
18178 PyObject * obj0 = 0 ;
18179 PyObject * obj1 = 0 ;
18180 char * kwnames[] = {
18181 (char *) "self",(char *) "data", NULL
18182 };
18183
18184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18186 if (!SWIG_IsOK(res1)) {
18187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18188 }
18189 arg1 = reinterpret_cast< wxImage * >(argp1);
18190 {
18191 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18192 arg3 = (int)temp2;
18193 }
18194 {
18195 PyThreadState* __tstate = wxPyBeginAllowThreads();
18196 wxImage_SetData(arg1,arg2,arg3);
18197 wxPyEndAllowThreads(__tstate);
18198 if (PyErr_Occurred()) SWIG_fail;
18199 }
18200 resultobj = SWIG_Py_Void();
18201 return resultobj;
18202 fail:
18203 return NULL;
18204 }
18205
18206
18207 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18208 PyObject *resultobj = 0;
18209 wxImage *arg1 = (wxImage *) 0 ;
18210 PyObject *result = 0 ;
18211 void *argp1 = 0 ;
18212 int res1 = 0 ;
18213 PyObject *swig_obj[1] ;
18214
18215 if (!args) SWIG_fail;
18216 swig_obj[0] = args;
18217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18218 if (!SWIG_IsOK(res1)) {
18219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18220 }
18221 arg1 = reinterpret_cast< wxImage * >(argp1);
18222 {
18223 PyThreadState* __tstate = wxPyBeginAllowThreads();
18224 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18225 wxPyEndAllowThreads(__tstate);
18226 if (PyErr_Occurred()) SWIG_fail;
18227 }
18228 resultobj = result;
18229 return resultobj;
18230 fail:
18231 return NULL;
18232 }
18233
18234
18235 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18236 PyObject *resultobj = 0;
18237 wxImage *arg1 = (wxImage *) 0 ;
18238 buffer arg2 ;
18239 int arg3 ;
18240 void *argp1 = 0 ;
18241 int res1 = 0 ;
18242 Py_ssize_t temp2 ;
18243 PyObject * obj0 = 0 ;
18244 PyObject * obj1 = 0 ;
18245 char * kwnames[] = {
18246 (char *) "self",(char *) "data", NULL
18247 };
18248
18249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18251 if (!SWIG_IsOK(res1)) {
18252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18253 }
18254 arg1 = reinterpret_cast< wxImage * >(argp1);
18255 {
18256 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18257 arg3 = (int)temp2;
18258 }
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 wxImage_SetDataBuffer(arg1,arg2,arg3);
18262 wxPyEndAllowThreads(__tstate);
18263 if (PyErr_Occurred()) SWIG_fail;
18264 }
18265 resultobj = SWIG_Py_Void();
18266 return resultobj;
18267 fail:
18268 return NULL;
18269 }
18270
18271
18272 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18273 PyObject *resultobj = 0;
18274 wxImage *arg1 = (wxImage *) 0 ;
18275 PyObject *result = 0 ;
18276 void *argp1 = 0 ;
18277 int res1 = 0 ;
18278 PyObject *swig_obj[1] ;
18279
18280 if (!args) SWIG_fail;
18281 swig_obj[0] = args;
18282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18283 if (!SWIG_IsOK(res1)) {
18284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18285 }
18286 arg1 = reinterpret_cast< wxImage * >(argp1);
18287 {
18288 PyThreadState* __tstate = wxPyBeginAllowThreads();
18289 result = (PyObject *)wxImage_GetAlphaData(arg1);
18290 wxPyEndAllowThreads(__tstate);
18291 if (PyErr_Occurred()) SWIG_fail;
18292 }
18293 resultobj = result;
18294 return resultobj;
18295 fail:
18296 return NULL;
18297 }
18298
18299
18300 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18301 PyObject *resultobj = 0;
18302 wxImage *arg1 = (wxImage *) 0 ;
18303 buffer arg2 ;
18304 int arg3 ;
18305 void *argp1 = 0 ;
18306 int res1 = 0 ;
18307 Py_ssize_t temp2 ;
18308 PyObject * obj0 = 0 ;
18309 PyObject * obj1 = 0 ;
18310 char * kwnames[] = {
18311 (char *) "self",(char *) "alpha", NULL
18312 };
18313
18314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18316 if (!SWIG_IsOK(res1)) {
18317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18318 }
18319 arg1 = reinterpret_cast< wxImage * >(argp1);
18320 {
18321 if (obj1 != Py_None) {
18322 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18323 arg3 = (int)temp2;
18324 }
18325 }
18326 {
18327 PyThreadState* __tstate = wxPyBeginAllowThreads();
18328 wxImage_SetAlphaData(arg1,arg2,arg3);
18329 wxPyEndAllowThreads(__tstate);
18330 if (PyErr_Occurred()) SWIG_fail;
18331 }
18332 resultobj = SWIG_Py_Void();
18333 return resultobj;
18334 fail:
18335 return NULL;
18336 }
18337
18338
18339 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18340 PyObject *resultobj = 0;
18341 wxImage *arg1 = (wxImage *) 0 ;
18342 PyObject *result = 0 ;
18343 void *argp1 = 0 ;
18344 int res1 = 0 ;
18345 PyObject *swig_obj[1] ;
18346
18347 if (!args) SWIG_fail;
18348 swig_obj[0] = args;
18349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18350 if (!SWIG_IsOK(res1)) {
18351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18352 }
18353 arg1 = reinterpret_cast< wxImage * >(argp1);
18354 {
18355 PyThreadState* __tstate = wxPyBeginAllowThreads();
18356 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18357 wxPyEndAllowThreads(__tstate);
18358 if (PyErr_Occurred()) SWIG_fail;
18359 }
18360 resultobj = result;
18361 return resultobj;
18362 fail:
18363 return NULL;
18364 }
18365
18366
18367 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18368 PyObject *resultobj = 0;
18369 wxImage *arg1 = (wxImage *) 0 ;
18370 buffer arg2 ;
18371 int arg3 ;
18372 void *argp1 = 0 ;
18373 int res1 = 0 ;
18374 Py_ssize_t temp2 ;
18375 PyObject * obj0 = 0 ;
18376 PyObject * obj1 = 0 ;
18377 char * kwnames[] = {
18378 (char *) "self",(char *) "alpha", NULL
18379 };
18380
18381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18383 if (!SWIG_IsOK(res1)) {
18384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18385 }
18386 arg1 = reinterpret_cast< wxImage * >(argp1);
18387 {
18388 if (obj1 != Py_None) {
18389 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18390 arg3 = (int)temp2;
18391 }
18392 }
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = SWIG_Py_Void();
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj = 0;
18408 wxImage *arg1 = (wxImage *) 0 ;
18409 byte arg2 ;
18410 byte arg3 ;
18411 byte arg4 ;
18412 void *argp1 = 0 ;
18413 int res1 = 0 ;
18414 unsigned char val2 ;
18415 int ecode2 = 0 ;
18416 unsigned char val3 ;
18417 int ecode3 = 0 ;
18418 unsigned char val4 ;
18419 int ecode4 = 0 ;
18420 PyObject * obj0 = 0 ;
18421 PyObject * obj1 = 0 ;
18422 PyObject * obj2 = 0 ;
18423 PyObject * obj3 = 0 ;
18424 char * kwnames[] = {
18425 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18426 };
18427
18428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18430 if (!SWIG_IsOK(res1)) {
18431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18432 }
18433 arg1 = reinterpret_cast< wxImage * >(argp1);
18434 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18435 if (!SWIG_IsOK(ecode2)) {
18436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18437 }
18438 arg2 = static_cast< byte >(val2);
18439 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18440 if (!SWIG_IsOK(ecode3)) {
18441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18442 }
18443 arg3 = static_cast< byte >(val3);
18444 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18445 if (!SWIG_IsOK(ecode4)) {
18446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18447 }
18448 arg4 = static_cast< byte >(val4);
18449 {
18450 PyThreadState* __tstate = wxPyBeginAllowThreads();
18451 (arg1)->SetMaskColour(arg2,arg3,arg4);
18452 wxPyEndAllowThreads(__tstate);
18453 if (PyErr_Occurred()) SWIG_fail;
18454 }
18455 resultobj = SWIG_Py_Void();
18456 return resultobj;
18457 fail:
18458 return NULL;
18459 }
18460
18461
18462 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18463 PyObject *resultobj = 0;
18464 wxImage *arg1 = (wxImage *) 0 ;
18465 byte *arg2 = (byte *) 0 ;
18466 byte *arg3 = (byte *) 0 ;
18467 byte *arg4 = (byte *) 0 ;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 byte temp2 ;
18471 int res2 = SWIG_TMPOBJ ;
18472 byte temp3 ;
18473 int res3 = SWIG_TMPOBJ ;
18474 byte temp4 ;
18475 int res4 = SWIG_TMPOBJ ;
18476 PyObject *swig_obj[1] ;
18477
18478 arg2 = &temp2;
18479 arg3 = &temp3;
18480 arg4 = &temp4;
18481 if (!args) SWIG_fail;
18482 swig_obj[0] = args;
18483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18484 if (!SWIG_IsOK(res1)) {
18485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18486 }
18487 arg1 = reinterpret_cast< wxImage * >(argp1);
18488 {
18489 PyThreadState* __tstate = wxPyBeginAllowThreads();
18490 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18491 wxPyEndAllowThreads(__tstate);
18492 if (PyErr_Occurred()) SWIG_fail;
18493 }
18494 resultobj = SWIG_Py_Void();
18495 if (SWIG_IsTmpObj(res2)) {
18496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18497 } else {
18498 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18500 }
18501 if (SWIG_IsTmpObj(res3)) {
18502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18503 } else {
18504 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18506 }
18507 if (SWIG_IsTmpObj(res4)) {
18508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18509 } else {
18510 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18512 }
18513 return resultobj;
18514 fail:
18515 return NULL;
18516 }
18517
18518
18519 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18520 PyObject *resultobj = 0;
18521 wxImage *arg1 = (wxImage *) 0 ;
18522 byte result;
18523 void *argp1 = 0 ;
18524 int res1 = 0 ;
18525 PyObject *swig_obj[1] ;
18526
18527 if (!args) SWIG_fail;
18528 swig_obj[0] = args;
18529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18530 if (!SWIG_IsOK(res1)) {
18531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18532 }
18533 arg1 = reinterpret_cast< wxImage * >(argp1);
18534 {
18535 PyThreadState* __tstate = wxPyBeginAllowThreads();
18536 result = (byte)(arg1)->GetMaskRed();
18537 wxPyEndAllowThreads(__tstate);
18538 if (PyErr_Occurred()) SWIG_fail;
18539 }
18540 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18541 return resultobj;
18542 fail:
18543 return NULL;
18544 }
18545
18546
18547 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18548 PyObject *resultobj = 0;
18549 wxImage *arg1 = (wxImage *) 0 ;
18550 byte result;
18551 void *argp1 = 0 ;
18552 int res1 = 0 ;
18553 PyObject *swig_obj[1] ;
18554
18555 if (!args) SWIG_fail;
18556 swig_obj[0] = args;
18557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18560 }
18561 arg1 = reinterpret_cast< wxImage * >(argp1);
18562 {
18563 PyThreadState* __tstate = wxPyBeginAllowThreads();
18564 result = (byte)(arg1)->GetMaskGreen();
18565 wxPyEndAllowThreads(__tstate);
18566 if (PyErr_Occurred()) SWIG_fail;
18567 }
18568 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18569 return resultobj;
18570 fail:
18571 return NULL;
18572 }
18573
18574
18575 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18576 PyObject *resultobj = 0;
18577 wxImage *arg1 = (wxImage *) 0 ;
18578 byte result;
18579 void *argp1 = 0 ;
18580 int res1 = 0 ;
18581 PyObject *swig_obj[1] ;
18582
18583 if (!args) SWIG_fail;
18584 swig_obj[0] = args;
18585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18586 if (!SWIG_IsOK(res1)) {
18587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18588 }
18589 arg1 = reinterpret_cast< wxImage * >(argp1);
18590 {
18591 PyThreadState* __tstate = wxPyBeginAllowThreads();
18592 result = (byte)(arg1)->GetMaskBlue();
18593 wxPyEndAllowThreads(__tstate);
18594 if (PyErr_Occurred()) SWIG_fail;
18595 }
18596 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18597 return resultobj;
18598 fail:
18599 return NULL;
18600 }
18601
18602
18603 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18604 PyObject *resultobj = 0;
18605 wxImage *arg1 = (wxImage *) 0 ;
18606 bool arg2 = (bool) true ;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 bool val2 ;
18610 int ecode2 = 0 ;
18611 PyObject * obj0 = 0 ;
18612 PyObject * obj1 = 0 ;
18613 char * kwnames[] = {
18614 (char *) "self",(char *) "mask", NULL
18615 };
18616
18617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18619 if (!SWIG_IsOK(res1)) {
18620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18621 }
18622 arg1 = reinterpret_cast< wxImage * >(argp1);
18623 if (obj1) {
18624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18625 if (!SWIG_IsOK(ecode2)) {
18626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18627 }
18628 arg2 = static_cast< bool >(val2);
18629 }
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 (arg1)->SetMask(arg2);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_Py_Void();
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxImage *arg1 = (wxImage *) 0 ;
18646 bool result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18656 }
18657 arg1 = reinterpret_cast< wxImage * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (bool)(arg1)->HasMask();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 {
18665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18666 }
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj = 0;
18675 wxImage *arg1 = (wxImage *) 0 ;
18676 double arg2 ;
18677 wxPoint *arg3 = 0 ;
18678 bool arg4 = (bool) true ;
18679 wxPoint *arg5 = (wxPoint *) NULL ;
18680 SwigValueWrapper<wxImage > result;
18681 void *argp1 = 0 ;
18682 int res1 = 0 ;
18683 double val2 ;
18684 int ecode2 = 0 ;
18685 wxPoint temp3 ;
18686 bool val4 ;
18687 int ecode4 = 0 ;
18688 void *argp5 = 0 ;
18689 int res5 = 0 ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 PyObject * obj2 = 0 ;
18693 PyObject * obj3 = 0 ;
18694 PyObject * obj4 = 0 ;
18695 char * kwnames[] = {
18696 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18697 };
18698
18699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18701 if (!SWIG_IsOK(res1)) {
18702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18703 }
18704 arg1 = reinterpret_cast< wxImage * >(argp1);
18705 ecode2 = SWIG_AsVal_double(obj1, &val2);
18706 if (!SWIG_IsOK(ecode2)) {
18707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18708 }
18709 arg2 = static_cast< double >(val2);
18710 {
18711 arg3 = &temp3;
18712 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18713 }
18714 if (obj3) {
18715 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18716 if (!SWIG_IsOK(ecode4)) {
18717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18718 }
18719 arg4 = static_cast< bool >(val4);
18720 }
18721 if (obj4) {
18722 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18723 if (!SWIG_IsOK(res5)) {
18724 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18725 }
18726 arg5 = reinterpret_cast< wxPoint * >(argp5);
18727 }
18728 {
18729 PyThreadState* __tstate = wxPyBeginAllowThreads();
18730 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18735 return resultobj;
18736 fail:
18737 return NULL;
18738 }
18739
18740
18741 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18742 PyObject *resultobj = 0;
18743 wxImage *arg1 = (wxImage *) 0 ;
18744 bool arg2 = (bool) true ;
18745 SwigValueWrapper<wxImage > result;
18746 void *argp1 = 0 ;
18747 int res1 = 0 ;
18748 bool val2 ;
18749 int ecode2 = 0 ;
18750 PyObject * obj0 = 0 ;
18751 PyObject * obj1 = 0 ;
18752 char * kwnames[] = {
18753 (char *) "self",(char *) "clockwise", NULL
18754 };
18755
18756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18758 if (!SWIG_IsOK(res1)) {
18759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18760 }
18761 arg1 = reinterpret_cast< wxImage * >(argp1);
18762 if (obj1) {
18763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18764 if (!SWIG_IsOK(ecode2)) {
18765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18766 }
18767 arg2 = static_cast< bool >(val2);
18768 }
18769 {
18770 PyThreadState* __tstate = wxPyBeginAllowThreads();
18771 result = (arg1)->Rotate90(arg2);
18772 wxPyEndAllowThreads(__tstate);
18773 if (PyErr_Occurred()) SWIG_fail;
18774 }
18775 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18783 PyObject *resultobj = 0;
18784 wxImage *arg1 = (wxImage *) 0 ;
18785 bool arg2 = (bool) true ;
18786 SwigValueWrapper<wxImage > result;
18787 void *argp1 = 0 ;
18788 int res1 = 0 ;
18789 bool val2 ;
18790 int ecode2 = 0 ;
18791 PyObject * obj0 = 0 ;
18792 PyObject * obj1 = 0 ;
18793 char * kwnames[] = {
18794 (char *) "self",(char *) "horizontally", NULL
18795 };
18796
18797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18799 if (!SWIG_IsOK(res1)) {
18800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18801 }
18802 arg1 = reinterpret_cast< wxImage * >(argp1);
18803 if (obj1) {
18804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18805 if (!SWIG_IsOK(ecode2)) {
18806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18807 }
18808 arg2 = static_cast< bool >(val2);
18809 }
18810 {
18811 PyThreadState* __tstate = wxPyBeginAllowThreads();
18812 result = (arg1)->Mirror(arg2);
18813 wxPyEndAllowThreads(__tstate);
18814 if (PyErr_Occurred()) SWIG_fail;
18815 }
18816 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj = 0;
18825 wxImage *arg1 = (wxImage *) 0 ;
18826 byte arg2 ;
18827 byte arg3 ;
18828 byte arg4 ;
18829 byte arg5 ;
18830 byte arg6 ;
18831 byte arg7 ;
18832 void *argp1 = 0 ;
18833 int res1 = 0 ;
18834 unsigned char val2 ;
18835 int ecode2 = 0 ;
18836 unsigned char val3 ;
18837 int ecode3 = 0 ;
18838 unsigned char val4 ;
18839 int ecode4 = 0 ;
18840 unsigned char val5 ;
18841 int ecode5 = 0 ;
18842 unsigned char val6 ;
18843 int ecode6 = 0 ;
18844 unsigned char val7 ;
18845 int ecode7 = 0 ;
18846 PyObject * obj0 = 0 ;
18847 PyObject * obj1 = 0 ;
18848 PyObject * obj2 = 0 ;
18849 PyObject * obj3 = 0 ;
18850 PyObject * obj4 = 0 ;
18851 PyObject * obj5 = 0 ;
18852 PyObject * obj6 = 0 ;
18853 char * kwnames[] = {
18854 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18855 };
18856
18857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18861 }
18862 arg1 = reinterpret_cast< wxImage * >(argp1);
18863 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18864 if (!SWIG_IsOK(ecode2)) {
18865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18866 }
18867 arg2 = static_cast< byte >(val2);
18868 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18869 if (!SWIG_IsOK(ecode3)) {
18870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18871 }
18872 arg3 = static_cast< byte >(val3);
18873 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18874 if (!SWIG_IsOK(ecode4)) {
18875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18876 }
18877 arg4 = static_cast< byte >(val4);
18878 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18879 if (!SWIG_IsOK(ecode5)) {
18880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18881 }
18882 arg5 = static_cast< byte >(val5);
18883 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18884 if (!SWIG_IsOK(ecode6)) {
18885 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18886 }
18887 arg6 = static_cast< byte >(val6);
18888 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18889 if (!SWIG_IsOK(ecode7)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18891 }
18892 arg7 = static_cast< byte >(val7);
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 resultobj = SWIG_Py_Void();
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18907 PyObject *resultobj = 0;
18908 wxImage *arg1 = (wxImage *) 0 ;
18909 double arg2 = (double) 0.299 ;
18910 double arg3 = (double) 0.587 ;
18911 double arg4 = (double) 0.114 ;
18912 SwigValueWrapper<wxImage > result;
18913 void *argp1 = 0 ;
18914 int res1 = 0 ;
18915 double val2 ;
18916 int ecode2 = 0 ;
18917 double val3 ;
18918 int ecode3 = 0 ;
18919 double val4 ;
18920 int ecode4 = 0 ;
18921 PyObject * obj0 = 0 ;
18922 PyObject * obj1 = 0 ;
18923 PyObject * obj2 = 0 ;
18924 PyObject * obj3 = 0 ;
18925 char * kwnames[] = {
18926 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18927 };
18928
18929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18931 if (!SWIG_IsOK(res1)) {
18932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18933 }
18934 arg1 = reinterpret_cast< wxImage * >(argp1);
18935 if (obj1) {
18936 ecode2 = SWIG_AsVal_double(obj1, &val2);
18937 if (!SWIG_IsOK(ecode2)) {
18938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18939 }
18940 arg2 = static_cast< double >(val2);
18941 }
18942 if (obj2) {
18943 ecode3 = SWIG_AsVal_double(obj2, &val3);
18944 if (!SWIG_IsOK(ecode3)) {
18945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18946 }
18947 arg3 = static_cast< double >(val3);
18948 }
18949 if (obj3) {
18950 ecode4 = SWIG_AsVal_double(obj3, &val4);
18951 if (!SWIG_IsOK(ecode4)) {
18952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18953 }
18954 arg4 = static_cast< double >(val4);
18955 }
18956 {
18957 PyThreadState* __tstate = wxPyBeginAllowThreads();
18958 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj = 0;
18971 wxImage *arg1 = (wxImage *) 0 ;
18972 byte arg2 ;
18973 byte arg3 ;
18974 byte arg4 ;
18975 SwigValueWrapper<wxImage > result;
18976 void *argp1 = 0 ;
18977 int res1 = 0 ;
18978 unsigned char val2 ;
18979 int ecode2 = 0 ;
18980 unsigned char val3 ;
18981 int ecode3 = 0 ;
18982 unsigned char val4 ;
18983 int ecode4 = 0 ;
18984 PyObject * obj0 = 0 ;
18985 PyObject * obj1 = 0 ;
18986 PyObject * obj2 = 0 ;
18987 PyObject * obj3 = 0 ;
18988 char * kwnames[] = {
18989 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18990 };
18991
18992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18994 if (!SWIG_IsOK(res1)) {
18995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
18996 }
18997 arg1 = reinterpret_cast< wxImage * >(argp1);
18998 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18999 if (!SWIG_IsOK(ecode2)) {
19000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19001 }
19002 arg2 = static_cast< byte >(val2);
19003 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19004 if (!SWIG_IsOK(ecode3)) {
19005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19006 }
19007 arg3 = static_cast< byte >(val3);
19008 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19009 if (!SWIG_IsOK(ecode4)) {
19010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19011 }
19012 arg4 = static_cast< byte >(val4);
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19016 wxPyEndAllowThreads(__tstate);
19017 if (PyErr_Occurred()) SWIG_fail;
19018 }
19019 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19020 return resultobj;
19021 fail:
19022 return NULL;
19023 }
19024
19025
19026 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19027 PyObject *resultobj = 0;
19028 wxImage *arg1 = (wxImage *) 0 ;
19029 wxString *arg2 = 0 ;
19030 wxString *arg3 = 0 ;
19031 void *argp1 = 0 ;
19032 int res1 = 0 ;
19033 bool temp2 = false ;
19034 bool temp3 = false ;
19035 PyObject * obj0 = 0 ;
19036 PyObject * obj1 = 0 ;
19037 PyObject * obj2 = 0 ;
19038 char * kwnames[] = {
19039 (char *) "self",(char *) "name",(char *) "value", NULL
19040 };
19041
19042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19044 if (!SWIG_IsOK(res1)) {
19045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19046 }
19047 arg1 = reinterpret_cast< wxImage * >(argp1);
19048 {
19049 arg2 = wxString_in_helper(obj1);
19050 if (arg2 == NULL) SWIG_fail;
19051 temp2 = true;
19052 }
19053 {
19054 arg3 = wxString_in_helper(obj2);
19055 if (arg3 == NULL) SWIG_fail;
19056 temp3 = true;
19057 }
19058 {
19059 PyThreadState* __tstate = wxPyBeginAllowThreads();
19060 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19061 wxPyEndAllowThreads(__tstate);
19062 if (PyErr_Occurred()) SWIG_fail;
19063 }
19064 resultobj = SWIG_Py_Void();
19065 {
19066 if (temp2)
19067 delete arg2;
19068 }
19069 {
19070 if (temp3)
19071 delete arg3;
19072 }
19073 return resultobj;
19074 fail:
19075 {
19076 if (temp2)
19077 delete arg2;
19078 }
19079 {
19080 if (temp3)
19081 delete arg3;
19082 }
19083 return NULL;
19084 }
19085
19086
19087 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19088 PyObject *resultobj = 0;
19089 wxImage *arg1 = (wxImage *) 0 ;
19090 wxString *arg2 = 0 ;
19091 int arg3 ;
19092 void *argp1 = 0 ;
19093 int res1 = 0 ;
19094 bool temp2 = false ;
19095 int val3 ;
19096 int ecode3 = 0 ;
19097 PyObject * obj0 = 0 ;
19098 PyObject * obj1 = 0 ;
19099 PyObject * obj2 = 0 ;
19100 char * kwnames[] = {
19101 (char *) "self",(char *) "name",(char *) "value", NULL
19102 };
19103
19104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19106 if (!SWIG_IsOK(res1)) {
19107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19108 }
19109 arg1 = reinterpret_cast< wxImage * >(argp1);
19110 {
19111 arg2 = wxString_in_helper(obj1);
19112 if (arg2 == NULL) SWIG_fail;
19113 temp2 = true;
19114 }
19115 ecode3 = SWIG_AsVal_int(obj2, &val3);
19116 if (!SWIG_IsOK(ecode3)) {
19117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19118 }
19119 arg3 = static_cast< int >(val3);
19120 {
19121 PyThreadState* __tstate = wxPyBeginAllowThreads();
19122 (arg1)->SetOption((wxString const &)*arg2,arg3);
19123 wxPyEndAllowThreads(__tstate);
19124 if (PyErr_Occurred()) SWIG_fail;
19125 }
19126 resultobj = SWIG_Py_Void();
19127 {
19128 if (temp2)
19129 delete arg2;
19130 }
19131 return resultobj;
19132 fail:
19133 {
19134 if (temp2)
19135 delete arg2;
19136 }
19137 return NULL;
19138 }
19139
19140
19141 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19142 PyObject *resultobj = 0;
19143 wxImage *arg1 = (wxImage *) 0 ;
19144 wxString *arg2 = 0 ;
19145 wxString result;
19146 void *argp1 = 0 ;
19147 int res1 = 0 ;
19148 bool temp2 = false ;
19149 PyObject * obj0 = 0 ;
19150 PyObject * obj1 = 0 ;
19151 char * kwnames[] = {
19152 (char *) "self",(char *) "name", NULL
19153 };
19154
19155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19157 if (!SWIG_IsOK(res1)) {
19158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19159 }
19160 arg1 = reinterpret_cast< wxImage * >(argp1);
19161 {
19162 arg2 = wxString_in_helper(obj1);
19163 if (arg2 == NULL) SWIG_fail;
19164 temp2 = true;
19165 }
19166 {
19167 PyThreadState* __tstate = wxPyBeginAllowThreads();
19168 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19169 wxPyEndAllowThreads(__tstate);
19170 if (PyErr_Occurred()) SWIG_fail;
19171 }
19172 {
19173 #if wxUSE_UNICODE
19174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19175 #else
19176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19177 #endif
19178 }
19179 {
19180 if (temp2)
19181 delete arg2;
19182 }
19183 return resultobj;
19184 fail:
19185 {
19186 if (temp2)
19187 delete arg2;
19188 }
19189 return NULL;
19190 }
19191
19192
19193 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19194 PyObject *resultobj = 0;
19195 wxImage *arg1 = (wxImage *) 0 ;
19196 wxString *arg2 = 0 ;
19197 int result;
19198 void *argp1 = 0 ;
19199 int res1 = 0 ;
19200 bool temp2 = false ;
19201 PyObject * obj0 = 0 ;
19202 PyObject * obj1 = 0 ;
19203 char * kwnames[] = {
19204 (char *) "self",(char *) "name", NULL
19205 };
19206
19207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19209 if (!SWIG_IsOK(res1)) {
19210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19211 }
19212 arg1 = reinterpret_cast< wxImage * >(argp1);
19213 {
19214 arg2 = wxString_in_helper(obj1);
19215 if (arg2 == NULL) SWIG_fail;
19216 temp2 = true;
19217 }
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 resultobj = SWIG_From_int(static_cast< int >(result));
19225 {
19226 if (temp2)
19227 delete arg2;
19228 }
19229 return resultobj;
19230 fail:
19231 {
19232 if (temp2)
19233 delete arg2;
19234 }
19235 return NULL;
19236 }
19237
19238
19239 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19240 PyObject *resultobj = 0;
19241 wxImage *arg1 = (wxImage *) 0 ;
19242 wxString *arg2 = 0 ;
19243 bool result;
19244 void *argp1 = 0 ;
19245 int res1 = 0 ;
19246 bool temp2 = false ;
19247 PyObject * obj0 = 0 ;
19248 PyObject * obj1 = 0 ;
19249 char * kwnames[] = {
19250 (char *) "self",(char *) "name", NULL
19251 };
19252
19253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19255 if (!SWIG_IsOK(res1)) {
19256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19257 }
19258 arg1 = reinterpret_cast< wxImage * >(argp1);
19259 {
19260 arg2 = wxString_in_helper(obj1);
19261 if (arg2 == NULL) SWIG_fail;
19262 temp2 = true;
19263 }
19264 {
19265 PyThreadState* __tstate = wxPyBeginAllowThreads();
19266 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 {
19271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19272 }
19273 {
19274 if (temp2)
19275 delete arg2;
19276 }
19277 return resultobj;
19278 fail:
19279 {
19280 if (temp2)
19281 delete arg2;
19282 }
19283 return NULL;
19284 }
19285
19286
19287 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19288 PyObject *resultobj = 0;
19289 wxImage *arg1 = (wxImage *) 0 ;
19290 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19291 unsigned long result;
19292 void *argp1 = 0 ;
19293 int res1 = 0 ;
19294 unsigned long val2 ;
19295 int ecode2 = 0 ;
19296 PyObject * obj0 = 0 ;
19297 PyObject * obj1 = 0 ;
19298 char * kwnames[] = {
19299 (char *) "self",(char *) "stopafter", NULL
19300 };
19301
19302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19304 if (!SWIG_IsOK(res1)) {
19305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19306 }
19307 arg1 = reinterpret_cast< wxImage * >(argp1);
19308 if (obj1) {
19309 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19310 if (!SWIG_IsOK(ecode2)) {
19311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19312 }
19313 arg2 = static_cast< unsigned long >(val2);
19314 }
19315 {
19316 PyThreadState* __tstate = wxPyBeginAllowThreads();
19317 result = (unsigned long)(arg1)->CountColours(arg2);
19318 wxPyEndAllowThreads(__tstate);
19319 if (PyErr_Occurred()) SWIG_fail;
19320 }
19321 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj = 0;
19330 wxImage *arg1 = (wxImage *) 0 ;
19331 wxImageHistogram *arg2 = 0 ;
19332 unsigned long result;
19333 void *argp1 = 0 ;
19334 int res1 = 0 ;
19335 void *argp2 = 0 ;
19336 int res2 = 0 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char * kwnames[] = {
19340 (char *) "self",(char *) "h", NULL
19341 };
19342
19343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19345 if (!SWIG_IsOK(res1)) {
19346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19347 }
19348 arg1 = reinterpret_cast< wxImage * >(argp1);
19349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19350 if (!SWIG_IsOK(res2)) {
19351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19352 }
19353 if (!argp2) {
19354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19355 }
19356 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19357 {
19358 PyThreadState* __tstate = wxPyBeginAllowThreads();
19359 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19360 wxPyEndAllowThreads(__tstate);
19361 if (PyErr_Occurred()) SWIG_fail;
19362 }
19363 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19364 return resultobj;
19365 fail:
19366 return NULL;
19367 }
19368
19369
19370 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19371 PyObject *resultobj = 0;
19372 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19373 void *argp1 = 0 ;
19374 int res1 = 0 ;
19375 PyObject * obj0 = 0 ;
19376 char * kwnames[] = {
19377 (char *) "handler", NULL
19378 };
19379
19380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19382 if (!SWIG_IsOK(res1)) {
19383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19384 }
19385 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 wxImage::AddHandler(arg1);
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 resultobj = SWIG_Py_Void();
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19400 PyObject *resultobj = 0;
19401 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19402 void *argp1 = 0 ;
19403 int res1 = 0 ;
19404 PyObject * obj0 = 0 ;
19405 char * kwnames[] = {
19406 (char *) "handler", NULL
19407 };
19408
19409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19411 if (!SWIG_IsOK(res1)) {
19412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19413 }
19414 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19415 {
19416 PyThreadState* __tstate = wxPyBeginAllowThreads();
19417 wxImage::InsertHandler(arg1);
19418 wxPyEndAllowThreads(__tstate);
19419 if (PyErr_Occurred()) SWIG_fail;
19420 }
19421 resultobj = SWIG_Py_Void();
19422 return resultobj;
19423 fail:
19424 return NULL;
19425 }
19426
19427
19428 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19429 PyObject *resultobj = 0;
19430 wxString *arg1 = 0 ;
19431 bool result;
19432 bool temp1 = false ;
19433 PyObject * obj0 = 0 ;
19434 char * kwnames[] = {
19435 (char *) "name", NULL
19436 };
19437
19438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19439 {
19440 arg1 = wxString_in_helper(obj0);
19441 if (arg1 == NULL) SWIG_fail;
19442 temp1 = true;
19443 }
19444 {
19445 PyThreadState* __tstate = wxPyBeginAllowThreads();
19446 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 {
19451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19452 }
19453 {
19454 if (temp1)
19455 delete arg1;
19456 }
19457 return resultobj;
19458 fail:
19459 {
19460 if (temp1)
19461 delete arg1;
19462 }
19463 return NULL;
19464 }
19465
19466
19467 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19468 PyObject *resultobj = 0;
19469 PyObject *result = 0 ;
19470
19471 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19472 {
19473 PyThreadState* __tstate = wxPyBeginAllowThreads();
19474 result = (PyObject *)wxImage_GetHandlers();
19475 wxPyEndAllowThreads(__tstate);
19476 if (PyErr_Occurred()) SWIG_fail;
19477 }
19478 resultobj = result;
19479 return resultobj;
19480 fail:
19481 return NULL;
19482 }
19483
19484
19485 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19486 PyObject *resultobj = 0;
19487 wxString result;
19488
19489 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 result = wxImage::GetImageExtWildcard();
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 {
19497 #if wxUSE_UNICODE
19498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19499 #else
19500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19501 #endif
19502 }
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19510 PyObject *resultobj = 0;
19511 wxImage *arg1 = (wxImage *) 0 ;
19512 int arg2 = (int) -1 ;
19513 wxBitmap result;
19514 void *argp1 = 0 ;
19515 int res1 = 0 ;
19516 int val2 ;
19517 int ecode2 = 0 ;
19518 PyObject * obj0 = 0 ;
19519 PyObject * obj1 = 0 ;
19520 char * kwnames[] = {
19521 (char *) "self",(char *) "depth", NULL
19522 };
19523
19524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19526 if (!SWIG_IsOK(res1)) {
19527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19528 }
19529 arg1 = reinterpret_cast< wxImage * >(argp1);
19530 if (obj1) {
19531 ecode2 = SWIG_AsVal_int(obj1, &val2);
19532 if (!SWIG_IsOK(ecode2)) {
19533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19534 }
19535 arg2 = static_cast< int >(val2);
19536 }
19537 {
19538 if (!wxPyCheckForApp()) SWIG_fail;
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 result = wxImage_ConvertToBitmap(arg1,arg2);
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19552 PyObject *resultobj = 0;
19553 wxImage *arg1 = (wxImage *) 0 ;
19554 byte arg2 ;
19555 byte arg3 ;
19556 byte arg4 ;
19557 wxBitmap result;
19558 void *argp1 = 0 ;
19559 int res1 = 0 ;
19560 unsigned char val2 ;
19561 int ecode2 = 0 ;
19562 unsigned char val3 ;
19563 int ecode3 = 0 ;
19564 unsigned char val4 ;
19565 int ecode4 = 0 ;
19566 PyObject * obj0 = 0 ;
19567 PyObject * obj1 = 0 ;
19568 PyObject * obj2 = 0 ;
19569 PyObject * obj3 = 0 ;
19570 char * kwnames[] = {
19571 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19572 };
19573
19574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19576 if (!SWIG_IsOK(res1)) {
19577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19578 }
19579 arg1 = reinterpret_cast< wxImage * >(argp1);
19580 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19581 if (!SWIG_IsOK(ecode2)) {
19582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19583 }
19584 arg2 = static_cast< byte >(val2);
19585 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19586 if (!SWIG_IsOK(ecode3)) {
19587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19588 }
19589 arg3 = static_cast< byte >(val3);
19590 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19591 if (!SWIG_IsOK(ecode4)) {
19592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19593 }
19594 arg4 = static_cast< byte >(val4);
19595 {
19596 if (!wxPyCheckForApp()) SWIG_fail;
19597 PyThreadState* __tstate = wxPyBeginAllowThreads();
19598 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19599 wxPyEndAllowThreads(__tstate);
19600 if (PyErr_Occurred()) SWIG_fail;
19601 }
19602 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19603 return resultobj;
19604 fail:
19605 return NULL;
19606 }
19607
19608
19609 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19610 PyObject *resultobj = 0;
19611 wxImage *arg1 = (wxImage *) 0 ;
19612 double arg2 ;
19613 void *argp1 = 0 ;
19614 int res1 = 0 ;
19615 double val2 ;
19616 int ecode2 = 0 ;
19617 PyObject * obj0 = 0 ;
19618 PyObject * obj1 = 0 ;
19619 char * kwnames[] = {
19620 (char *) "self",(char *) "angle", NULL
19621 };
19622
19623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19625 if (!SWIG_IsOK(res1)) {
19626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19627 }
19628 arg1 = reinterpret_cast< wxImage * >(argp1);
19629 ecode2 = SWIG_AsVal_double(obj1, &val2);
19630 if (!SWIG_IsOK(ecode2)) {
19631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19632 }
19633 arg2 = static_cast< double >(val2);
19634 {
19635 PyThreadState* __tstate = wxPyBeginAllowThreads();
19636 (arg1)->RotateHue(arg2);
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 resultobj = SWIG_Py_Void();
19641 return resultobj;
19642 fail:
19643 return NULL;
19644 }
19645
19646
19647 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19648 PyObject *resultobj = 0;
19649 wxImage_RGBValue arg1 ;
19650 wxImage_HSVValue result;
19651 void *argp1 ;
19652 int res1 = 0 ;
19653 PyObject * obj0 = 0 ;
19654 char * kwnames[] = {
19655 (char *) "rgb", NULL
19656 };
19657
19658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19659 {
19660 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19661 if (!SWIG_IsOK(res1)) {
19662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19663 }
19664 if (!argp1) {
19665 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19666 } else {
19667 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19668 arg1 = *temp;
19669 if (SWIG_IsNewObj(res1)) delete temp;
19670 }
19671 }
19672 {
19673 PyThreadState* __tstate = wxPyBeginAllowThreads();
19674 result = wxImage::RGBtoHSV(arg1);
19675 wxPyEndAllowThreads(__tstate);
19676 if (PyErr_Occurred()) SWIG_fail;
19677 }
19678 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19686 PyObject *resultobj = 0;
19687 wxImage_HSVValue arg1 ;
19688 wxImage_RGBValue result;
19689 void *argp1 ;
19690 int res1 = 0 ;
19691 PyObject * obj0 = 0 ;
19692 char * kwnames[] = {
19693 (char *) "hsv", NULL
19694 };
19695
19696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19697 {
19698 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19699 if (!SWIG_IsOK(res1)) {
19700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19701 }
19702 if (!argp1) {
19703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19704 } else {
19705 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19706 arg1 = *temp;
19707 if (SWIG_IsNewObj(res1)) delete temp;
19708 }
19709 }
19710 {
19711 PyThreadState* __tstate = wxPyBeginAllowThreads();
19712 result = wxImage::HSVtoRGB(arg1);
19713 wxPyEndAllowThreads(__tstate);
19714 if (PyErr_Occurred()) SWIG_fail;
19715 }
19716 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19724 PyObject *obj;
19725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19726 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19727 return SWIG_Py_Void();
19728 }
19729
19730 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19731 return SWIG_Python_InitShadowInstance(args);
19732 }
19733
19734 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19735 PyObject *resultobj = 0;
19736 int arg1 ;
19737 int arg2 ;
19738 buffer arg3 ;
19739 int arg4 ;
19740 buffer arg5 = (buffer) NULL ;
19741 int arg6 = (int) 0 ;
19742 wxImage *result = 0 ;
19743 int val1 ;
19744 int ecode1 = 0 ;
19745 int val2 ;
19746 int ecode2 = 0 ;
19747 Py_ssize_t temp3 ;
19748 Py_ssize_t temp5 ;
19749 PyObject * obj0 = 0 ;
19750 PyObject * obj1 = 0 ;
19751 PyObject * obj2 = 0 ;
19752 PyObject * obj3 = 0 ;
19753 char * kwnames[] = {
19754 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19755 };
19756
19757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19758 ecode1 = SWIG_AsVal_int(obj0, &val1);
19759 if (!SWIG_IsOK(ecode1)) {
19760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19761 }
19762 arg1 = static_cast< int >(val1);
19763 ecode2 = SWIG_AsVal_int(obj1, &val2);
19764 if (!SWIG_IsOK(ecode2)) {
19765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19766 }
19767 arg2 = static_cast< int >(val2);
19768 {
19769 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19770 arg4 = (int)temp3;
19771 }
19772 if (obj3) {
19773 {
19774 if (obj3 != Py_None) {
19775 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19776 arg6 = (int)temp5;
19777 }
19778 }
19779 }
19780 {
19781 PyThreadState* __tstate = wxPyBeginAllowThreads();
19782 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19783 wxPyEndAllowThreads(__tstate);
19784 if (PyErr_Occurred()) SWIG_fail;
19785 }
19786 {
19787 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19788 }
19789 return resultobj;
19790 fail:
19791 return NULL;
19792 }
19793
19794
19795 SWIGINTERN int NullImage_set(PyObject *) {
19796 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19797 return 1;
19798 }
19799
19800
19801 SWIGINTERN PyObject *NullImage_get(void) {
19802 PyObject *pyobj = 0;
19803
19804 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19805 return pyobj;
19806 }
19807
19808
19809 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19810 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19811 return 1;
19812 }
19813
19814
19815 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19816 PyObject *pyobj = 0;
19817
19818 {
19819 #if wxUSE_UNICODE
19820 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19821 #else
19822 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19823 #endif
19824 }
19825 return pyobj;
19826 }
19827
19828
19829 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19830 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19831 return 1;
19832 }
19833
19834
19835 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19836 PyObject *pyobj = 0;
19837
19838 {
19839 #if wxUSE_UNICODE
19840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19841 #else
19842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19843 #endif
19844 }
19845 return pyobj;
19846 }
19847
19848
19849 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19850 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19851 return 1;
19852 }
19853
19854
19855 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19856 PyObject *pyobj = 0;
19857
19858 {
19859 #if wxUSE_UNICODE
19860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19861 #else
19862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19863 #endif
19864 }
19865 return pyobj;
19866 }
19867
19868
19869 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19870 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19871 return 1;
19872 }
19873
19874
19875 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19876 PyObject *pyobj = 0;
19877
19878 {
19879 #if wxUSE_UNICODE
19880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19881 #else
19882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19883 #endif
19884 }
19885 return pyobj;
19886 }
19887
19888
19889 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19890 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19891 return 1;
19892 }
19893
19894
19895 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19896 PyObject *pyobj = 0;
19897
19898 {
19899 #if wxUSE_UNICODE
19900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19901 #else
19902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19903 #endif
19904 }
19905 return pyobj;
19906 }
19907
19908
19909 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19910 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19911 return 1;
19912 }
19913
19914
19915 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19916 PyObject *pyobj = 0;
19917
19918 {
19919 #if wxUSE_UNICODE
19920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19921 #else
19922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19923 #endif
19924 }
19925 return pyobj;
19926 }
19927
19928
19929 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19930 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19931 return 1;
19932 }
19933
19934
19935 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19936 PyObject *pyobj = 0;
19937
19938 {
19939 #if wxUSE_UNICODE
19940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19941 #else
19942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19943 #endif
19944 }
19945 return pyobj;
19946 }
19947
19948
19949 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19950 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19951 return 1;
19952 }
19953
19954
19955 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19956 PyObject *pyobj = 0;
19957
19958 {
19959 #if wxUSE_UNICODE
19960 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19961 #else
19962 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19963 #endif
19964 }
19965 return pyobj;
19966 }
19967
19968
19969 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19970 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19971 return 1;
19972 }
19973
19974
19975 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19976 PyObject *pyobj = 0;
19977
19978 {
19979 #if wxUSE_UNICODE
19980 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19981 #else
19982 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19983 #endif
19984 }
19985 return pyobj;
19986 }
19987
19988
19989 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19990 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19991 return 1;
19992 }
19993
19994
19995 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
19996 PyObject *pyobj = 0;
19997
19998 {
19999 #if wxUSE_UNICODE
20000 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20001 #else
20002 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20003 #endif
20004 }
20005 return pyobj;
20006 }
20007
20008
20009 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20010 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20011 return 1;
20012 }
20013
20014
20015 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20016 PyObject *pyobj = 0;
20017
20018 {
20019 #if wxUSE_UNICODE
20020 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20021 #else
20022 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20023 #endif
20024 }
20025 return pyobj;
20026 }
20027
20028
20029 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20030 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20031 return 1;
20032 }
20033
20034
20035 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20036 PyObject *pyobj = 0;
20037
20038 {
20039 #if wxUSE_UNICODE
20040 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20041 #else
20042 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20043 #endif
20044 }
20045 return pyobj;
20046 }
20047
20048
20049 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20050 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20051 return 1;
20052 }
20053
20054
20055 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20056 PyObject *pyobj = 0;
20057
20058 {
20059 #if wxUSE_UNICODE
20060 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20061 #else
20062 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20063 #endif
20064 }
20065 return pyobj;
20066 }
20067
20068
20069 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20070 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20071 return 1;
20072 }
20073
20074
20075 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20076 PyObject *pyobj = 0;
20077
20078 {
20079 #if wxUSE_UNICODE
20080 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20081 #else
20082 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20083 #endif
20084 }
20085 return pyobj;
20086 }
20087
20088
20089 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20090 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20091 return 1;
20092 }
20093
20094
20095 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20096 PyObject *pyobj = 0;
20097
20098 {
20099 #if wxUSE_UNICODE
20100 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20101 #else
20102 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20103 #endif
20104 }
20105 return pyobj;
20106 }
20107
20108
20109 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20110 PyObject *resultobj = 0;
20111 wxBMPHandler *result = 0 ;
20112
20113 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20114 {
20115 PyThreadState* __tstate = wxPyBeginAllowThreads();
20116 result = (wxBMPHandler *)new wxBMPHandler();
20117 wxPyEndAllowThreads(__tstate);
20118 if (PyErr_Occurred()) SWIG_fail;
20119 }
20120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20128 PyObject *obj;
20129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20130 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20131 return SWIG_Py_Void();
20132 }
20133
20134 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20135 return SWIG_Python_InitShadowInstance(args);
20136 }
20137
20138 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20139 PyObject *resultobj = 0;
20140 wxICOHandler *result = 0 ;
20141
20142 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20143 {
20144 PyThreadState* __tstate = wxPyBeginAllowThreads();
20145 result = (wxICOHandler *)new wxICOHandler();
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20157 PyObject *obj;
20158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20159 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20160 return SWIG_Py_Void();
20161 }
20162
20163 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20164 return SWIG_Python_InitShadowInstance(args);
20165 }
20166
20167 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20168 PyObject *resultobj = 0;
20169 wxCURHandler *result = 0 ;
20170
20171 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20172 {
20173 PyThreadState* __tstate = wxPyBeginAllowThreads();
20174 result = (wxCURHandler *)new wxCURHandler();
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20179 return resultobj;
20180 fail:
20181 return NULL;
20182 }
20183
20184
20185 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20186 PyObject *obj;
20187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20188 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20189 return SWIG_Py_Void();
20190 }
20191
20192 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20193 return SWIG_Python_InitShadowInstance(args);
20194 }
20195
20196 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20197 PyObject *resultobj = 0;
20198 wxANIHandler *result = 0 ;
20199
20200 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20201 {
20202 PyThreadState* __tstate = wxPyBeginAllowThreads();
20203 result = (wxANIHandler *)new wxANIHandler();
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20215 PyObject *obj;
20216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20217 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20218 return SWIG_Py_Void();
20219 }
20220
20221 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20222 return SWIG_Python_InitShadowInstance(args);
20223 }
20224
20225 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 PyObject *resultobj = 0;
20227 wxPNGHandler *result = 0 ;
20228
20229 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 result = (wxPNGHandler *)new wxPNGHandler();
20233 wxPyEndAllowThreads(__tstate);
20234 if (PyErr_Occurred()) SWIG_fail;
20235 }
20236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20244 PyObject *obj;
20245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20246 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20247 return SWIG_Py_Void();
20248 }
20249
20250 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20251 return SWIG_Python_InitShadowInstance(args);
20252 }
20253
20254 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 PyObject *resultobj = 0;
20256 wxGIFHandler *result = 0 ;
20257
20258 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20259 {
20260 PyThreadState* __tstate = wxPyBeginAllowThreads();
20261 result = (wxGIFHandler *)new wxGIFHandler();
20262 wxPyEndAllowThreads(__tstate);
20263 if (PyErr_Occurred()) SWIG_fail;
20264 }
20265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20273 PyObject *obj;
20274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20275 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20276 return SWIG_Py_Void();
20277 }
20278
20279 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20280 return SWIG_Python_InitShadowInstance(args);
20281 }
20282
20283 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20284 PyObject *resultobj = 0;
20285 wxPCXHandler *result = 0 ;
20286
20287 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (wxPCXHandler *)new wxPCXHandler();
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20302 PyObject *obj;
20303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20304 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20305 return SWIG_Py_Void();
20306 }
20307
20308 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20309 return SWIG_Python_InitShadowInstance(args);
20310 }
20311
20312 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 PyObject *resultobj = 0;
20314 wxJPEGHandler *result = 0 ;
20315
20316 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20317 {
20318 PyThreadState* __tstate = wxPyBeginAllowThreads();
20319 result = (wxJPEGHandler *)new wxJPEGHandler();
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20331 PyObject *obj;
20332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20333 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20334 return SWIG_Py_Void();
20335 }
20336
20337 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20338 return SWIG_Python_InitShadowInstance(args);
20339 }
20340
20341 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 PyObject *resultobj = 0;
20343 wxPNMHandler *result = 0 ;
20344
20345 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20346 {
20347 PyThreadState* __tstate = wxPyBeginAllowThreads();
20348 result = (wxPNMHandler *)new wxPNMHandler();
20349 wxPyEndAllowThreads(__tstate);
20350 if (PyErr_Occurred()) SWIG_fail;
20351 }
20352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20360 PyObject *obj;
20361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20362 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20363 return SWIG_Py_Void();
20364 }
20365
20366 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20367 return SWIG_Python_InitShadowInstance(args);
20368 }
20369
20370 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 PyObject *resultobj = 0;
20372 wxXPMHandler *result = 0 ;
20373
20374 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20375 {
20376 PyThreadState* __tstate = wxPyBeginAllowThreads();
20377 result = (wxXPMHandler *)new wxXPMHandler();
20378 wxPyEndAllowThreads(__tstate);
20379 if (PyErr_Occurred()) SWIG_fail;
20380 }
20381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20382 return resultobj;
20383 fail:
20384 return NULL;
20385 }
20386
20387
20388 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20389 PyObject *obj;
20390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20391 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20392 return SWIG_Py_Void();
20393 }
20394
20395 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20396 return SWIG_Python_InitShadowInstance(args);
20397 }
20398
20399 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 PyObject *resultobj = 0;
20401 wxTIFFHandler *result = 0 ;
20402
20403 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (wxTIFFHandler *)new wxTIFFHandler();
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20411 return resultobj;
20412 fail:
20413 return NULL;
20414 }
20415
20416
20417 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20418 PyObject *obj;
20419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20420 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20421 return SWIG_Py_Void();
20422 }
20423
20424 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20425 return SWIG_Python_InitShadowInstance(args);
20426 }
20427
20428 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20429 PyObject *resultobj = 0;
20430 wxImage *arg1 = 0 ;
20431 wxImage *arg2 = 0 ;
20432 int arg3 = (int) 236 ;
20433 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20434 bool result;
20435 void *argp1 = 0 ;
20436 int res1 = 0 ;
20437 void *argp2 = 0 ;
20438 int res2 = 0 ;
20439 int val3 ;
20440 int ecode3 = 0 ;
20441 int val4 ;
20442 int ecode4 = 0 ;
20443 PyObject * obj0 = 0 ;
20444 PyObject * obj1 = 0 ;
20445 PyObject * obj2 = 0 ;
20446 PyObject * obj3 = 0 ;
20447 char * kwnames[] = {
20448 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20449 };
20450
20451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20452 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20453 if (!SWIG_IsOK(res1)) {
20454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20455 }
20456 if (!argp1) {
20457 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20458 }
20459 arg1 = reinterpret_cast< wxImage * >(argp1);
20460 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20461 if (!SWIG_IsOK(res2)) {
20462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20463 }
20464 if (!argp2) {
20465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20466 }
20467 arg2 = reinterpret_cast< wxImage * >(argp2);
20468 if (obj2) {
20469 ecode3 = SWIG_AsVal_int(obj2, &val3);
20470 if (!SWIG_IsOK(ecode3)) {
20471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20472 }
20473 arg3 = static_cast< int >(val3);
20474 }
20475 if (obj3) {
20476 ecode4 = SWIG_AsVal_int(obj3, &val4);
20477 if (!SWIG_IsOK(ecode4)) {
20478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20479 }
20480 arg4 = static_cast< int >(val4);
20481 }
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 {
20489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20490 }
20491 return resultobj;
20492 fail:
20493 return NULL;
20494 }
20495
20496
20497 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20498 PyObject *obj;
20499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20500 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20501 return SWIG_Py_Void();
20502 }
20503
20504 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20505 PyObject *resultobj = 0;
20506 wxEvtHandler *result = 0 ;
20507
20508 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20509 {
20510 PyThreadState* __tstate = wxPyBeginAllowThreads();
20511 result = (wxEvtHandler *)new wxEvtHandler();
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20523 PyObject *resultobj = 0;
20524 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20525 wxEvtHandler *result = 0 ;
20526 void *argp1 = 0 ;
20527 int res1 = 0 ;
20528 PyObject *swig_obj[1] ;
20529
20530 if (!args) SWIG_fail;
20531 swig_obj[0] = args;
20532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20533 if (!SWIG_IsOK(res1)) {
20534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20535 }
20536 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 {
20544 resultobj = wxPyMake_wxObject(result, 0);
20545 }
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20555 wxEvtHandler *result = 0 ;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 PyObject *swig_obj[1] ;
20559
20560 if (!args) SWIG_fail;
20561 swig_obj[0] = args;
20562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20563 if (!SWIG_IsOK(res1)) {
20564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20565 }
20566 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 {
20574 resultobj = wxPyMake_wxObject(result, 0);
20575 }
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20583 PyObject *resultobj = 0;
20584 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20586 void *argp1 = 0 ;
20587 int res1 = 0 ;
20588 void *argp2 = 0 ;
20589 int res2 = 0 ;
20590 PyObject * obj0 = 0 ;
20591 PyObject * obj1 = 0 ;
20592 char * kwnames[] = {
20593 (char *) "self",(char *) "handler", NULL
20594 };
20595
20596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20598 if (!SWIG_IsOK(res1)) {
20599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20600 }
20601 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20603 if (!SWIG_IsOK(res2)) {
20604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20605 }
20606 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20607 {
20608 PyThreadState* __tstate = wxPyBeginAllowThreads();
20609 (arg1)->SetNextHandler(arg2);
20610 wxPyEndAllowThreads(__tstate);
20611 if (PyErr_Occurred()) SWIG_fail;
20612 }
20613 resultobj = SWIG_Py_Void();
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj = 0;
20622 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20623 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20624 void *argp1 = 0 ;
20625 int res1 = 0 ;
20626 void *argp2 = 0 ;
20627 int res2 = 0 ;
20628 PyObject * obj0 = 0 ;
20629 PyObject * obj1 = 0 ;
20630 char * kwnames[] = {
20631 (char *) "self",(char *) "handler", NULL
20632 };
20633
20634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20638 }
20639 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20641 if (!SWIG_IsOK(res2)) {
20642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20643 }
20644 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 (arg1)->SetPreviousHandler(arg2);
20648 wxPyEndAllowThreads(__tstate);
20649 if (PyErr_Occurred()) SWIG_fail;
20650 }
20651 resultobj = SWIG_Py_Void();
20652 return resultobj;
20653 fail:
20654 return NULL;
20655 }
20656
20657
20658 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20659 PyObject *resultobj = 0;
20660 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20661 bool result;
20662 void *argp1 = 0 ;
20663 int res1 = 0 ;
20664 PyObject *swig_obj[1] ;
20665
20666 if (!args) SWIG_fail;
20667 swig_obj[0] = args;
20668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20669 if (!SWIG_IsOK(res1)) {
20670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20671 }
20672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = (bool)(arg1)->GetEvtHandlerEnabled();
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 {
20680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20681 }
20682 return resultobj;
20683 fail:
20684 return NULL;
20685 }
20686
20687
20688 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20689 PyObject *resultobj = 0;
20690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20691 bool arg2 ;
20692 void *argp1 = 0 ;
20693 int res1 = 0 ;
20694 bool val2 ;
20695 int ecode2 = 0 ;
20696 PyObject * obj0 = 0 ;
20697 PyObject * obj1 = 0 ;
20698 char * kwnames[] = {
20699 (char *) "self",(char *) "enabled", NULL
20700 };
20701
20702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20704 if (!SWIG_IsOK(res1)) {
20705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20706 }
20707 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20709 if (!SWIG_IsOK(ecode2)) {
20710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20711 }
20712 arg2 = static_cast< bool >(val2);
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 (arg1)->SetEvtHandlerEnabled(arg2);
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 resultobj = SWIG_Py_Void();
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj = 0;
20728 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20729 wxEvent *arg2 = 0 ;
20730 bool result;
20731 void *argp1 = 0 ;
20732 int res1 = 0 ;
20733 void *argp2 = 0 ;
20734 int res2 = 0 ;
20735 PyObject * obj0 = 0 ;
20736 PyObject * obj1 = 0 ;
20737 char * kwnames[] = {
20738 (char *) "self",(char *) "event", NULL
20739 };
20740
20741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20743 if (!SWIG_IsOK(res1)) {
20744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20745 }
20746 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20748 if (!SWIG_IsOK(res2)) {
20749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20750 }
20751 if (!argp2) {
20752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20753 }
20754 arg2 = reinterpret_cast< wxEvent * >(argp2);
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (bool)(arg1)->ProcessEvent(*arg2);
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 {
20762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20763 }
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20771 PyObject *resultobj = 0;
20772 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20773 wxEvent *arg2 = 0 ;
20774 void *argp1 = 0 ;
20775 int res1 = 0 ;
20776 void *argp2 = 0 ;
20777 int res2 = 0 ;
20778 PyObject * obj0 = 0 ;
20779 PyObject * obj1 = 0 ;
20780 char * kwnames[] = {
20781 (char *) "self",(char *) "event", NULL
20782 };
20783
20784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20786 if (!SWIG_IsOK(res1)) {
20787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20788 }
20789 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20790 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20791 if (!SWIG_IsOK(res2)) {
20792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20793 }
20794 if (!argp2) {
20795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20796 }
20797 arg2 = reinterpret_cast< wxEvent * >(argp2);
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 (arg1)->AddPendingEvent(*arg2);
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_Py_Void();
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20812 PyObject *resultobj = 0;
20813 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20814 void *argp1 = 0 ;
20815 int res1 = 0 ;
20816 PyObject *swig_obj[1] ;
20817
20818 if (!args) SWIG_fail;
20819 swig_obj[0] = args;
20820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20821 if (!SWIG_IsOK(res1)) {
20822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20823 }
20824 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20825 {
20826 PyThreadState* __tstate = wxPyBeginAllowThreads();
20827 (arg1)->ProcessPendingEvents();
20828 wxPyEndAllowThreads(__tstate);
20829 if (PyErr_Occurred()) SWIG_fail;
20830 }
20831 resultobj = SWIG_Py_Void();
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20839 PyObject *resultobj = 0;
20840 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20841 bool arg2 = (bool) true ;
20842 void *argp1 = 0 ;
20843 int res1 = 0 ;
20844 bool val2 ;
20845 int ecode2 = 0 ;
20846 PyObject * obj0 = 0 ;
20847 PyObject * obj1 = 0 ;
20848 char * kwnames[] = {
20849 (char *) "self",(char *) "allow", NULL
20850 };
20851
20852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20854 if (!SWIG_IsOK(res1)) {
20855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20856 }
20857 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20858 if (obj1) {
20859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20860 if (!SWIG_IsOK(ecode2)) {
20861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20862 }
20863 arg2 = static_cast< bool >(val2);
20864 }
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 (arg1)->AllowReentrance(arg2);
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 resultobj = SWIG_Py_Void();
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20879 PyObject *resultobj = 0;
20880 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20881 bool result;
20882 void *argp1 = 0 ;
20883 int res1 = 0 ;
20884 PyObject *swig_obj[1] ;
20885
20886 if (!args) SWIG_fail;
20887 swig_obj[0] = args;
20888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20889 if (!SWIG_IsOK(res1)) {
20890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20891 }
20892 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (bool)(arg1)->IsReentranceAllowed();
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 {
20900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20901 }
20902 return resultobj;
20903 fail:
20904 return NULL;
20905 }
20906
20907
20908 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20909 PyObject *resultobj = 0;
20910 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20911 bool result;
20912 void *argp1 = 0 ;
20913 int res1 = 0 ;
20914 PyObject *swig_obj[1] ;
20915
20916 if (!args) SWIG_fail;
20917 swig_obj[0] = args;
20918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20919 if (!SWIG_IsOK(res1)) {
20920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20921 }
20922 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20923 {
20924 PyThreadState* __tstate = wxPyBeginAllowThreads();
20925 result = (bool)(arg1)->IsEventHandlingInProgress();
20926 wxPyEndAllowThreads(__tstate);
20927 if (PyErr_Occurred()) SWIG_fail;
20928 }
20929 {
20930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20931 }
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj = 0;
20940 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20941 int arg2 ;
20942 int arg3 ;
20943 int arg4 ;
20944 PyObject *arg5 = (PyObject *) 0 ;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 int val2 ;
20948 int ecode2 = 0 ;
20949 int val3 ;
20950 int ecode3 = 0 ;
20951 int val4 ;
20952 int ecode4 = 0 ;
20953 PyObject * obj0 = 0 ;
20954 PyObject * obj1 = 0 ;
20955 PyObject * obj2 = 0 ;
20956 PyObject * obj3 = 0 ;
20957 PyObject * obj4 = 0 ;
20958 char * kwnames[] = {
20959 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20960 };
20961
20962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20964 if (!SWIG_IsOK(res1)) {
20965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20966 }
20967 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20968 ecode2 = SWIG_AsVal_int(obj1, &val2);
20969 if (!SWIG_IsOK(ecode2)) {
20970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20971 }
20972 arg2 = static_cast< int >(val2);
20973 ecode3 = SWIG_AsVal_int(obj2, &val3);
20974 if (!SWIG_IsOK(ecode3)) {
20975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20976 }
20977 arg3 = static_cast< int >(val3);
20978 ecode4 = SWIG_AsVal_int(obj3, &val4);
20979 if (!SWIG_IsOK(ecode4)) {
20980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20981 }
20982 arg4 = static_cast< int >(val4);
20983 arg5 = obj4;
20984 {
20985 PyThreadState* __tstate = wxPyBeginAllowThreads();
20986 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20987 wxPyEndAllowThreads(__tstate);
20988 if (PyErr_Occurred()) SWIG_fail;
20989 }
20990 resultobj = SWIG_Py_Void();
20991 return resultobj;
20992 fail:
20993 return NULL;
20994 }
20995
20996
20997 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20998 PyObject *resultobj = 0;
20999 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21000 int arg2 ;
21001 int arg3 = (int) -1 ;
21002 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21003 bool result;
21004 void *argp1 = 0 ;
21005 int res1 = 0 ;
21006 int val2 ;
21007 int ecode2 = 0 ;
21008 int val3 ;
21009 int ecode3 = 0 ;
21010 int val4 ;
21011 int ecode4 = 0 ;
21012 PyObject * obj0 = 0 ;
21013 PyObject * obj1 = 0 ;
21014 PyObject * obj2 = 0 ;
21015 PyObject * obj3 = 0 ;
21016 char * kwnames[] = {
21017 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21018 };
21019
21020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21022 if (!SWIG_IsOK(res1)) {
21023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21024 }
21025 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21026 ecode2 = SWIG_AsVal_int(obj1, &val2);
21027 if (!SWIG_IsOK(ecode2)) {
21028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21029 }
21030 arg2 = static_cast< int >(val2);
21031 if (obj2) {
21032 ecode3 = SWIG_AsVal_int(obj2, &val3);
21033 if (!SWIG_IsOK(ecode3)) {
21034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21035 }
21036 arg3 = static_cast< int >(val3);
21037 }
21038 if (obj3) {
21039 ecode4 = SWIG_AsVal_int(obj3, &val4);
21040 if (!SWIG_IsOK(ecode4)) {
21041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21042 }
21043 arg4 = static_cast< wxEventType >(val4);
21044 }
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 {
21052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj = 0;
21062 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21063 PyObject *arg2 = (PyObject *) 0 ;
21064 bool arg3 = (bool) true ;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 bool val3 ;
21068 int ecode3 = 0 ;
21069 PyObject * obj0 = 0 ;
21070 PyObject * obj1 = 0 ;
21071 PyObject * obj2 = 0 ;
21072 char * kwnames[] = {
21073 (char *) "self",(char *) "_self",(char *) "incref", NULL
21074 };
21075
21076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21080 }
21081 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21082 arg2 = obj1;
21083 if (obj2) {
21084 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21085 if (!SWIG_IsOK(ecode3)) {
21086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21087 }
21088 arg3 = static_cast< bool >(val3);
21089 }
21090 {
21091 PyThreadState* __tstate = wxPyBeginAllowThreads();
21092 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21093 wxPyEndAllowThreads(__tstate);
21094 if (PyErr_Occurred()) SWIG_fail;
21095 }
21096 resultobj = SWIG_Py_Void();
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21104 PyObject *obj;
21105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21106 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21107 return SWIG_Py_Void();
21108 }
21109
21110 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21111 return SWIG_Python_InitShadowInstance(args);
21112 }
21113
21114 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21115 PyObject *resultobj = 0;
21116 wxEventType result;
21117
21118 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21119 {
21120 PyThreadState* __tstate = wxPyBeginAllowThreads();
21121 result = (wxEventType)wxNewEventType();
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 resultobj = SWIG_From_int(static_cast< int >(result));
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21133 PyObject *resultobj = 0;
21134 wxEvent *arg1 = (wxEvent *) 0 ;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21144 }
21145 arg1 = reinterpret_cast< wxEvent * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 delete arg1;
21149
21150 wxPyEndAllowThreads(__tstate);
21151 if (PyErr_Occurred()) SWIG_fail;
21152 }
21153 resultobj = SWIG_Py_Void();
21154 return resultobj;
21155 fail:
21156 return NULL;
21157 }
21158
21159
21160 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21161 PyObject *resultobj = 0;
21162 wxEvent *arg1 = (wxEvent *) 0 ;
21163 wxEventType arg2 ;
21164 void *argp1 = 0 ;
21165 int res1 = 0 ;
21166 int val2 ;
21167 int ecode2 = 0 ;
21168 PyObject * obj0 = 0 ;
21169 PyObject * obj1 = 0 ;
21170 char * kwnames[] = {
21171 (char *) "self",(char *) "typ", NULL
21172 };
21173
21174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21176 if (!SWIG_IsOK(res1)) {
21177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21178 }
21179 arg1 = reinterpret_cast< wxEvent * >(argp1);
21180 ecode2 = SWIG_AsVal_int(obj1, &val2);
21181 if (!SWIG_IsOK(ecode2)) {
21182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21183 }
21184 arg2 = static_cast< wxEventType >(val2);
21185 {
21186 PyThreadState* __tstate = wxPyBeginAllowThreads();
21187 (arg1)->SetEventType(arg2);
21188 wxPyEndAllowThreads(__tstate);
21189 if (PyErr_Occurred()) SWIG_fail;
21190 }
21191 resultobj = SWIG_Py_Void();
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21199 PyObject *resultobj = 0;
21200 wxEvent *arg1 = (wxEvent *) 0 ;
21201 wxEventType result;
21202 void *argp1 = 0 ;
21203 int res1 = 0 ;
21204 PyObject *swig_obj[1] ;
21205
21206 if (!args) SWIG_fail;
21207 swig_obj[0] = args;
21208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxEvent * >(argp1);
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 resultobj = SWIG_From_int(static_cast< int >(result));
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21227 PyObject *resultobj = 0;
21228 wxEvent *arg1 = (wxEvent *) 0 ;
21229 wxObject *result = 0 ;
21230 void *argp1 = 0 ;
21231 int res1 = 0 ;
21232 PyObject *swig_obj[1] ;
21233
21234 if (!args) SWIG_fail;
21235 swig_obj[0] = args;
21236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21237 if (!SWIG_IsOK(res1)) {
21238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21239 }
21240 arg1 = reinterpret_cast< wxEvent * >(argp1);
21241 {
21242 PyThreadState* __tstate = wxPyBeginAllowThreads();
21243 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21244 wxPyEndAllowThreads(__tstate);
21245 if (PyErr_Occurred()) SWIG_fail;
21246 }
21247 {
21248 resultobj = wxPyMake_wxObject(result, (bool)0);
21249 }
21250 return resultobj;
21251 fail:
21252 return NULL;
21253 }
21254
21255
21256 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21257 PyObject *resultobj = 0;
21258 wxEvent *arg1 = (wxEvent *) 0 ;
21259 wxObject *arg2 = (wxObject *) 0 ;
21260 void *argp1 = 0 ;
21261 int res1 = 0 ;
21262 void *argp2 = 0 ;
21263 int res2 = 0 ;
21264 PyObject * obj0 = 0 ;
21265 PyObject * obj1 = 0 ;
21266 char * kwnames[] = {
21267 (char *) "self",(char *) "obj", NULL
21268 };
21269
21270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21272 if (!SWIG_IsOK(res1)) {
21273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21274 }
21275 arg1 = reinterpret_cast< wxEvent * >(argp1);
21276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21277 if (!SWIG_IsOK(res2)) {
21278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21279 }
21280 arg2 = reinterpret_cast< wxObject * >(argp2);
21281 {
21282 PyThreadState* __tstate = wxPyBeginAllowThreads();
21283 (arg1)->SetEventObject(arg2);
21284 wxPyEndAllowThreads(__tstate);
21285 if (PyErr_Occurred()) SWIG_fail;
21286 }
21287 resultobj = SWIG_Py_Void();
21288 return resultobj;
21289 fail:
21290 return NULL;
21291 }
21292
21293
21294 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21295 PyObject *resultobj = 0;
21296 wxEvent *arg1 = (wxEvent *) 0 ;
21297 long result;
21298 void *argp1 = 0 ;
21299 int res1 = 0 ;
21300 PyObject *swig_obj[1] ;
21301
21302 if (!args) SWIG_fail;
21303 swig_obj[0] = args;
21304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21305 if (!SWIG_IsOK(res1)) {
21306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21307 }
21308 arg1 = reinterpret_cast< wxEvent * >(argp1);
21309 {
21310 PyThreadState* __tstate = wxPyBeginAllowThreads();
21311 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 resultobj = SWIG_From_long(static_cast< long >(result));
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj = 0;
21324 wxEvent *arg1 = (wxEvent *) 0 ;
21325 long arg2 = (long) 0 ;
21326 void *argp1 = 0 ;
21327 int res1 = 0 ;
21328 long val2 ;
21329 int ecode2 = 0 ;
21330 PyObject * obj0 = 0 ;
21331 PyObject * obj1 = 0 ;
21332 char * kwnames[] = {
21333 (char *) "self",(char *) "ts", NULL
21334 };
21335
21336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21338 if (!SWIG_IsOK(res1)) {
21339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21340 }
21341 arg1 = reinterpret_cast< wxEvent * >(argp1);
21342 if (obj1) {
21343 ecode2 = SWIG_AsVal_long(obj1, &val2);
21344 if (!SWIG_IsOK(ecode2)) {
21345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21346 }
21347 arg2 = static_cast< long >(val2);
21348 }
21349 {
21350 PyThreadState* __tstate = wxPyBeginAllowThreads();
21351 (arg1)->SetTimestamp(arg2);
21352 wxPyEndAllowThreads(__tstate);
21353 if (PyErr_Occurred()) SWIG_fail;
21354 }
21355 resultobj = SWIG_Py_Void();
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21363 PyObject *resultobj = 0;
21364 wxEvent *arg1 = (wxEvent *) 0 ;
21365 int result;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 PyObject *swig_obj[1] ;
21369
21370 if (!args) SWIG_fail;
21371 swig_obj[0] = args;
21372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21375 }
21376 arg1 = reinterpret_cast< wxEvent * >(argp1);
21377 {
21378 PyThreadState* __tstate = wxPyBeginAllowThreads();
21379 result = (int)((wxEvent const *)arg1)->GetId();
21380 wxPyEndAllowThreads(__tstate);
21381 if (PyErr_Occurred()) SWIG_fail;
21382 }
21383 resultobj = SWIG_From_int(static_cast< int >(result));
21384 return resultobj;
21385 fail:
21386 return NULL;
21387 }
21388
21389
21390 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21391 PyObject *resultobj = 0;
21392 wxEvent *arg1 = (wxEvent *) 0 ;
21393 int arg2 ;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 int val2 ;
21397 int ecode2 = 0 ;
21398 PyObject * obj0 = 0 ;
21399 PyObject * obj1 = 0 ;
21400 char * kwnames[] = {
21401 (char *) "self",(char *) "Id", NULL
21402 };
21403
21404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21408 }
21409 arg1 = reinterpret_cast< wxEvent * >(argp1);
21410 ecode2 = SWIG_AsVal_int(obj1, &val2);
21411 if (!SWIG_IsOK(ecode2)) {
21412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21413 }
21414 arg2 = static_cast< int >(val2);
21415 {
21416 PyThreadState* __tstate = wxPyBeginAllowThreads();
21417 (arg1)->SetId(arg2);
21418 wxPyEndAllowThreads(__tstate);
21419 if (PyErr_Occurred()) SWIG_fail;
21420 }
21421 resultobj = SWIG_Py_Void();
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxEvent *arg1 = (wxEvent *) 0 ;
21431 bool result;
21432 void *argp1 = 0 ;
21433 int res1 = 0 ;
21434 PyObject *swig_obj[1] ;
21435
21436 if (!args) SWIG_fail;
21437 swig_obj[0] = args;
21438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21439 if (!SWIG_IsOK(res1)) {
21440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21441 }
21442 arg1 = reinterpret_cast< wxEvent * >(argp1);
21443 {
21444 PyThreadState* __tstate = wxPyBeginAllowThreads();
21445 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21446 wxPyEndAllowThreads(__tstate);
21447 if (PyErr_Occurred()) SWIG_fail;
21448 }
21449 {
21450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21451 }
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21459 PyObject *resultobj = 0;
21460 wxEvent *arg1 = (wxEvent *) 0 ;
21461 bool arg2 = (bool) true ;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 bool val2 ;
21465 int ecode2 = 0 ;
21466 PyObject * obj0 = 0 ;
21467 PyObject * obj1 = 0 ;
21468 char * kwnames[] = {
21469 (char *) "self",(char *) "skip", NULL
21470 };
21471
21472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21474 if (!SWIG_IsOK(res1)) {
21475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21476 }
21477 arg1 = reinterpret_cast< wxEvent * >(argp1);
21478 if (obj1) {
21479 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21480 if (!SWIG_IsOK(ecode2)) {
21481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21482 }
21483 arg2 = static_cast< bool >(val2);
21484 }
21485 {
21486 PyThreadState* __tstate = wxPyBeginAllowThreads();
21487 (arg1)->Skip(arg2);
21488 wxPyEndAllowThreads(__tstate);
21489 if (PyErr_Occurred()) SWIG_fail;
21490 }
21491 resultobj = SWIG_Py_Void();
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21499 PyObject *resultobj = 0;
21500 wxEvent *arg1 = (wxEvent *) 0 ;
21501 bool result;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 PyObject *swig_obj[1] ;
21505
21506 if (!args) SWIG_fail;
21507 swig_obj[0] = args;
21508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21511 }
21512 arg1 = reinterpret_cast< wxEvent * >(argp1);
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21516 wxPyEndAllowThreads(__tstate);
21517 if (PyErr_Occurred()) SWIG_fail;
21518 }
21519 {
21520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21521 }
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 PyObject *resultobj = 0;
21530 wxEvent *arg1 = (wxEvent *) 0 ;
21531 bool result;
21532 void *argp1 = 0 ;
21533 int res1 = 0 ;
21534 PyObject *swig_obj[1] ;
21535
21536 if (!args) SWIG_fail;
21537 swig_obj[0] = args;
21538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21541 }
21542 arg1 = reinterpret_cast< wxEvent * >(argp1);
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21546 wxPyEndAllowThreads(__tstate);
21547 if (PyErr_Occurred()) SWIG_fail;
21548 }
21549 {
21550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21551 }
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxEvent *arg1 = (wxEvent *) 0 ;
21561 int result;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 PyObject *swig_obj[1] ;
21565
21566 if (!args) SWIG_fail;
21567 swig_obj[0] = args;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21571 }
21572 arg1 = reinterpret_cast< wxEvent * >(argp1);
21573 {
21574 PyThreadState* __tstate = wxPyBeginAllowThreads();
21575 result = (int)(arg1)->StopPropagation();
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 resultobj = SWIG_From_int(static_cast< int >(result));
21580 return resultobj;
21581 fail:
21582 return NULL;
21583 }
21584
21585
21586 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21587 PyObject *resultobj = 0;
21588 wxEvent *arg1 = (wxEvent *) 0 ;
21589 int arg2 ;
21590 void *argp1 = 0 ;
21591 int res1 = 0 ;
21592 int val2 ;
21593 int ecode2 = 0 ;
21594 PyObject * obj0 = 0 ;
21595 PyObject * obj1 = 0 ;
21596 char * kwnames[] = {
21597 (char *) "self",(char *) "propagationLevel", NULL
21598 };
21599
21600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21602 if (!SWIG_IsOK(res1)) {
21603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21604 }
21605 arg1 = reinterpret_cast< wxEvent * >(argp1);
21606 ecode2 = SWIG_AsVal_int(obj1, &val2);
21607 if (!SWIG_IsOK(ecode2)) {
21608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21609 }
21610 arg2 = static_cast< int >(val2);
21611 {
21612 PyThreadState* __tstate = wxPyBeginAllowThreads();
21613 (arg1)->ResumePropagation(arg2);
21614 wxPyEndAllowThreads(__tstate);
21615 if (PyErr_Occurred()) SWIG_fail;
21616 }
21617 resultobj = SWIG_Py_Void();
21618 return resultobj;
21619 fail:
21620 return NULL;
21621 }
21622
21623
21624 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21625 PyObject *resultobj = 0;
21626 wxEvent *arg1 = (wxEvent *) 0 ;
21627 wxEvent *result = 0 ;
21628 void *argp1 = 0 ;
21629 int res1 = 0 ;
21630 PyObject *swig_obj[1] ;
21631
21632 if (!args) SWIG_fail;
21633 swig_obj[0] = args;
21634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21637 }
21638 arg1 = reinterpret_cast< wxEvent * >(argp1);
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 result = (wxEvent *)(arg1)->Clone();
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21646 return resultobj;
21647 fail:
21648 return NULL;
21649 }
21650
21651
21652 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21653 PyObject *obj;
21654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21655 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21656 return SWIG_Py_Void();
21657 }
21658
21659 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21660 PyObject *resultobj = 0;
21661 wxEvent *arg1 = 0 ;
21662 wxPropagationDisabler *result = 0 ;
21663 void *argp1 = 0 ;
21664 int res1 = 0 ;
21665 PyObject * obj0 = 0 ;
21666 char * kwnames[] = {
21667 (char *) "event", NULL
21668 };
21669
21670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21671 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21672 if (!SWIG_IsOK(res1)) {
21673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21674 }
21675 if (!argp1) {
21676 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21677 }
21678 arg1 = reinterpret_cast< wxEvent * >(argp1);
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21682 wxPyEndAllowThreads(__tstate);
21683 if (PyErr_Occurred()) SWIG_fail;
21684 }
21685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21686 return resultobj;
21687 fail:
21688 return NULL;
21689 }
21690
21691
21692 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21693 PyObject *resultobj = 0;
21694 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21695 void *argp1 = 0 ;
21696 int res1 = 0 ;
21697 PyObject *swig_obj[1] ;
21698
21699 if (!args) SWIG_fail;
21700 swig_obj[0] = args;
21701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21702 if (!SWIG_IsOK(res1)) {
21703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21704 }
21705 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21706 {
21707 PyThreadState* __tstate = wxPyBeginAllowThreads();
21708 delete arg1;
21709
21710 wxPyEndAllowThreads(__tstate);
21711 if (PyErr_Occurred()) SWIG_fail;
21712 }
21713 resultobj = SWIG_Py_Void();
21714 return resultobj;
21715 fail:
21716 return NULL;
21717 }
21718
21719
21720 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21721 PyObject *obj;
21722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21723 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21724 return SWIG_Py_Void();
21725 }
21726
21727 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21728 return SWIG_Python_InitShadowInstance(args);
21729 }
21730
21731 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21732 PyObject *resultobj = 0;
21733 wxEvent *arg1 = 0 ;
21734 wxPropagateOnce *result = 0 ;
21735 void *argp1 = 0 ;
21736 int res1 = 0 ;
21737 PyObject * obj0 = 0 ;
21738 char * kwnames[] = {
21739 (char *) "event", NULL
21740 };
21741
21742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21743 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21744 if (!SWIG_IsOK(res1)) {
21745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21746 }
21747 if (!argp1) {
21748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21749 }
21750 arg1 = reinterpret_cast< wxEvent * >(argp1);
21751 {
21752 PyThreadState* __tstate = wxPyBeginAllowThreads();
21753 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21754 wxPyEndAllowThreads(__tstate);
21755 if (PyErr_Occurred()) SWIG_fail;
21756 }
21757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21758 return resultobj;
21759 fail:
21760 return NULL;
21761 }
21762
21763
21764 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21765 PyObject *resultobj = 0;
21766 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21767 void *argp1 = 0 ;
21768 int res1 = 0 ;
21769 PyObject *swig_obj[1] ;
21770
21771 if (!args) SWIG_fail;
21772 swig_obj[0] = args;
21773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21774 if (!SWIG_IsOK(res1)) {
21775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21776 }
21777 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21778 {
21779 PyThreadState* __tstate = wxPyBeginAllowThreads();
21780 delete arg1;
21781
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 resultobj = SWIG_Py_Void();
21786 return resultobj;
21787 fail:
21788 return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21793 PyObject *obj;
21794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21795 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21796 return SWIG_Py_Void();
21797 }
21798
21799 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21800 return SWIG_Python_InitShadowInstance(args);
21801 }
21802
21803 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21804 PyObject *resultobj = 0;
21805 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21806 int arg2 = (int) 0 ;
21807 wxCommandEvent *result = 0 ;
21808 int val1 ;
21809 int ecode1 = 0 ;
21810 int val2 ;
21811 int ecode2 = 0 ;
21812 PyObject * obj0 = 0 ;
21813 PyObject * obj1 = 0 ;
21814 char * kwnames[] = {
21815 (char *) "commandType",(char *) "winid", NULL
21816 };
21817
21818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21819 if (obj0) {
21820 ecode1 = SWIG_AsVal_int(obj0, &val1);
21821 if (!SWIG_IsOK(ecode1)) {
21822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21823 }
21824 arg1 = static_cast< wxEventType >(val1);
21825 }
21826 if (obj1) {
21827 ecode2 = SWIG_AsVal_int(obj1, &val2);
21828 if (!SWIG_IsOK(ecode2)) {
21829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21830 }
21831 arg2 = static_cast< int >(val2);
21832 }
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21836 wxPyEndAllowThreads(__tstate);
21837 if (PyErr_Occurred()) SWIG_fail;
21838 }
21839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21847 PyObject *resultobj = 0;
21848 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21849 int result;
21850 void *argp1 = 0 ;
21851 int res1 = 0 ;
21852 PyObject *swig_obj[1] ;
21853
21854 if (!args) SWIG_fail;
21855 swig_obj[0] = args;
21856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21857 if (!SWIG_IsOK(res1)) {
21858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21859 }
21860 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 resultobj = SWIG_From_int(static_cast< int >(result));
21868 return resultobj;
21869 fail:
21870 return NULL;
21871 }
21872
21873
21874 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21875 PyObject *resultobj = 0;
21876 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21877 wxString *arg2 = 0 ;
21878 void *argp1 = 0 ;
21879 int res1 = 0 ;
21880 bool temp2 = false ;
21881 PyObject * obj0 = 0 ;
21882 PyObject * obj1 = 0 ;
21883 char * kwnames[] = {
21884 (char *) "self",(char *) "s", NULL
21885 };
21886
21887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21889 if (!SWIG_IsOK(res1)) {
21890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21891 }
21892 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21893 {
21894 arg2 = wxString_in_helper(obj1);
21895 if (arg2 == NULL) SWIG_fail;
21896 temp2 = true;
21897 }
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 (arg1)->SetString((wxString const &)*arg2);
21901 wxPyEndAllowThreads(__tstate);
21902 if (PyErr_Occurred()) SWIG_fail;
21903 }
21904 resultobj = SWIG_Py_Void();
21905 {
21906 if (temp2)
21907 delete arg2;
21908 }
21909 return resultobj;
21910 fail:
21911 {
21912 if (temp2)
21913 delete arg2;
21914 }
21915 return NULL;
21916 }
21917
21918
21919 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21920 PyObject *resultobj = 0;
21921 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21922 wxString result;
21923 void *argp1 = 0 ;
21924 int res1 = 0 ;
21925 PyObject *swig_obj[1] ;
21926
21927 if (!args) SWIG_fail;
21928 swig_obj[0] = args;
21929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21930 if (!SWIG_IsOK(res1)) {
21931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21932 }
21933 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = ((wxCommandEvent const *)arg1)->GetString();
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 {
21941 #if wxUSE_UNICODE
21942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21943 #else
21944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21945 #endif
21946 }
21947 return resultobj;
21948 fail:
21949 return NULL;
21950 }
21951
21952
21953 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21954 PyObject *resultobj = 0;
21955 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21956 bool result;
21957 void *argp1 = 0 ;
21958 int res1 = 0 ;
21959 PyObject *swig_obj[1] ;
21960
21961 if (!args) SWIG_fail;
21962 swig_obj[0] = args;
21963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21964 if (!SWIG_IsOK(res1)) {
21965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21966 }
21967 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21968 {
21969 PyThreadState* __tstate = wxPyBeginAllowThreads();
21970 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21971 wxPyEndAllowThreads(__tstate);
21972 if (PyErr_Occurred()) SWIG_fail;
21973 }
21974 {
21975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21976 }
21977 return resultobj;
21978 fail:
21979 return NULL;
21980 }
21981
21982
21983 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21984 PyObject *resultobj = 0;
21985 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21986 bool result;
21987 void *argp1 = 0 ;
21988 int res1 = 0 ;
21989 PyObject *swig_obj[1] ;
21990
21991 if (!args) SWIG_fail;
21992 swig_obj[0] = args;
21993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21994 if (!SWIG_IsOK(res1)) {
21995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21996 }
21997 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21998 {
21999 PyThreadState* __tstate = wxPyBeginAllowThreads();
22000 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22001 wxPyEndAllowThreads(__tstate);
22002 if (PyErr_Occurred()) SWIG_fail;
22003 }
22004 {
22005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22006 }
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22014 PyObject *resultobj = 0;
22015 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22016 long arg2 ;
22017 void *argp1 = 0 ;
22018 int res1 = 0 ;
22019 long val2 ;
22020 int ecode2 = 0 ;
22021 PyObject * obj0 = 0 ;
22022 PyObject * obj1 = 0 ;
22023 char * kwnames[] = {
22024 (char *) "self",(char *) "extraLong", NULL
22025 };
22026
22027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22029 if (!SWIG_IsOK(res1)) {
22030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22031 }
22032 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22033 ecode2 = SWIG_AsVal_long(obj1, &val2);
22034 if (!SWIG_IsOK(ecode2)) {
22035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22036 }
22037 arg2 = static_cast< long >(val2);
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 (arg1)->SetExtraLong(arg2);
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 resultobj = SWIG_Py_Void();
22045 return resultobj;
22046 fail:
22047 return NULL;
22048 }
22049
22050
22051 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22052 PyObject *resultobj = 0;
22053 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22054 long result;
22055 void *argp1 = 0 ;
22056 int res1 = 0 ;
22057 PyObject *swig_obj[1] ;
22058
22059 if (!args) SWIG_fail;
22060 swig_obj[0] = args;
22061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22062 if (!SWIG_IsOK(res1)) {
22063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22064 }
22065 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22066 {
22067 PyThreadState* __tstate = wxPyBeginAllowThreads();
22068 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22069 wxPyEndAllowThreads(__tstate);
22070 if (PyErr_Occurred()) SWIG_fail;
22071 }
22072 resultobj = SWIG_From_long(static_cast< long >(result));
22073 return resultobj;
22074 fail:
22075 return NULL;
22076 }
22077
22078
22079 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22080 PyObject *resultobj = 0;
22081 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22082 int arg2 ;
22083 void *argp1 = 0 ;
22084 int res1 = 0 ;
22085 int val2 ;
22086 int ecode2 = 0 ;
22087 PyObject * obj0 = 0 ;
22088 PyObject * obj1 = 0 ;
22089 char * kwnames[] = {
22090 (char *) "self",(char *) "i", NULL
22091 };
22092
22093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22097 }
22098 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22099 ecode2 = SWIG_AsVal_int(obj1, &val2);
22100 if (!SWIG_IsOK(ecode2)) {
22101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22102 }
22103 arg2 = static_cast< int >(val2);
22104 {
22105 PyThreadState* __tstate = wxPyBeginAllowThreads();
22106 (arg1)->SetInt(arg2);
22107 wxPyEndAllowThreads(__tstate);
22108 if (PyErr_Occurred()) SWIG_fail;
22109 }
22110 resultobj = SWIG_Py_Void();
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22118 PyObject *resultobj = 0;
22119 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22120 int 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_wxCommandEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22130 }
22131 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 resultobj = SWIG_From_int(static_cast< int >(result));
22139 return resultobj;
22140 fail:
22141 return NULL;
22142 }
22143
22144
22145 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22146 PyObject *resultobj = 0;
22147 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22148 PyObject *result = 0 ;
22149 void *argp1 = 0 ;
22150 int res1 = 0 ;
22151 PyObject *swig_obj[1] ;
22152
22153 if (!args) SWIG_fail;
22154 swig_obj[0] = args;
22155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22156 if (!SWIG_IsOK(res1)) {
22157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22158 }
22159 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22160 {
22161 PyThreadState* __tstate = wxPyBeginAllowThreads();
22162 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22163 wxPyEndAllowThreads(__tstate);
22164 if (PyErr_Occurred()) SWIG_fail;
22165 }
22166 resultobj = result;
22167 return resultobj;
22168 fail:
22169 return NULL;
22170 }
22171
22172
22173 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22174 PyObject *resultobj = 0;
22175 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22176 PyObject *arg2 = (PyObject *) 0 ;
22177 void *argp1 = 0 ;
22178 int res1 = 0 ;
22179 PyObject * obj0 = 0 ;
22180 PyObject * obj1 = 0 ;
22181 char * kwnames[] = {
22182 (char *) "self",(char *) "clientData", NULL
22183 };
22184
22185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22187 if (!SWIG_IsOK(res1)) {
22188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22189 }
22190 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22191 arg2 = obj1;
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 wxCommandEvent_SetClientData(arg1,arg2);
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 resultobj = SWIG_Py_Void();
22199 return resultobj;
22200 fail:
22201 return NULL;
22202 }
22203
22204
22205 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22206 PyObject *resultobj = 0;
22207 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22208 wxEvent *result = 0 ;
22209 void *argp1 = 0 ;
22210 int res1 = 0 ;
22211 PyObject *swig_obj[1] ;
22212
22213 if (!args) SWIG_fail;
22214 swig_obj[0] = args;
22215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22216 if (!SWIG_IsOK(res1)) {
22217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22218 }
22219 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22234 PyObject *obj;
22235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22236 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22237 return SWIG_Py_Void();
22238 }
22239
22240 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22241 return SWIG_Python_InitShadowInstance(args);
22242 }
22243
22244 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22245 PyObject *resultobj = 0;
22246 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22247 int arg2 = (int) 0 ;
22248 wxNotifyEvent *result = 0 ;
22249 int val1 ;
22250 int ecode1 = 0 ;
22251 int val2 ;
22252 int ecode2 = 0 ;
22253 PyObject * obj0 = 0 ;
22254 PyObject * obj1 = 0 ;
22255 char * kwnames[] = {
22256 (char *) "commandType",(char *) "winid", NULL
22257 };
22258
22259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22260 if (obj0) {
22261 ecode1 = SWIG_AsVal_int(obj0, &val1);
22262 if (!SWIG_IsOK(ecode1)) {
22263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22264 }
22265 arg1 = static_cast< wxEventType >(val1);
22266 }
22267 if (obj1) {
22268 ecode2 = SWIG_AsVal_int(obj1, &val2);
22269 if (!SWIG_IsOK(ecode2)) {
22270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22271 }
22272 arg2 = static_cast< int >(val2);
22273 }
22274 {
22275 PyThreadState* __tstate = wxPyBeginAllowThreads();
22276 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22277 wxPyEndAllowThreads(__tstate);
22278 if (PyErr_Occurred()) SWIG_fail;
22279 }
22280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22281 return resultobj;
22282 fail:
22283 return NULL;
22284 }
22285
22286
22287 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22288 PyObject *resultobj = 0;
22289 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 PyObject *swig_obj[1] ;
22293
22294 if (!args) SWIG_fail;
22295 swig_obj[0] = args;
22296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22297 if (!SWIG_IsOK(res1)) {
22298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22299 }
22300 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22301 {
22302 PyThreadState* __tstate = wxPyBeginAllowThreads();
22303 (arg1)->Veto();
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = SWIG_Py_Void();
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22315 PyObject *resultobj = 0;
22316 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22317 void *argp1 = 0 ;
22318 int res1 = 0 ;
22319 PyObject *swig_obj[1] ;
22320
22321 if (!args) SWIG_fail;
22322 swig_obj[0] = args;
22323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22324 if (!SWIG_IsOK(res1)) {
22325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22326 }
22327 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22328 {
22329 PyThreadState* __tstate = wxPyBeginAllowThreads();
22330 (arg1)->Allow();
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 resultobj = SWIG_Py_Void();
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22342 PyObject *resultobj = 0;
22343 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22344 bool result;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 PyObject *swig_obj[1] ;
22348
22349 if (!args) SWIG_fail;
22350 swig_obj[0] = args;
22351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22352 if (!SWIG_IsOK(res1)) {
22353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22354 }
22355 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22356 {
22357 PyThreadState* __tstate = wxPyBeginAllowThreads();
22358 result = (bool)(arg1)->IsAllowed();
22359 wxPyEndAllowThreads(__tstate);
22360 if (PyErr_Occurred()) SWIG_fail;
22361 }
22362 {
22363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22364 }
22365 return resultobj;
22366 fail:
22367 return NULL;
22368 }
22369
22370
22371 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22372 PyObject *obj;
22373 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22374 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22375 return SWIG_Py_Void();
22376 }
22377
22378 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22379 return SWIG_Python_InitShadowInstance(args);
22380 }
22381
22382 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22383 PyObject *resultobj = 0;
22384 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22385 int arg2 = (int) 0 ;
22386 int arg3 = (int) 0 ;
22387 int arg4 = (int) 0 ;
22388 wxScrollEvent *result = 0 ;
22389 int val1 ;
22390 int ecode1 = 0 ;
22391 int val2 ;
22392 int ecode2 = 0 ;
22393 int val3 ;
22394 int ecode3 = 0 ;
22395 int val4 ;
22396 int ecode4 = 0 ;
22397 PyObject * obj0 = 0 ;
22398 PyObject * obj1 = 0 ;
22399 PyObject * obj2 = 0 ;
22400 PyObject * obj3 = 0 ;
22401 char * kwnames[] = {
22402 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22403 };
22404
22405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22406 if (obj0) {
22407 ecode1 = SWIG_AsVal_int(obj0, &val1);
22408 if (!SWIG_IsOK(ecode1)) {
22409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22410 }
22411 arg1 = static_cast< wxEventType >(val1);
22412 }
22413 if (obj1) {
22414 ecode2 = SWIG_AsVal_int(obj1, &val2);
22415 if (!SWIG_IsOK(ecode2)) {
22416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22417 }
22418 arg2 = static_cast< int >(val2);
22419 }
22420 if (obj2) {
22421 ecode3 = SWIG_AsVal_int(obj2, &val3);
22422 if (!SWIG_IsOK(ecode3)) {
22423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22424 }
22425 arg3 = static_cast< int >(val3);
22426 }
22427 if (obj3) {
22428 ecode4 = SWIG_AsVal_int(obj3, &val4);
22429 if (!SWIG_IsOK(ecode4)) {
22430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22431 }
22432 arg4 = static_cast< int >(val4);
22433 }
22434 {
22435 PyThreadState* __tstate = wxPyBeginAllowThreads();
22436 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22437 wxPyEndAllowThreads(__tstate);
22438 if (PyErr_Occurred()) SWIG_fail;
22439 }
22440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22441 return resultobj;
22442 fail:
22443 return NULL;
22444 }
22445
22446
22447 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22448 PyObject *resultobj = 0;
22449 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22450 int result;
22451 void *argp1 = 0 ;
22452 int res1 = 0 ;
22453 PyObject *swig_obj[1] ;
22454
22455 if (!args) SWIG_fail;
22456 swig_obj[0] = args;
22457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22458 if (!SWIG_IsOK(res1)) {
22459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22460 }
22461 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22462 {
22463 PyThreadState* __tstate = wxPyBeginAllowThreads();
22464 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22465 wxPyEndAllowThreads(__tstate);
22466 if (PyErr_Occurred()) SWIG_fail;
22467 }
22468 resultobj = SWIG_From_int(static_cast< int >(result));
22469 return resultobj;
22470 fail:
22471 return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22476 PyObject *resultobj = 0;
22477 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22478 int result;
22479 void *argp1 = 0 ;
22480 int res1 = 0 ;
22481 PyObject *swig_obj[1] ;
22482
22483 if (!args) SWIG_fail;
22484 swig_obj[0] = args;
22485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22486 if (!SWIG_IsOK(res1)) {
22487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22488 }
22489 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 resultobj = SWIG_From_int(static_cast< int >(result));
22497 return resultobj;
22498 fail:
22499 return NULL;
22500 }
22501
22502
22503 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22504 PyObject *resultobj = 0;
22505 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22506 int arg2 ;
22507 void *argp1 = 0 ;
22508 int res1 = 0 ;
22509 int val2 ;
22510 int ecode2 = 0 ;
22511 PyObject * obj0 = 0 ;
22512 PyObject * obj1 = 0 ;
22513 char * kwnames[] = {
22514 (char *) "self",(char *) "orient", NULL
22515 };
22516
22517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22519 if (!SWIG_IsOK(res1)) {
22520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22521 }
22522 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22523 ecode2 = SWIG_AsVal_int(obj1, &val2);
22524 if (!SWIG_IsOK(ecode2)) {
22525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22526 }
22527 arg2 = static_cast< int >(val2);
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 (arg1)->SetOrientation(arg2);
22531 wxPyEndAllowThreads(__tstate);
22532 if (PyErr_Occurred()) SWIG_fail;
22533 }
22534 resultobj = SWIG_Py_Void();
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22542 PyObject *resultobj = 0;
22543 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22544 int arg2 ;
22545 void *argp1 = 0 ;
22546 int res1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 PyObject * obj0 = 0 ;
22550 PyObject * obj1 = 0 ;
22551 char * kwnames[] = {
22552 (char *) "self",(char *) "pos", NULL
22553 };
22554
22555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22557 if (!SWIG_IsOK(res1)) {
22558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22559 }
22560 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22561 ecode2 = SWIG_AsVal_int(obj1, &val2);
22562 if (!SWIG_IsOK(ecode2)) {
22563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22564 }
22565 arg2 = static_cast< int >(val2);
22566 {
22567 PyThreadState* __tstate = wxPyBeginAllowThreads();
22568 (arg1)->SetPosition(arg2);
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 resultobj = SWIG_Py_Void();
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *obj;
22581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22582 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22583 return SWIG_Py_Void();
22584 }
22585
22586 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22587 return SWIG_Python_InitShadowInstance(args);
22588 }
22589
22590 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj = 0;
22592 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22593 int arg2 = (int) 0 ;
22594 int arg3 = (int) 0 ;
22595 wxScrollWinEvent *result = 0 ;
22596 int val1 ;
22597 int ecode1 = 0 ;
22598 int val2 ;
22599 int ecode2 = 0 ;
22600 int val3 ;
22601 int ecode3 = 0 ;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604 PyObject * obj2 = 0 ;
22605 char * kwnames[] = {
22606 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22607 };
22608
22609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22610 if (obj0) {
22611 ecode1 = SWIG_AsVal_int(obj0, &val1);
22612 if (!SWIG_IsOK(ecode1)) {
22613 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22614 }
22615 arg1 = static_cast< wxEventType >(val1);
22616 }
22617 if (obj1) {
22618 ecode2 = SWIG_AsVal_int(obj1, &val2);
22619 if (!SWIG_IsOK(ecode2)) {
22620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22621 }
22622 arg2 = static_cast< int >(val2);
22623 }
22624 if (obj2) {
22625 ecode3 = SWIG_AsVal_int(obj2, &val3);
22626 if (!SWIG_IsOK(ecode3)) {
22627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22628 }
22629 arg3 = static_cast< int >(val3);
22630 }
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22634 wxPyEndAllowThreads(__tstate);
22635 if (PyErr_Occurred()) SWIG_fail;
22636 }
22637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22645 PyObject *resultobj = 0;
22646 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22647 int result;
22648 void *argp1 = 0 ;
22649 int res1 = 0 ;
22650 PyObject *swig_obj[1] ;
22651
22652 if (!args) SWIG_fail;
22653 swig_obj[0] = args;
22654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22655 if (!SWIG_IsOK(res1)) {
22656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22657 }
22658 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22659 {
22660 PyThreadState* __tstate = wxPyBeginAllowThreads();
22661 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22662 wxPyEndAllowThreads(__tstate);
22663 if (PyErr_Occurred()) SWIG_fail;
22664 }
22665 resultobj = SWIG_From_int(static_cast< int >(result));
22666 return resultobj;
22667 fail:
22668 return NULL;
22669 }
22670
22671
22672 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22673 PyObject *resultobj = 0;
22674 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22675 int result;
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_wxScrollWinEvent, 0 | 0 );
22683 if (!SWIG_IsOK(res1)) {
22684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22685 }
22686 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22687 {
22688 PyThreadState* __tstate = wxPyBeginAllowThreads();
22689 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22690 wxPyEndAllowThreads(__tstate);
22691 if (PyErr_Occurred()) SWIG_fail;
22692 }
22693 resultobj = SWIG_From_int(static_cast< int >(result));
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22701 PyObject *resultobj = 0;
22702 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22703 int arg2 ;
22704 void *argp1 = 0 ;
22705 int res1 = 0 ;
22706 int val2 ;
22707 int ecode2 = 0 ;
22708 PyObject * obj0 = 0 ;
22709 PyObject * obj1 = 0 ;
22710 char * kwnames[] = {
22711 (char *) "self",(char *) "orient", NULL
22712 };
22713
22714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22716 if (!SWIG_IsOK(res1)) {
22717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22718 }
22719 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22720 ecode2 = SWIG_AsVal_int(obj1, &val2);
22721 if (!SWIG_IsOK(ecode2)) {
22722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22723 }
22724 arg2 = static_cast< int >(val2);
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 (arg1)->SetOrientation(arg2);
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 resultobj = SWIG_Py_Void();
22732 return resultobj;
22733 fail:
22734 return NULL;
22735 }
22736
22737
22738 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22739 PyObject *resultobj = 0;
22740 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22741 int arg2 ;
22742 void *argp1 = 0 ;
22743 int res1 = 0 ;
22744 int val2 ;
22745 int ecode2 = 0 ;
22746 PyObject * obj0 = 0 ;
22747 PyObject * obj1 = 0 ;
22748 char * kwnames[] = {
22749 (char *) "self",(char *) "pos", NULL
22750 };
22751
22752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22754 if (!SWIG_IsOK(res1)) {
22755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22756 }
22757 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22758 ecode2 = SWIG_AsVal_int(obj1, &val2);
22759 if (!SWIG_IsOK(ecode2)) {
22760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22761 }
22762 arg2 = static_cast< int >(val2);
22763 {
22764 PyThreadState* __tstate = wxPyBeginAllowThreads();
22765 (arg1)->SetPosition(arg2);
22766 wxPyEndAllowThreads(__tstate);
22767 if (PyErr_Occurred()) SWIG_fail;
22768 }
22769 resultobj = SWIG_Py_Void();
22770 return resultobj;
22771 fail:
22772 return NULL;
22773 }
22774
22775
22776 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22777 PyObject *obj;
22778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22779 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22780 return SWIG_Py_Void();
22781 }
22782
22783 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 return SWIG_Python_InitShadowInstance(args);
22785 }
22786
22787 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj = 0;
22789 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22790 wxMouseEvent *result = 0 ;
22791 int val1 ;
22792 int ecode1 = 0 ;
22793 PyObject * obj0 = 0 ;
22794 char * kwnames[] = {
22795 (char *) "mouseType", NULL
22796 };
22797
22798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22799 if (obj0) {
22800 ecode1 = SWIG_AsVal_int(obj0, &val1);
22801 if (!SWIG_IsOK(ecode1)) {
22802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22803 }
22804 arg1 = static_cast< wxEventType >(val1);
22805 }
22806 {
22807 PyThreadState* __tstate = wxPyBeginAllowThreads();
22808 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22813 return resultobj;
22814 fail:
22815 return NULL;
22816 }
22817
22818
22819 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22820 PyObject *resultobj = 0;
22821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22822 bool result;
22823 void *argp1 = 0 ;
22824 int res1 = 0 ;
22825 PyObject *swig_obj[1] ;
22826
22827 if (!args) SWIG_fail;
22828 swig_obj[0] = args;
22829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22830 if (!SWIG_IsOK(res1)) {
22831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22832 }
22833 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22837 wxPyEndAllowThreads(__tstate);
22838 if (PyErr_Occurred()) SWIG_fail;
22839 }
22840 {
22841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22842 }
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22850 PyObject *resultobj = 0;
22851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22852 int arg2 = (int) wxMOUSE_BTN_ANY ;
22853 bool result;
22854 void *argp1 = 0 ;
22855 int res1 = 0 ;
22856 int val2 ;
22857 int ecode2 = 0 ;
22858 PyObject * obj0 = 0 ;
22859 PyObject * obj1 = 0 ;
22860 char * kwnames[] = {
22861 (char *) "self",(char *) "but", NULL
22862 };
22863
22864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22866 if (!SWIG_IsOK(res1)) {
22867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22868 }
22869 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22870 if (obj1) {
22871 ecode2 = SWIG_AsVal_int(obj1, &val2);
22872 if (!SWIG_IsOK(ecode2)) {
22873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22874 }
22875 arg2 = static_cast< int >(val2);
22876 }
22877 {
22878 PyThreadState* __tstate = wxPyBeginAllowThreads();
22879 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22880 wxPyEndAllowThreads(__tstate);
22881 if (PyErr_Occurred()) SWIG_fail;
22882 }
22883 {
22884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22885 }
22886 return resultobj;
22887 fail:
22888 return NULL;
22889 }
22890
22891
22892 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22893 PyObject *resultobj = 0;
22894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22895 int arg2 = (int) wxMOUSE_BTN_ANY ;
22896 bool result;
22897 void *argp1 = 0 ;
22898 int res1 = 0 ;
22899 int val2 ;
22900 int ecode2 = 0 ;
22901 PyObject * obj0 = 0 ;
22902 PyObject * obj1 = 0 ;
22903 char * kwnames[] = {
22904 (char *) "self",(char *) "but", NULL
22905 };
22906
22907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22911 }
22912 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22913 if (obj1) {
22914 ecode2 = SWIG_AsVal_int(obj1, &val2);
22915 if (!SWIG_IsOK(ecode2)) {
22916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22917 }
22918 arg2 = static_cast< int >(val2);
22919 }
22920 {
22921 PyThreadState* __tstate = wxPyBeginAllowThreads();
22922 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22923 wxPyEndAllowThreads(__tstate);
22924 if (PyErr_Occurred()) SWIG_fail;
22925 }
22926 {
22927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22928 }
22929 return resultobj;
22930 fail:
22931 return NULL;
22932 }
22933
22934
22935 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22936 PyObject *resultobj = 0;
22937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22938 int arg2 = (int) wxMOUSE_BTN_ANY ;
22939 bool result;
22940 void *argp1 = 0 ;
22941 int res1 = 0 ;
22942 int val2 ;
22943 int ecode2 = 0 ;
22944 PyObject * obj0 = 0 ;
22945 PyObject * obj1 = 0 ;
22946 char * kwnames[] = {
22947 (char *) "self",(char *) "but", NULL
22948 };
22949
22950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22952 if (!SWIG_IsOK(res1)) {
22953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22954 }
22955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22956 if (obj1) {
22957 ecode2 = SWIG_AsVal_int(obj1, &val2);
22958 if (!SWIG_IsOK(ecode2)) {
22959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22960 }
22961 arg2 = static_cast< int >(val2);
22962 }
22963 {
22964 PyThreadState* __tstate = wxPyBeginAllowThreads();
22965 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22966 wxPyEndAllowThreads(__tstate);
22967 if (PyErr_Occurred()) SWIG_fail;
22968 }
22969 {
22970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22971 }
22972 return resultobj;
22973 fail:
22974 return NULL;
22975 }
22976
22977
22978 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22979 PyObject *resultobj = 0;
22980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22981 int arg2 ;
22982 bool result;
22983 void *argp1 = 0 ;
22984 int res1 = 0 ;
22985 int val2 ;
22986 int ecode2 = 0 ;
22987 PyObject * obj0 = 0 ;
22988 PyObject * obj1 = 0 ;
22989 char * kwnames[] = {
22990 (char *) "self",(char *) "button", NULL
22991 };
22992
22993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22995 if (!SWIG_IsOK(res1)) {
22996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22997 }
22998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22999 ecode2 = SWIG_AsVal_int(obj1, &val2);
23000 if (!SWIG_IsOK(ecode2)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23002 }
23003 arg2 = static_cast< int >(val2);
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23007 wxPyEndAllowThreads(__tstate);
23008 if (PyErr_Occurred()) SWIG_fail;
23009 }
23010 {
23011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23012 }
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23020 PyObject *resultobj = 0;
23021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23022 int arg2 ;
23023 bool result;
23024 void *argp1 = 0 ;
23025 int res1 = 0 ;
23026 int val2 ;
23027 int ecode2 = 0 ;
23028 PyObject * obj0 = 0 ;
23029 PyObject * obj1 = 0 ;
23030 char * kwnames[] = {
23031 (char *) "self",(char *) "but", NULL
23032 };
23033
23034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23036 if (!SWIG_IsOK(res1)) {
23037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23038 }
23039 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23040 ecode2 = SWIG_AsVal_int(obj1, &val2);
23041 if (!SWIG_IsOK(ecode2)) {
23042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23043 }
23044 arg2 = static_cast< int >(val2);
23045 {
23046 PyThreadState* __tstate = wxPyBeginAllowThreads();
23047 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23048 wxPyEndAllowThreads(__tstate);
23049 if (PyErr_Occurred()) SWIG_fail;
23050 }
23051 {
23052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23053 }
23054 return resultobj;
23055 fail:
23056 return NULL;
23057 }
23058
23059
23060 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23061 PyObject *resultobj = 0;
23062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23063 int result;
23064 void *argp1 = 0 ;
23065 int res1 = 0 ;
23066 PyObject *swig_obj[1] ;
23067
23068 if (!args) SWIG_fail;
23069 swig_obj[0] = args;
23070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23071 if (!SWIG_IsOK(res1)) {
23072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23073 }
23074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23078 wxPyEndAllowThreads(__tstate);
23079 if (PyErr_Occurred()) SWIG_fail;
23080 }
23081 resultobj = SWIG_From_int(static_cast< int >(result));
23082 return resultobj;
23083 fail:
23084 return NULL;
23085 }
23086
23087
23088 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23089 PyObject *resultobj = 0;
23090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23091 bool result;
23092 void *argp1 = 0 ;
23093 int res1 = 0 ;
23094 PyObject *swig_obj[1] ;
23095
23096 if (!args) SWIG_fail;
23097 swig_obj[0] = args;
23098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23099 if (!SWIG_IsOK(res1)) {
23100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23101 }
23102 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23103 {
23104 PyThreadState* __tstate = wxPyBeginAllowThreads();
23105 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23106 wxPyEndAllowThreads(__tstate);
23107 if (PyErr_Occurred()) SWIG_fail;
23108 }
23109 {
23110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23111 }
23112 return resultobj;
23113 fail:
23114 return NULL;
23115 }
23116
23117
23118 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23119 PyObject *resultobj = 0;
23120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23121 bool result;
23122 void *argp1 = 0 ;
23123 int res1 = 0 ;
23124 PyObject *swig_obj[1] ;
23125
23126 if (!args) SWIG_fail;
23127 swig_obj[0] = args;
23128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23129 if (!SWIG_IsOK(res1)) {
23130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23131 }
23132 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23133 {
23134 PyThreadState* __tstate = wxPyBeginAllowThreads();
23135 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23136 wxPyEndAllowThreads(__tstate);
23137 if (PyErr_Occurred()) SWIG_fail;
23138 }
23139 {
23140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23141 }
23142 return resultobj;
23143 fail:
23144 return NULL;
23145 }
23146
23147
23148 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23149 PyObject *resultobj = 0;
23150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23151 bool result;
23152 void *argp1 = 0 ;
23153 int res1 = 0 ;
23154 PyObject *swig_obj[1] ;
23155
23156 if (!args) SWIG_fail;
23157 swig_obj[0] = args;
23158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23159 if (!SWIG_IsOK(res1)) {
23160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23161 }
23162 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23163 {
23164 PyThreadState* __tstate = wxPyBeginAllowThreads();
23165 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23166 wxPyEndAllowThreads(__tstate);
23167 if (PyErr_Occurred()) SWIG_fail;
23168 }
23169 {
23170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23171 }
23172 return resultobj;
23173 fail:
23174 return NULL;
23175 }
23176
23177
23178 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23179 PyObject *resultobj = 0;
23180 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23181 bool result;
23182 void *argp1 = 0 ;
23183 int res1 = 0 ;
23184 PyObject *swig_obj[1] ;
23185
23186 if (!args) SWIG_fail;
23187 swig_obj[0] = args;
23188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23189 if (!SWIG_IsOK(res1)) {
23190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23191 }
23192 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23193 {
23194 PyThreadState* __tstate = wxPyBeginAllowThreads();
23195 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23196 wxPyEndAllowThreads(__tstate);
23197 if (PyErr_Occurred()) SWIG_fail;
23198 }
23199 {
23200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23201 }
23202 return resultobj;
23203 fail:
23204 return NULL;
23205 }
23206
23207
23208 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23209 PyObject *resultobj = 0;
23210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23211 bool result;
23212 void *argp1 = 0 ;
23213 int res1 = 0 ;
23214 PyObject *swig_obj[1] ;
23215
23216 if (!args) SWIG_fail;
23217 swig_obj[0] = args;
23218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23219 if (!SWIG_IsOK(res1)) {
23220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23221 }
23222 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23223 {
23224 PyThreadState* __tstate = wxPyBeginAllowThreads();
23225 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23226 wxPyEndAllowThreads(__tstate);
23227 if (PyErr_Occurred()) SWIG_fail;
23228 }
23229 {
23230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23231 }
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23239 PyObject *resultobj = 0;
23240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23241 bool result;
23242 void *argp1 = 0 ;
23243 int res1 = 0 ;
23244 PyObject *swig_obj[1] ;
23245
23246 if (!args) SWIG_fail;
23247 swig_obj[0] = args;
23248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23249 if (!SWIG_IsOK(res1)) {
23250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23251 }
23252 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 {
23260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23261 }
23262 return resultobj;
23263 fail:
23264 return NULL;
23265 }
23266
23267
23268 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23269 PyObject *resultobj = 0;
23270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23271 bool result;
23272 void *argp1 = 0 ;
23273 int res1 = 0 ;
23274 PyObject *swig_obj[1] ;
23275
23276 if (!args) SWIG_fail;
23277 swig_obj[0] = args;
23278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23279 if (!SWIG_IsOK(res1)) {
23280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23281 }
23282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23283 {
23284 PyThreadState* __tstate = wxPyBeginAllowThreads();
23285 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23286 wxPyEndAllowThreads(__tstate);
23287 if (PyErr_Occurred()) SWIG_fail;
23288 }
23289 {
23290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23291 }
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23299 PyObject *resultobj = 0;
23300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23301 bool 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_wxMouseEvent, 0 | 0 );
23309 if (!SWIG_IsOK(res1)) {
23310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23311 }
23312 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23313 {
23314 PyThreadState* __tstate = wxPyBeginAllowThreads();
23315 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23316 wxPyEndAllowThreads(__tstate);
23317 if (PyErr_Occurred()) SWIG_fail;
23318 }
23319 {
23320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23321 }
23322 return resultobj;
23323 fail:
23324 return NULL;
23325 }
23326
23327
23328 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23329 PyObject *resultobj = 0;
23330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23331 bool result;
23332 void *argp1 = 0 ;
23333 int res1 = 0 ;
23334 PyObject *swig_obj[1] ;
23335
23336 if (!args) SWIG_fail;
23337 swig_obj[0] = args;
23338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23339 if (!SWIG_IsOK(res1)) {
23340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23341 }
23342 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23346 wxPyEndAllowThreads(__tstate);
23347 if (PyErr_Occurred()) SWIG_fail;
23348 }
23349 {
23350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23351 }
23352 return resultobj;
23353 fail:
23354 return NULL;
23355 }
23356
23357
23358 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23359 PyObject *resultobj = 0;
23360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23361 bool result;
23362 void *argp1 = 0 ;
23363 int res1 = 0 ;
23364 PyObject *swig_obj[1] ;
23365
23366 if (!args) SWIG_fail;
23367 swig_obj[0] = args;
23368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23369 if (!SWIG_IsOK(res1)) {
23370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23371 }
23372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23373 {
23374 PyThreadState* __tstate = wxPyBeginAllowThreads();
23375 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23376 wxPyEndAllowThreads(__tstate);
23377 if (PyErr_Occurred()) SWIG_fail;
23378 }
23379 {
23380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23381 }
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23389 PyObject *resultobj = 0;
23390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23391 bool result;
23392 void *argp1 = 0 ;
23393 int res1 = 0 ;
23394 PyObject *swig_obj[1] ;
23395
23396 if (!args) SWIG_fail;
23397 swig_obj[0] = args;
23398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23399 if (!SWIG_IsOK(res1)) {
23400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23401 }
23402 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 {
23410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23411 }
23412 return resultobj;
23413 fail:
23414 return NULL;
23415 }
23416
23417
23418 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23419 PyObject *resultobj = 0;
23420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23421 bool result;
23422 void *argp1 = 0 ;
23423 int res1 = 0 ;
23424 PyObject *swig_obj[1] ;
23425
23426 if (!args) SWIG_fail;
23427 swig_obj[0] = args;
23428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23429 if (!SWIG_IsOK(res1)) {
23430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23431 }
23432 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23433 {
23434 PyThreadState* __tstate = wxPyBeginAllowThreads();
23435 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23436 wxPyEndAllowThreads(__tstate);
23437 if (PyErr_Occurred()) SWIG_fail;
23438 }
23439 {
23440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23441 }
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23449 PyObject *resultobj = 0;
23450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23451 bool result;
23452 void *argp1 = 0 ;
23453 int res1 = 0 ;
23454 PyObject *swig_obj[1] ;
23455
23456 if (!args) SWIG_fail;
23457 swig_obj[0] = args;
23458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23459 if (!SWIG_IsOK(res1)) {
23460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23461 }
23462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23463 {
23464 PyThreadState* __tstate = wxPyBeginAllowThreads();
23465 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23466 wxPyEndAllowThreads(__tstate);
23467 if (PyErr_Occurred()) SWIG_fail;
23468 }
23469 {
23470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23471 }
23472 return resultobj;
23473 fail:
23474 return NULL;
23475 }
23476
23477
23478 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23479 PyObject *resultobj = 0;
23480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23481 bool result;
23482 void *argp1 = 0 ;
23483 int res1 = 0 ;
23484 PyObject *swig_obj[1] ;
23485
23486 if (!args) SWIG_fail;
23487 swig_obj[0] = args;
23488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23489 if (!SWIG_IsOK(res1)) {
23490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23491 }
23492 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 {
23500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23501 }
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23509 PyObject *resultobj = 0;
23510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23511 bool result;
23512 void *argp1 = 0 ;
23513 int res1 = 0 ;
23514 PyObject *swig_obj[1] ;
23515
23516 if (!args) SWIG_fail;
23517 swig_obj[0] = args;
23518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23519 if (!SWIG_IsOK(res1)) {
23520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23521 }
23522 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23523 {
23524 PyThreadState* __tstate = wxPyBeginAllowThreads();
23525 result = (bool)(arg1)->LeftIsDown();
23526 wxPyEndAllowThreads(__tstate);
23527 if (PyErr_Occurred()) SWIG_fail;
23528 }
23529 {
23530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23531 }
23532 return resultobj;
23533 fail:
23534 return NULL;
23535 }
23536
23537
23538 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23539 PyObject *resultobj = 0;
23540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23541 bool result;
23542 void *argp1 = 0 ;
23543 int res1 = 0 ;
23544 PyObject *swig_obj[1] ;
23545
23546 if (!args) SWIG_fail;
23547 swig_obj[0] = args;
23548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23549 if (!SWIG_IsOK(res1)) {
23550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23551 }
23552 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23553 {
23554 PyThreadState* __tstate = wxPyBeginAllowThreads();
23555 result = (bool)(arg1)->MiddleIsDown();
23556 wxPyEndAllowThreads(__tstate);
23557 if (PyErr_Occurred()) SWIG_fail;
23558 }
23559 {
23560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23561 }
23562 return resultobj;
23563 fail:
23564 return NULL;
23565 }
23566
23567
23568 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23569 PyObject *resultobj = 0;
23570 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23571 bool result;
23572 void *argp1 = 0 ;
23573 int res1 = 0 ;
23574 PyObject *swig_obj[1] ;
23575
23576 if (!args) SWIG_fail;
23577 swig_obj[0] = args;
23578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23579 if (!SWIG_IsOK(res1)) {
23580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23581 }
23582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23583 {
23584 PyThreadState* __tstate = wxPyBeginAllowThreads();
23585 result = (bool)(arg1)->RightIsDown();
23586 wxPyEndAllowThreads(__tstate);
23587 if (PyErr_Occurred()) SWIG_fail;
23588 }
23589 {
23590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23591 }
23592 return resultobj;
23593 fail:
23594 return NULL;
23595 }
23596
23597
23598 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23599 PyObject *resultobj = 0;
23600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23601 bool result;
23602 void *argp1 = 0 ;
23603 int res1 = 0 ;
23604 PyObject *swig_obj[1] ;
23605
23606 if (!args) SWIG_fail;
23607 swig_obj[0] = args;
23608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23609 if (!SWIG_IsOK(res1)) {
23610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23611 }
23612 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23613 {
23614 PyThreadState* __tstate = wxPyBeginAllowThreads();
23615 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 {
23620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23621 }
23622 return resultobj;
23623 fail:
23624 return NULL;
23625 }
23626
23627
23628 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23629 PyObject *resultobj = 0;
23630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23631 bool result;
23632 void *argp1 = 0 ;
23633 int res1 = 0 ;
23634 PyObject *swig_obj[1] ;
23635
23636 if (!args) SWIG_fail;
23637 swig_obj[0] = args;
23638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23639 if (!SWIG_IsOK(res1)) {
23640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23641 }
23642 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23643 {
23644 PyThreadState* __tstate = wxPyBeginAllowThreads();
23645 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23646 wxPyEndAllowThreads(__tstate);
23647 if (PyErr_Occurred()) SWIG_fail;
23648 }
23649 {
23650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23651 }
23652 return resultobj;
23653 fail:
23654 return NULL;
23655 }
23656
23657
23658 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23659 PyObject *resultobj = 0;
23660 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23661 bool result;
23662 void *argp1 = 0 ;
23663 int res1 = 0 ;
23664 PyObject *swig_obj[1] ;
23665
23666 if (!args) SWIG_fail;
23667 swig_obj[0] = args;
23668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23669 if (!SWIG_IsOK(res1)) {
23670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23671 }
23672 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23673 {
23674 PyThreadState* __tstate = wxPyBeginAllowThreads();
23675 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 {
23680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23681 }
23682 return resultobj;
23683 fail:
23684 return NULL;
23685 }
23686
23687
23688 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23689 PyObject *resultobj = 0;
23690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23691 bool result;
23692 void *argp1 = 0 ;
23693 int res1 = 0 ;
23694 PyObject *swig_obj[1] ;
23695
23696 if (!args) SWIG_fail;
23697 swig_obj[0] = args;
23698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23699 if (!SWIG_IsOK(res1)) {
23700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23701 }
23702 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23703 {
23704 PyThreadState* __tstate = wxPyBeginAllowThreads();
23705 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 {
23710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23711 }
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23719 PyObject *resultobj = 0;
23720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23721 wxPoint result;
23722 void *argp1 = 0 ;
23723 int res1 = 0 ;
23724 PyObject *swig_obj[1] ;
23725
23726 if (!args) SWIG_fail;
23727 swig_obj[0] = args;
23728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23729 if (!SWIG_IsOK(res1)) {
23730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23731 }
23732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23733 {
23734 PyThreadState* __tstate = wxPyBeginAllowThreads();
23735 result = (arg1)->GetPosition();
23736 wxPyEndAllowThreads(__tstate);
23737 if (PyErr_Occurred()) SWIG_fail;
23738 }
23739 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23740 return resultobj;
23741 fail:
23742 return NULL;
23743 }
23744
23745
23746 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23747 PyObject *resultobj = 0;
23748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23749 long *arg2 = (long *) 0 ;
23750 long *arg3 = (long *) 0 ;
23751 void *argp1 = 0 ;
23752 int res1 = 0 ;
23753 long temp2 ;
23754 int res2 = SWIG_TMPOBJ ;
23755 long temp3 ;
23756 int res3 = SWIG_TMPOBJ ;
23757 PyObject *swig_obj[1] ;
23758
23759 arg2 = &temp2;
23760 arg3 = &temp3;
23761 if (!args) SWIG_fail;
23762 swig_obj[0] = args;
23763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23764 if (!SWIG_IsOK(res1)) {
23765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23766 }
23767 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 (arg1)->GetPosition(arg2,arg3);
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 resultobj = SWIG_Py_Void();
23775 if (SWIG_IsTmpObj(res2)) {
23776 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23777 } else {
23778 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23779 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23780 }
23781 if (SWIG_IsTmpObj(res3)) {
23782 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23783 } else {
23784 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23785 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23786 }
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23794 PyObject *resultobj = 0;
23795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23796 wxDC *arg2 = 0 ;
23797 wxPoint result;
23798 void *argp1 = 0 ;
23799 int res1 = 0 ;
23800 void *argp2 = 0 ;
23801 int res2 = 0 ;
23802 PyObject * obj0 = 0 ;
23803 PyObject * obj1 = 0 ;
23804 char * kwnames[] = {
23805 (char *) "self",(char *) "dc", NULL
23806 };
23807
23808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23810 if (!SWIG_IsOK(res1)) {
23811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23812 }
23813 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23814 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23815 if (!SWIG_IsOK(res2)) {
23816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23817 }
23818 if (!argp2) {
23819 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23820 }
23821 arg2 = reinterpret_cast< wxDC * >(argp2);
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23836 PyObject *resultobj = 0;
23837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23838 int result;
23839 void *argp1 = 0 ;
23840 int res1 = 0 ;
23841 PyObject *swig_obj[1] ;
23842
23843 if (!args) SWIG_fail;
23844 swig_obj[0] = args;
23845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23846 if (!SWIG_IsOK(res1)) {
23847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23848 }
23849 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23850 {
23851 PyThreadState* __tstate = wxPyBeginAllowThreads();
23852 result = (int)((wxMouseEvent const *)arg1)->GetX();
23853 wxPyEndAllowThreads(__tstate);
23854 if (PyErr_Occurred()) SWIG_fail;
23855 }
23856 resultobj = SWIG_From_int(static_cast< int >(result));
23857 return resultobj;
23858 fail:
23859 return NULL;
23860 }
23861
23862
23863 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23864 PyObject *resultobj = 0;
23865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23866 int result;
23867 void *argp1 = 0 ;
23868 int res1 = 0 ;
23869 PyObject *swig_obj[1] ;
23870
23871 if (!args) SWIG_fail;
23872 swig_obj[0] = args;
23873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23874 if (!SWIG_IsOK(res1)) {
23875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23876 }
23877 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23878 {
23879 PyThreadState* __tstate = wxPyBeginAllowThreads();
23880 result = (int)((wxMouseEvent const *)arg1)->GetY();
23881 wxPyEndAllowThreads(__tstate);
23882 if (PyErr_Occurred()) SWIG_fail;
23883 }
23884 resultobj = SWIG_From_int(static_cast< int >(result));
23885 return resultobj;
23886 fail:
23887 return NULL;
23888 }
23889
23890
23891 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23892 PyObject *resultobj = 0;
23893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23894 int result;
23895 void *argp1 = 0 ;
23896 int res1 = 0 ;
23897 PyObject *swig_obj[1] ;
23898
23899 if (!args) SWIG_fail;
23900 swig_obj[0] = args;
23901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23902 if (!SWIG_IsOK(res1)) {
23903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23904 }
23905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 resultobj = SWIG_From_int(static_cast< int >(result));
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 PyObject *resultobj = 0;
23921 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23922 int result;
23923 void *argp1 = 0 ;
23924 int res1 = 0 ;
23925 PyObject *swig_obj[1] ;
23926
23927 if (!args) SWIG_fail;
23928 swig_obj[0] = args;
23929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23930 if (!SWIG_IsOK(res1)) {
23931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23932 }
23933 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_From_int(static_cast< int >(result));
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *resultobj = 0;
23949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23950 int result;
23951 void *argp1 = 0 ;
23952 int res1 = 0 ;
23953 PyObject *swig_obj[1] ;
23954
23955 if (!args) SWIG_fail;
23956 swig_obj[0] = args;
23957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23958 if (!SWIG_IsOK(res1)) {
23959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23960 }
23961 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 resultobj = SWIG_From_int(static_cast< int >(result));
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 PyObject *resultobj = 0;
23977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23978 bool result;
23979 void *argp1 = 0 ;
23980 int res1 = 0 ;
23981 PyObject *swig_obj[1] ;
23982
23983 if (!args) SWIG_fail;
23984 swig_obj[0] = args;
23985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23986 if (!SWIG_IsOK(res1)) {
23987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23988 }
23989 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 {
23997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *resultobj = 0;
24007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24008 int arg2 ;
24009 void *argp1 = 0 ;
24010 int res1 = 0 ;
24011 int val2 ;
24012 int ecode2 = 0 ;
24013 PyObject *swig_obj[2] ;
24014
24015 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24017 if (!SWIG_IsOK(res1)) {
24018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24019 }
24020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24021 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24022 if (!SWIG_IsOK(ecode2)) {
24023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24024 }
24025 arg2 = static_cast< int >(val2);
24026 if (arg1) (arg1)->m_x = arg2;
24027
24028 resultobj = SWIG_Py_Void();
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24036 PyObject *resultobj = 0;
24037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24038 int result;
24039 void *argp1 = 0 ;
24040 int res1 = 0 ;
24041 PyObject *swig_obj[1] ;
24042
24043 if (!args) SWIG_fail;
24044 swig_obj[0] = args;
24045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24046 if (!SWIG_IsOK(res1)) {
24047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24048 }
24049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24050 result = (int) ((arg1)->m_x);
24051 resultobj = SWIG_From_int(static_cast< int >(result));
24052 return resultobj;
24053 fail:
24054 return NULL;
24055 }
24056
24057
24058 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24059 PyObject *resultobj = 0;
24060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24061 int arg2 ;
24062 void *argp1 = 0 ;
24063 int res1 = 0 ;
24064 int val2 ;
24065 int ecode2 = 0 ;
24066 PyObject *swig_obj[2] ;
24067
24068 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24070 if (!SWIG_IsOK(res1)) {
24071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24072 }
24073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24074 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24075 if (!SWIG_IsOK(ecode2)) {
24076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24077 }
24078 arg2 = static_cast< int >(val2);
24079 if (arg1) (arg1)->m_y = arg2;
24080
24081 resultobj = SWIG_Py_Void();
24082 return resultobj;
24083 fail:
24084 return NULL;
24085 }
24086
24087
24088 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24089 PyObject *resultobj = 0;
24090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24091 int result;
24092 void *argp1 = 0 ;
24093 int res1 = 0 ;
24094 PyObject *swig_obj[1] ;
24095
24096 if (!args) SWIG_fail;
24097 swig_obj[0] = args;
24098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24099 if (!SWIG_IsOK(res1)) {
24100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24101 }
24102 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24103 result = (int) ((arg1)->m_y);
24104 resultobj = SWIG_From_int(static_cast< int >(result));
24105 return resultobj;
24106 fail:
24107 return NULL;
24108 }
24109
24110
24111 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24112 PyObject *resultobj = 0;
24113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24114 bool arg2 ;
24115 void *argp1 = 0 ;
24116 int res1 = 0 ;
24117 bool val2 ;
24118 int ecode2 = 0 ;
24119 PyObject *swig_obj[2] ;
24120
24121 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24123 if (!SWIG_IsOK(res1)) {
24124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24125 }
24126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24127 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24128 if (!SWIG_IsOK(ecode2)) {
24129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24130 }
24131 arg2 = static_cast< bool >(val2);
24132 if (arg1) (arg1)->m_leftDown = arg2;
24133
24134 resultobj = SWIG_Py_Void();
24135 return resultobj;
24136 fail:
24137 return NULL;
24138 }
24139
24140
24141 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24142 PyObject *resultobj = 0;
24143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24144 bool result;
24145 void *argp1 = 0 ;
24146 int res1 = 0 ;
24147 PyObject *swig_obj[1] ;
24148
24149 if (!args) SWIG_fail;
24150 swig_obj[0] = args;
24151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24152 if (!SWIG_IsOK(res1)) {
24153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24154 }
24155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24156 result = (bool) ((arg1)->m_leftDown);
24157 {
24158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24159 }
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24167 PyObject *resultobj = 0;
24168 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24169 bool arg2 ;
24170 void *argp1 = 0 ;
24171 int res1 = 0 ;
24172 bool val2 ;
24173 int ecode2 = 0 ;
24174 PyObject *swig_obj[2] ;
24175
24176 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24178 if (!SWIG_IsOK(res1)) {
24179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24180 }
24181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24182 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24183 if (!SWIG_IsOK(ecode2)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24185 }
24186 arg2 = static_cast< bool >(val2);
24187 if (arg1) (arg1)->m_middleDown = arg2;
24188
24189 resultobj = SWIG_Py_Void();
24190 return resultobj;
24191 fail:
24192 return NULL;
24193 }
24194
24195
24196 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24197 PyObject *resultobj = 0;
24198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24199 bool 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_wxMouseEvent, 0 | 0 );
24207 if (!SWIG_IsOK(res1)) {
24208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24209 }
24210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24211 result = (bool) ((arg1)->m_middleDown);
24212 {
24213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24214 }
24215 return resultobj;
24216 fail:
24217 return NULL;
24218 }
24219
24220
24221 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24222 PyObject *resultobj = 0;
24223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24224 bool arg2 ;
24225 void *argp1 = 0 ;
24226 int res1 = 0 ;
24227 bool val2 ;
24228 int ecode2 = 0 ;
24229 PyObject *swig_obj[2] ;
24230
24231 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24233 if (!SWIG_IsOK(res1)) {
24234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24235 }
24236 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24237 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24238 if (!SWIG_IsOK(ecode2)) {
24239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24240 }
24241 arg2 = static_cast< bool >(val2);
24242 if (arg1) (arg1)->m_rightDown = arg2;
24243
24244 resultobj = SWIG_Py_Void();
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24252 PyObject *resultobj = 0;
24253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24254 bool result;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 PyObject *swig_obj[1] ;
24258
24259 if (!args) SWIG_fail;
24260 swig_obj[0] = args;
24261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24264 }
24265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24266 result = (bool) ((arg1)->m_rightDown);
24267 {
24268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24269 }
24270 return resultobj;
24271 fail:
24272 return NULL;
24273 }
24274
24275
24276 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24277 PyObject *resultobj = 0;
24278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24279 bool arg2 ;
24280 void *argp1 = 0 ;
24281 int res1 = 0 ;
24282 bool val2 ;
24283 int ecode2 = 0 ;
24284 PyObject *swig_obj[2] ;
24285
24286 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24288 if (!SWIG_IsOK(res1)) {
24289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24290 }
24291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24292 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24293 if (!SWIG_IsOK(ecode2)) {
24294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24295 }
24296 arg2 = static_cast< bool >(val2);
24297 if (arg1) (arg1)->m_controlDown = arg2;
24298
24299 resultobj = SWIG_Py_Void();
24300 return resultobj;
24301 fail:
24302 return NULL;
24303 }
24304
24305
24306 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24307 PyObject *resultobj = 0;
24308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24309 bool result;
24310 void *argp1 = 0 ;
24311 int res1 = 0 ;
24312 PyObject *swig_obj[1] ;
24313
24314 if (!args) SWIG_fail;
24315 swig_obj[0] = args;
24316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24317 if (!SWIG_IsOK(res1)) {
24318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24319 }
24320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24321 result = (bool) ((arg1)->m_controlDown);
24322 {
24323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24324 }
24325 return resultobj;
24326 fail:
24327 return NULL;
24328 }
24329
24330
24331 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24332 PyObject *resultobj = 0;
24333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24334 bool arg2 ;
24335 void *argp1 = 0 ;
24336 int res1 = 0 ;
24337 bool val2 ;
24338 int ecode2 = 0 ;
24339 PyObject *swig_obj[2] ;
24340
24341 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24343 if (!SWIG_IsOK(res1)) {
24344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24345 }
24346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24347 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24348 if (!SWIG_IsOK(ecode2)) {
24349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24350 }
24351 arg2 = static_cast< bool >(val2);
24352 if (arg1) (arg1)->m_shiftDown = arg2;
24353
24354 resultobj = SWIG_Py_Void();
24355 return resultobj;
24356 fail:
24357 return NULL;
24358 }
24359
24360
24361 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24362 PyObject *resultobj = 0;
24363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24364 bool result;
24365 void *argp1 = 0 ;
24366 int res1 = 0 ;
24367 PyObject *swig_obj[1] ;
24368
24369 if (!args) SWIG_fail;
24370 swig_obj[0] = args;
24371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24372 if (!SWIG_IsOK(res1)) {
24373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24374 }
24375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24376 result = (bool) ((arg1)->m_shiftDown);
24377 {
24378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24379 }
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *resultobj = 0;
24388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24389 bool arg2 ;
24390 void *argp1 = 0 ;
24391 int res1 = 0 ;
24392 bool val2 ;
24393 int ecode2 = 0 ;
24394 PyObject *swig_obj[2] ;
24395
24396 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24398 if (!SWIG_IsOK(res1)) {
24399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24400 }
24401 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24402 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24403 if (!SWIG_IsOK(ecode2)) {
24404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24405 }
24406 arg2 = static_cast< bool >(val2);
24407 if (arg1) (arg1)->m_altDown = arg2;
24408
24409 resultobj = SWIG_Py_Void();
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417 PyObject *resultobj = 0;
24418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24419 bool result;
24420 void *argp1 = 0 ;
24421 int res1 = 0 ;
24422 PyObject *swig_obj[1] ;
24423
24424 if (!args) SWIG_fail;
24425 swig_obj[0] = args;
24426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24427 if (!SWIG_IsOK(res1)) {
24428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24429 }
24430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24431 result = (bool) ((arg1)->m_altDown);
24432 {
24433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24434 }
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24442 PyObject *resultobj = 0;
24443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24444 bool arg2 ;
24445 void *argp1 = 0 ;
24446 int res1 = 0 ;
24447 bool val2 ;
24448 int ecode2 = 0 ;
24449 PyObject *swig_obj[2] ;
24450
24451 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24453 if (!SWIG_IsOK(res1)) {
24454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24455 }
24456 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24457 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24458 if (!SWIG_IsOK(ecode2)) {
24459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24460 }
24461 arg2 = static_cast< bool >(val2);
24462 if (arg1) (arg1)->m_metaDown = arg2;
24463
24464 resultobj = SWIG_Py_Void();
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24472 PyObject *resultobj = 0;
24473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24474 bool result;
24475 void *argp1 = 0 ;
24476 int res1 = 0 ;
24477 PyObject *swig_obj[1] ;
24478
24479 if (!args) SWIG_fail;
24480 swig_obj[0] = args;
24481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24482 if (!SWIG_IsOK(res1)) {
24483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24484 }
24485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24486 result = (bool) ((arg1)->m_metaDown);
24487 {
24488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24489 }
24490 return resultobj;
24491 fail:
24492 return NULL;
24493 }
24494
24495
24496 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24497 PyObject *resultobj = 0;
24498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24499 int arg2 ;
24500 void *argp1 = 0 ;
24501 int res1 = 0 ;
24502 int val2 ;
24503 int ecode2 = 0 ;
24504 PyObject *swig_obj[2] ;
24505
24506 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24508 if (!SWIG_IsOK(res1)) {
24509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24510 }
24511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24512 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24513 if (!SWIG_IsOK(ecode2)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24515 }
24516 arg2 = static_cast< int >(val2);
24517 if (arg1) (arg1)->m_wheelRotation = arg2;
24518
24519 resultobj = SWIG_Py_Void();
24520 return resultobj;
24521 fail:
24522 return NULL;
24523 }
24524
24525
24526 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24527 PyObject *resultobj = 0;
24528 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24529 int result;
24530 void *argp1 = 0 ;
24531 int res1 = 0 ;
24532 PyObject *swig_obj[1] ;
24533
24534 if (!args) SWIG_fail;
24535 swig_obj[0] = args;
24536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24537 if (!SWIG_IsOK(res1)) {
24538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24539 }
24540 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24541 result = (int) ((arg1)->m_wheelRotation);
24542 resultobj = SWIG_From_int(static_cast< int >(result));
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24550 PyObject *resultobj = 0;
24551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24552 int arg2 ;
24553 void *argp1 = 0 ;
24554 int res1 = 0 ;
24555 int val2 ;
24556 int ecode2 = 0 ;
24557 PyObject *swig_obj[2] ;
24558
24559 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24561 if (!SWIG_IsOK(res1)) {
24562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24563 }
24564 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24565 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24566 if (!SWIG_IsOK(ecode2)) {
24567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24568 }
24569 arg2 = static_cast< int >(val2);
24570 if (arg1) (arg1)->m_wheelDelta = arg2;
24571
24572 resultobj = SWIG_Py_Void();
24573 return resultobj;
24574 fail:
24575 return NULL;
24576 }
24577
24578
24579 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24580 PyObject *resultobj = 0;
24581 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24582 int result;
24583 void *argp1 = 0 ;
24584 int res1 = 0 ;
24585 PyObject *swig_obj[1] ;
24586
24587 if (!args) SWIG_fail;
24588 swig_obj[0] = args;
24589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24590 if (!SWIG_IsOK(res1)) {
24591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24592 }
24593 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24594 result = (int) ((arg1)->m_wheelDelta);
24595 resultobj = SWIG_From_int(static_cast< int >(result));
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24603 PyObject *resultobj = 0;
24604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24605 int arg2 ;
24606 void *argp1 = 0 ;
24607 int res1 = 0 ;
24608 int val2 ;
24609 int ecode2 = 0 ;
24610 PyObject *swig_obj[2] ;
24611
24612 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24614 if (!SWIG_IsOK(res1)) {
24615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24616 }
24617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24618 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24619 if (!SWIG_IsOK(ecode2)) {
24620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24621 }
24622 arg2 = static_cast< int >(val2);
24623 if (arg1) (arg1)->m_linesPerAction = arg2;
24624
24625 resultobj = SWIG_Py_Void();
24626 return resultobj;
24627 fail:
24628 return NULL;
24629 }
24630
24631
24632 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24633 PyObject *resultobj = 0;
24634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24635 int result;
24636 void *argp1 = 0 ;
24637 int res1 = 0 ;
24638 PyObject *swig_obj[1] ;
24639
24640 if (!args) SWIG_fail;
24641 swig_obj[0] = args;
24642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24643 if (!SWIG_IsOK(res1)) {
24644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24645 }
24646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24647 result = (int) ((arg1)->m_linesPerAction);
24648 resultobj = SWIG_From_int(static_cast< int >(result));
24649 return resultobj;
24650 fail:
24651 return NULL;
24652 }
24653
24654
24655 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24656 PyObject *obj;
24657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24659 return SWIG_Py_Void();
24660 }
24661
24662 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24663 return SWIG_Python_InitShadowInstance(args);
24664 }
24665
24666 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24667 PyObject *resultobj = 0;
24668 int arg1 = (int) 0 ;
24669 int arg2 = (int) 0 ;
24670 wxSetCursorEvent *result = 0 ;
24671 int val1 ;
24672 int ecode1 = 0 ;
24673 int val2 ;
24674 int ecode2 = 0 ;
24675 PyObject * obj0 = 0 ;
24676 PyObject * obj1 = 0 ;
24677 char * kwnames[] = {
24678 (char *) "x",(char *) "y", NULL
24679 };
24680
24681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24682 if (obj0) {
24683 ecode1 = SWIG_AsVal_int(obj0, &val1);
24684 if (!SWIG_IsOK(ecode1)) {
24685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24686 }
24687 arg1 = static_cast< int >(val1);
24688 }
24689 if (obj1) {
24690 ecode2 = SWIG_AsVal_int(obj1, &val2);
24691 if (!SWIG_IsOK(ecode2)) {
24692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24693 }
24694 arg2 = static_cast< int >(val2);
24695 }
24696 {
24697 PyThreadState* __tstate = wxPyBeginAllowThreads();
24698 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 PyObject *resultobj = 0;
24711 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24712 int result;
24713 void *argp1 = 0 ;
24714 int res1 = 0 ;
24715 PyObject *swig_obj[1] ;
24716
24717 if (!args) SWIG_fail;
24718 swig_obj[0] = args;
24719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24720 if (!SWIG_IsOK(res1)) {
24721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24722 }
24723 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 resultobj = SWIG_From_int(static_cast< int >(result));
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24738 PyObject *resultobj = 0;
24739 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24740 int result;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 PyObject *swig_obj[1] ;
24744
24745 if (!args) SWIG_fail;
24746 swig_obj[0] = args;
24747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24748 if (!SWIG_IsOK(res1)) {
24749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24750 }
24751 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 resultobj = SWIG_From_int(static_cast< int >(result));
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24766 PyObject *resultobj = 0;
24767 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24768 wxCursor *arg2 = 0 ;
24769 void *argp1 = 0 ;
24770 int res1 = 0 ;
24771 void *argp2 = 0 ;
24772 int res2 = 0 ;
24773 PyObject * obj0 = 0 ;
24774 PyObject * obj1 = 0 ;
24775 char * kwnames[] = {
24776 (char *) "self",(char *) "cursor", NULL
24777 };
24778
24779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24781 if (!SWIG_IsOK(res1)) {
24782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24783 }
24784 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24786 if (!SWIG_IsOK(res2)) {
24787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24788 }
24789 if (!argp2) {
24790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24791 }
24792 arg2 = reinterpret_cast< wxCursor * >(argp2);
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 (arg1)->SetCursor((wxCursor const &)*arg2);
24796 wxPyEndAllowThreads(__tstate);
24797 if (PyErr_Occurred()) SWIG_fail;
24798 }
24799 resultobj = SWIG_Py_Void();
24800 return resultobj;
24801 fail:
24802 return NULL;
24803 }
24804
24805
24806 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24807 PyObject *resultobj = 0;
24808 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24809 wxCursor *result = 0 ;
24810 void *argp1 = 0 ;
24811 int res1 = 0 ;
24812 PyObject *swig_obj[1] ;
24813
24814 if (!args) SWIG_fail;
24815 swig_obj[0] = args;
24816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24817 if (!SWIG_IsOK(res1)) {
24818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24819 }
24820 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24821 {
24822 PyThreadState* __tstate = wxPyBeginAllowThreads();
24823 {
24824 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24825 result = (wxCursor *) &_result_ref;
24826 }
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 wxCursor* resultptr = new wxCursor(*result);
24832 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24833 }
24834 return resultobj;
24835 fail:
24836 return NULL;
24837 }
24838
24839
24840 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24841 PyObject *resultobj = 0;
24842 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24843 bool result;
24844 void *argp1 = 0 ;
24845 int res1 = 0 ;
24846 PyObject *swig_obj[1] ;
24847
24848 if (!args) SWIG_fail;
24849 swig_obj[0] = args;
24850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24851 if (!SWIG_IsOK(res1)) {
24852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24853 }
24854 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 {
24862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24863 }
24864 return resultobj;
24865 fail:
24866 return NULL;
24867 }
24868
24869
24870 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24871 PyObject *obj;
24872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24873 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24874 return SWIG_Py_Void();
24875 }
24876
24877 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24878 return SWIG_Python_InitShadowInstance(args);
24879 }
24880
24881 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24882 PyObject *resultobj = 0;
24883 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24884 wxKeyEvent *result = 0 ;
24885 int val1 ;
24886 int ecode1 = 0 ;
24887 PyObject * obj0 = 0 ;
24888 char * kwnames[] = {
24889 (char *) "eventType", NULL
24890 };
24891
24892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24893 if (obj0) {
24894 ecode1 = SWIG_AsVal_int(obj0, &val1);
24895 if (!SWIG_IsOK(ecode1)) {
24896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24897 }
24898 arg1 = static_cast< wxEventType >(val1);
24899 }
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24914 PyObject *resultobj = 0;
24915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24916 int result;
24917 void *argp1 = 0 ;
24918 int res1 = 0 ;
24919 PyObject *swig_obj[1] ;
24920
24921 if (!args) SWIG_fail;
24922 swig_obj[0] = args;
24923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24924 if (!SWIG_IsOK(res1)) {
24925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24926 }
24927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24931 wxPyEndAllowThreads(__tstate);
24932 if (PyErr_Occurred()) SWIG_fail;
24933 }
24934 resultobj = SWIG_From_int(static_cast< int >(result));
24935 return resultobj;
24936 fail:
24937 return NULL;
24938 }
24939
24940
24941 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24942 PyObject *resultobj = 0;
24943 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24944 bool result;
24945 void *argp1 = 0 ;
24946 int res1 = 0 ;
24947 PyObject *swig_obj[1] ;
24948
24949 if (!args) SWIG_fail;
24950 swig_obj[0] = args;
24951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24952 if (!SWIG_IsOK(res1)) {
24953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24954 }
24955 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 {
24963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24964 }
24965 return resultobj;
24966 fail:
24967 return NULL;
24968 }
24969
24970
24971 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24972 PyObject *resultobj = 0;
24973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24974 bool result;
24975 void *argp1 = 0 ;
24976 int res1 = 0 ;
24977 PyObject *swig_obj[1] ;
24978
24979 if (!args) SWIG_fail;
24980 swig_obj[0] = args;
24981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24982 if (!SWIG_IsOK(res1)) {
24983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24984 }
24985 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24986 {
24987 PyThreadState* __tstate = wxPyBeginAllowThreads();
24988 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 {
24993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24994 }
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25002 PyObject *resultobj = 0;
25003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25004 bool result;
25005 void *argp1 = 0 ;
25006 int res1 = 0 ;
25007 PyObject *swig_obj[1] ;
25008
25009 if (!args) SWIG_fail;
25010 swig_obj[0] = args;
25011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25014 }
25015 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25016 {
25017 PyThreadState* __tstate = wxPyBeginAllowThreads();
25018 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25019 wxPyEndAllowThreads(__tstate);
25020 if (PyErr_Occurred()) SWIG_fail;
25021 }
25022 {
25023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25024 }
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25032 PyObject *resultobj = 0;
25033 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25034 bool result;
25035 void *argp1 = 0 ;
25036 int res1 = 0 ;
25037 PyObject *swig_obj[1] ;
25038
25039 if (!args) SWIG_fail;
25040 swig_obj[0] = args;
25041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25042 if (!SWIG_IsOK(res1)) {
25043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25044 }
25045 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25046 {
25047 PyThreadState* __tstate = wxPyBeginAllowThreads();
25048 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25049 wxPyEndAllowThreads(__tstate);
25050 if (PyErr_Occurred()) SWIG_fail;
25051 }
25052 {
25053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25054 }
25055 return resultobj;
25056 fail:
25057 return NULL;
25058 }
25059
25060
25061 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25062 PyObject *resultobj = 0;
25063 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25064 bool result;
25065 void *argp1 = 0 ;
25066 int res1 = 0 ;
25067 PyObject *swig_obj[1] ;
25068
25069 if (!args) SWIG_fail;
25070 swig_obj[0] = args;
25071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25072 if (!SWIG_IsOK(res1)) {
25073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25074 }
25075 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25076 {
25077 PyThreadState* __tstate = wxPyBeginAllowThreads();
25078 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25079 wxPyEndAllowThreads(__tstate);
25080 if (PyErr_Occurred()) SWIG_fail;
25081 }
25082 {
25083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25084 }
25085 return resultobj;
25086 fail:
25087 return NULL;
25088 }
25089
25090
25091 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25092 PyObject *resultobj = 0;
25093 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25094 bool result;
25095 void *argp1 = 0 ;
25096 int res1 = 0 ;
25097 PyObject *swig_obj[1] ;
25098
25099 if (!args) SWIG_fail;
25100 swig_obj[0] = args;
25101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25102 if (!SWIG_IsOK(res1)) {
25103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25104 }
25105 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25106 {
25107 PyThreadState* __tstate = wxPyBeginAllowThreads();
25108 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25109 wxPyEndAllowThreads(__tstate);
25110 if (PyErr_Occurred()) SWIG_fail;
25111 }
25112 {
25113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25114 }
25115 return resultobj;
25116 fail:
25117 return NULL;
25118 }
25119
25120
25121 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25122 PyObject *resultobj = 0;
25123 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25124 int result;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 PyObject *swig_obj[1] ;
25128
25129 if (!args) SWIG_fail;
25130 swig_obj[0] = args;
25131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25134 }
25135 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 resultobj = SWIG_From_int(static_cast< int >(result));
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25150 PyObject *resultobj = 0;
25151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25152 int result;
25153 void *argp1 = 0 ;
25154 int res1 = 0 ;
25155 PyObject *swig_obj[1] ;
25156
25157 if (!args) SWIG_fail;
25158 swig_obj[0] = args;
25159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25160 if (!SWIG_IsOK(res1)) {
25161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25162 }
25163 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 resultobj = SWIG_From_int(static_cast< int >(result));
25171 return resultobj;
25172 fail:
25173 return NULL;
25174 }
25175
25176
25177 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25178 PyObject *resultobj = 0;
25179 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25180 int arg2 ;
25181 void *argp1 = 0 ;
25182 int res1 = 0 ;
25183 int val2 ;
25184 int ecode2 = 0 ;
25185 PyObject * obj0 = 0 ;
25186 PyObject * obj1 = 0 ;
25187 char * kwnames[] = {
25188 (char *) "self",(char *) "uniChar", NULL
25189 };
25190
25191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25193 if (!SWIG_IsOK(res1)) {
25194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25195 }
25196 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25197 ecode2 = SWIG_AsVal_int(obj1, &val2);
25198 if (!SWIG_IsOK(ecode2)) {
25199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25200 }
25201 arg2 = static_cast< int >(val2);
25202 {
25203 PyThreadState* __tstate = wxPyBeginAllowThreads();
25204 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25205 wxPyEndAllowThreads(__tstate);
25206 if (PyErr_Occurred()) SWIG_fail;
25207 }
25208 resultobj = SWIG_Py_Void();
25209 return resultobj;
25210 fail:
25211 return NULL;
25212 }
25213
25214
25215 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25216 PyObject *resultobj = 0;
25217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25218 unsigned int result;
25219 void *argp1 = 0 ;
25220 int res1 = 0 ;
25221 PyObject *swig_obj[1] ;
25222
25223 if (!args) SWIG_fail;
25224 swig_obj[0] = args;
25225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25226 if (!SWIG_IsOK(res1)) {
25227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25228 }
25229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25230 {
25231 PyThreadState* __tstate = wxPyBeginAllowThreads();
25232 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25237 return resultobj;
25238 fail:
25239 return NULL;
25240 }
25241
25242
25243 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25244 PyObject *resultobj = 0;
25245 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25246 unsigned int result;
25247 void *argp1 = 0 ;
25248 int res1 = 0 ;
25249 PyObject *swig_obj[1] ;
25250
25251 if (!args) SWIG_fail;
25252 swig_obj[0] = args;
25253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25254 if (!SWIG_IsOK(res1)) {
25255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25256 }
25257 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25258 {
25259 PyThreadState* __tstate = wxPyBeginAllowThreads();
25260 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25261 wxPyEndAllowThreads(__tstate);
25262 if (PyErr_Occurred()) SWIG_fail;
25263 }
25264 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25265 return resultobj;
25266 fail:
25267 return NULL;
25268 }
25269
25270
25271 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25272 PyObject *resultobj = 0;
25273 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25274 wxPoint result;
25275 void *argp1 = 0 ;
25276 int res1 = 0 ;
25277 PyObject *swig_obj[1] ;
25278
25279 if (!args) SWIG_fail;
25280 swig_obj[0] = args;
25281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25282 if (!SWIG_IsOK(res1)) {
25283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25284 }
25285 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = (arg1)->GetPosition();
25289 wxPyEndAllowThreads(__tstate);
25290 if (PyErr_Occurred()) SWIG_fail;
25291 }
25292 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25293 return resultobj;
25294 fail:
25295 return NULL;
25296 }
25297
25298
25299 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25300 PyObject *resultobj = 0;
25301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25302 long *arg2 = (long *) 0 ;
25303 long *arg3 = (long *) 0 ;
25304 void *argp1 = 0 ;
25305 int res1 = 0 ;
25306 long temp2 ;
25307 int res2 = SWIG_TMPOBJ ;
25308 long temp3 ;
25309 int res3 = SWIG_TMPOBJ ;
25310 PyObject *swig_obj[1] ;
25311
25312 arg2 = &temp2;
25313 arg3 = &temp3;
25314 if (!args) SWIG_fail;
25315 swig_obj[0] = args;
25316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25317 if (!SWIG_IsOK(res1)) {
25318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25319 }
25320 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 (arg1)->GetPosition(arg2,arg3);
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_Py_Void();
25328 if (SWIG_IsTmpObj(res2)) {
25329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25330 } else {
25331 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25333 }
25334 if (SWIG_IsTmpObj(res3)) {
25335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25336 } else {
25337 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25339 }
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *resultobj = 0;
25348 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25349 int result;
25350 void *argp1 = 0 ;
25351 int res1 = 0 ;
25352 PyObject *swig_obj[1] ;
25353
25354 if (!args) SWIG_fail;
25355 swig_obj[0] = args;
25356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25357 if (!SWIG_IsOK(res1)) {
25358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25359 }
25360 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25361 {
25362 PyThreadState* __tstate = wxPyBeginAllowThreads();
25363 result = (int)((wxKeyEvent const *)arg1)->GetX();
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 resultobj = SWIG_From_int(static_cast< int >(result));
25368 return resultobj;
25369 fail:
25370 return NULL;
25371 }
25372
25373
25374 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25375 PyObject *resultobj = 0;
25376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25377 int result;
25378 void *argp1 = 0 ;
25379 int res1 = 0 ;
25380 PyObject *swig_obj[1] ;
25381
25382 if (!args) SWIG_fail;
25383 swig_obj[0] = args;
25384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25385 if (!SWIG_IsOK(res1)) {
25386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25387 }
25388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 result = (int)((wxKeyEvent const *)arg1)->GetY();
25392 wxPyEndAllowThreads(__tstate);
25393 if (PyErr_Occurred()) SWIG_fail;
25394 }
25395 resultobj = SWIG_From_int(static_cast< int >(result));
25396 return resultobj;
25397 fail:
25398 return NULL;
25399 }
25400
25401
25402 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25403 PyObject *resultobj = 0;
25404 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25405 int arg2 ;
25406 void *argp1 = 0 ;
25407 int res1 = 0 ;
25408 int val2 ;
25409 int ecode2 = 0 ;
25410 PyObject *swig_obj[2] ;
25411
25412 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25414 if (!SWIG_IsOK(res1)) {
25415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25416 }
25417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25418 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25419 if (!SWIG_IsOK(ecode2)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25421 }
25422 arg2 = static_cast< int >(val2);
25423 if (arg1) (arg1)->m_x = arg2;
25424
25425 resultobj = SWIG_Py_Void();
25426 return resultobj;
25427 fail:
25428 return NULL;
25429 }
25430
25431
25432 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25433 PyObject *resultobj = 0;
25434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25435 int result;
25436 void *argp1 = 0 ;
25437 int res1 = 0 ;
25438 PyObject *swig_obj[1] ;
25439
25440 if (!args) SWIG_fail;
25441 swig_obj[0] = args;
25442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25443 if (!SWIG_IsOK(res1)) {
25444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25445 }
25446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25447 result = (int) ((arg1)->m_x);
25448 resultobj = SWIG_From_int(static_cast< int >(result));
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 PyObject *resultobj = 0;
25457 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25458 int arg2 ;
25459 void *argp1 = 0 ;
25460 int res1 = 0 ;
25461 int val2 ;
25462 int ecode2 = 0 ;
25463 PyObject *swig_obj[2] ;
25464
25465 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25467 if (!SWIG_IsOK(res1)) {
25468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25469 }
25470 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25471 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25472 if (!SWIG_IsOK(ecode2)) {
25473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25474 }
25475 arg2 = static_cast< int >(val2);
25476 if (arg1) (arg1)->m_y = arg2;
25477
25478 resultobj = SWIG_Py_Void();
25479 return resultobj;
25480 fail:
25481 return NULL;
25482 }
25483
25484
25485 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25486 PyObject *resultobj = 0;
25487 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25488 int result;
25489 void *argp1 = 0 ;
25490 int res1 = 0 ;
25491 PyObject *swig_obj[1] ;
25492
25493 if (!args) SWIG_fail;
25494 swig_obj[0] = args;
25495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25496 if (!SWIG_IsOK(res1)) {
25497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25498 }
25499 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25500 result = (int) ((arg1)->m_y);
25501 resultobj = SWIG_From_int(static_cast< int >(result));
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25509 PyObject *resultobj = 0;
25510 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25511 long arg2 ;
25512 void *argp1 = 0 ;
25513 int res1 = 0 ;
25514 long val2 ;
25515 int ecode2 = 0 ;
25516 PyObject *swig_obj[2] ;
25517
25518 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25520 if (!SWIG_IsOK(res1)) {
25521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25522 }
25523 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25524 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25525 if (!SWIG_IsOK(ecode2)) {
25526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25527 }
25528 arg2 = static_cast< long >(val2);
25529 if (arg1) (arg1)->m_keyCode = arg2;
25530
25531 resultobj = SWIG_Py_Void();
25532 return resultobj;
25533 fail:
25534 return NULL;
25535 }
25536
25537
25538 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25539 PyObject *resultobj = 0;
25540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25541 long result;
25542 void *argp1 = 0 ;
25543 int res1 = 0 ;
25544 PyObject *swig_obj[1] ;
25545
25546 if (!args) SWIG_fail;
25547 swig_obj[0] = args;
25548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25549 if (!SWIG_IsOK(res1)) {
25550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25551 }
25552 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25553 result = (long) ((arg1)->m_keyCode);
25554 resultobj = SWIG_From_long(static_cast< long >(result));
25555 return resultobj;
25556 fail:
25557 return NULL;
25558 }
25559
25560
25561 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25562 PyObject *resultobj = 0;
25563 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25564 bool arg2 ;
25565 void *argp1 = 0 ;
25566 int res1 = 0 ;
25567 bool val2 ;
25568 int ecode2 = 0 ;
25569 PyObject *swig_obj[2] ;
25570
25571 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25573 if (!SWIG_IsOK(res1)) {
25574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25575 }
25576 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25577 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25578 if (!SWIG_IsOK(ecode2)) {
25579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25580 }
25581 arg2 = static_cast< bool >(val2);
25582 if (arg1) (arg1)->m_controlDown = arg2;
25583
25584 resultobj = SWIG_Py_Void();
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25592 PyObject *resultobj = 0;
25593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25594 bool result;
25595 void *argp1 = 0 ;
25596 int res1 = 0 ;
25597 PyObject *swig_obj[1] ;
25598
25599 if (!args) SWIG_fail;
25600 swig_obj[0] = args;
25601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25602 if (!SWIG_IsOK(res1)) {
25603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25604 }
25605 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25606 result = (bool) ((arg1)->m_controlDown);
25607 {
25608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25609 }
25610 return resultobj;
25611 fail:
25612 return NULL;
25613 }
25614
25615
25616 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25617 PyObject *resultobj = 0;
25618 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25619 bool arg2 ;
25620 void *argp1 = 0 ;
25621 int res1 = 0 ;
25622 bool val2 ;
25623 int ecode2 = 0 ;
25624 PyObject *swig_obj[2] ;
25625
25626 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25628 if (!SWIG_IsOK(res1)) {
25629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25630 }
25631 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25632 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25633 if (!SWIG_IsOK(ecode2)) {
25634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25635 }
25636 arg2 = static_cast< bool >(val2);
25637 if (arg1) (arg1)->m_shiftDown = arg2;
25638
25639 resultobj = SWIG_Py_Void();
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 PyObject *resultobj = 0;
25648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25649 bool result;
25650 void *argp1 = 0 ;
25651 int res1 = 0 ;
25652 PyObject *swig_obj[1] ;
25653
25654 if (!args) SWIG_fail;
25655 swig_obj[0] = args;
25656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25659 }
25660 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25661 result = (bool) ((arg1)->m_shiftDown);
25662 {
25663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25664 }
25665 return resultobj;
25666 fail:
25667 return NULL;
25668 }
25669
25670
25671 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25672 PyObject *resultobj = 0;
25673 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25674 bool arg2 ;
25675 void *argp1 = 0 ;
25676 int res1 = 0 ;
25677 bool val2 ;
25678 int ecode2 = 0 ;
25679 PyObject *swig_obj[2] ;
25680
25681 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25683 if (!SWIG_IsOK(res1)) {
25684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25685 }
25686 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25687 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25688 if (!SWIG_IsOK(ecode2)) {
25689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25690 }
25691 arg2 = static_cast< bool >(val2);
25692 if (arg1) (arg1)->m_altDown = arg2;
25693
25694 resultobj = SWIG_Py_Void();
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25702 PyObject *resultobj = 0;
25703 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25704 bool result;
25705 void *argp1 = 0 ;
25706 int res1 = 0 ;
25707 PyObject *swig_obj[1] ;
25708
25709 if (!args) SWIG_fail;
25710 swig_obj[0] = args;
25711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25712 if (!SWIG_IsOK(res1)) {
25713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25714 }
25715 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25716 result = (bool) ((arg1)->m_altDown);
25717 {
25718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25719 }
25720 return resultobj;
25721 fail:
25722 return NULL;
25723 }
25724
25725
25726 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25727 PyObject *resultobj = 0;
25728 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25729 bool arg2 ;
25730 void *argp1 = 0 ;
25731 int res1 = 0 ;
25732 bool val2 ;
25733 int ecode2 = 0 ;
25734 PyObject *swig_obj[2] ;
25735
25736 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25738 if (!SWIG_IsOK(res1)) {
25739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25740 }
25741 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25742 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25743 if (!SWIG_IsOK(ecode2)) {
25744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25745 }
25746 arg2 = static_cast< bool >(val2);
25747 if (arg1) (arg1)->m_metaDown = arg2;
25748
25749 resultobj = SWIG_Py_Void();
25750 return resultobj;
25751 fail:
25752 return NULL;
25753 }
25754
25755
25756 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25757 PyObject *resultobj = 0;
25758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25759 bool result;
25760 void *argp1 = 0 ;
25761 int res1 = 0 ;
25762 PyObject *swig_obj[1] ;
25763
25764 if (!args) SWIG_fail;
25765 swig_obj[0] = args;
25766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25767 if (!SWIG_IsOK(res1)) {
25768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25769 }
25770 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25771 result = (bool) ((arg1)->m_metaDown);
25772 {
25773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25774 }
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25782 PyObject *resultobj = 0;
25783 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25784 bool arg2 ;
25785 void *argp1 = 0 ;
25786 int res1 = 0 ;
25787 bool val2 ;
25788 int ecode2 = 0 ;
25789 PyObject *swig_obj[2] ;
25790
25791 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25793 if (!SWIG_IsOK(res1)) {
25794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25795 }
25796 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25797 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25798 if (!SWIG_IsOK(ecode2)) {
25799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25800 }
25801 arg2 = static_cast< bool >(val2);
25802 if (arg1) (arg1)->m_scanCode = arg2;
25803
25804 resultobj = SWIG_Py_Void();
25805 return resultobj;
25806 fail:
25807 return NULL;
25808 }
25809
25810
25811 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25812 PyObject *resultobj = 0;
25813 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25814 bool result;
25815 void *argp1 = 0 ;
25816 int res1 = 0 ;
25817 PyObject *swig_obj[1] ;
25818
25819 if (!args) SWIG_fail;
25820 swig_obj[0] = args;
25821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25822 if (!SWIG_IsOK(res1)) {
25823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25824 }
25825 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25826 result = (bool) ((arg1)->m_scanCode);
25827 {
25828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25829 }
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25837 PyObject *resultobj = 0;
25838 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25839 unsigned int arg2 ;
25840 void *argp1 = 0 ;
25841 int res1 = 0 ;
25842 unsigned int val2 ;
25843 int ecode2 = 0 ;
25844 PyObject *swig_obj[2] ;
25845
25846 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25848 if (!SWIG_IsOK(res1)) {
25849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25850 }
25851 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25852 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25853 if (!SWIG_IsOK(ecode2)) {
25854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25855 }
25856 arg2 = static_cast< unsigned int >(val2);
25857 if (arg1) (arg1)->m_rawCode = arg2;
25858
25859 resultobj = SWIG_Py_Void();
25860 return resultobj;
25861 fail:
25862 return NULL;
25863 }
25864
25865
25866 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25867 PyObject *resultobj = 0;
25868 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25869 unsigned int result;
25870 void *argp1 = 0 ;
25871 int res1 = 0 ;
25872 PyObject *swig_obj[1] ;
25873
25874 if (!args) SWIG_fail;
25875 swig_obj[0] = args;
25876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25879 }
25880 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25881 result = (unsigned int) ((arg1)->m_rawCode);
25882 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25890 PyObject *resultobj = 0;
25891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25892 unsigned int arg2 ;
25893 void *argp1 = 0 ;
25894 int res1 = 0 ;
25895 unsigned int val2 ;
25896 int ecode2 = 0 ;
25897 PyObject *swig_obj[2] ;
25898
25899 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25901 if (!SWIG_IsOK(res1)) {
25902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25903 }
25904 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25905 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25906 if (!SWIG_IsOK(ecode2)) {
25907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25908 }
25909 arg2 = static_cast< unsigned int >(val2);
25910 if (arg1) (arg1)->m_rawFlags = arg2;
25911
25912 resultobj = SWIG_Py_Void();
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25920 PyObject *resultobj = 0;
25921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25922 unsigned int result;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 PyObject *swig_obj[1] ;
25926
25927 if (!args) SWIG_fail;
25928 swig_obj[0] = args;
25929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25930 if (!SWIG_IsOK(res1)) {
25931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25932 }
25933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25934 result = (unsigned int) ((arg1)->m_rawFlags);
25935 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25943 PyObject *obj;
25944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25945 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25946 return SWIG_Py_Void();
25947 }
25948
25949 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25950 return SWIG_Python_InitShadowInstance(args);
25951 }
25952
25953 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25954 PyObject *resultobj = 0;
25955 wxSize const &arg1_defvalue = wxDefaultSize ;
25956 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25957 int arg2 = (int) 0 ;
25958 wxSizeEvent *result = 0 ;
25959 wxSize temp1 ;
25960 int val2 ;
25961 int ecode2 = 0 ;
25962 PyObject * obj0 = 0 ;
25963 PyObject * obj1 = 0 ;
25964 char * kwnames[] = {
25965 (char *) "sz",(char *) "winid", NULL
25966 };
25967
25968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25969 if (obj0) {
25970 {
25971 arg1 = &temp1;
25972 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25973 }
25974 }
25975 if (obj1) {
25976 ecode2 = SWIG_AsVal_int(obj1, &val2);
25977 if (!SWIG_IsOK(ecode2)) {
25978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25979 }
25980 arg2 = static_cast< int >(val2);
25981 }
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996 PyObject *resultobj = 0;
25997 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25998 wxSize result;
25999 void *argp1 = 0 ;
26000 int res1 = 0 ;
26001 PyObject *swig_obj[1] ;
26002
26003 if (!args) SWIG_fail;
26004 swig_obj[0] = args;
26005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26006 if (!SWIG_IsOK(res1)) {
26007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26008 }
26009 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = ((wxSizeEvent const *)arg1)->GetSize();
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26024 PyObject *resultobj = 0;
26025 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26026 wxRect result;
26027 void *argp1 = 0 ;
26028 int res1 = 0 ;
26029 PyObject *swig_obj[1] ;
26030
26031 if (!args) SWIG_fail;
26032 swig_obj[0] = args;
26033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26034 if (!SWIG_IsOK(res1)) {
26035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26036 }
26037 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26038 {
26039 PyThreadState* __tstate = wxPyBeginAllowThreads();
26040 result = ((wxSizeEvent const *)arg1)->GetRect();
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26045 return resultobj;
26046 fail:
26047 return NULL;
26048 }
26049
26050
26051 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26052 PyObject *resultobj = 0;
26053 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26054 wxRect arg2 ;
26055 void *argp1 = 0 ;
26056 int res1 = 0 ;
26057 void *argp2 ;
26058 int res2 = 0 ;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char * kwnames[] = {
26062 (char *) "self",(char *) "rect", NULL
26063 };
26064
26065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26067 if (!SWIG_IsOK(res1)) {
26068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26069 }
26070 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26071 {
26072 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26073 if (!SWIG_IsOK(res2)) {
26074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26075 }
26076 if (!argp2) {
26077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26078 } else {
26079 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26080 arg2 = *temp;
26081 if (SWIG_IsNewObj(res2)) delete temp;
26082 }
26083 }
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 (arg1)->SetRect(arg2);
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_Py_Void();
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26098 PyObject *resultobj = 0;
26099 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26100 wxSize arg2 ;
26101 void *argp1 = 0 ;
26102 int res1 = 0 ;
26103 void *argp2 ;
26104 int res2 = 0 ;
26105 PyObject * obj0 = 0 ;
26106 PyObject * obj1 = 0 ;
26107 char * kwnames[] = {
26108 (char *) "self",(char *) "size", NULL
26109 };
26110
26111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26113 if (!SWIG_IsOK(res1)) {
26114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26115 }
26116 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26117 {
26118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26119 if (!SWIG_IsOK(res2)) {
26120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26121 }
26122 if (!argp2) {
26123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26124 } else {
26125 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26126 arg2 = *temp;
26127 if (SWIG_IsNewObj(res2)) delete temp;
26128 }
26129 }
26130 {
26131 PyThreadState* __tstate = wxPyBeginAllowThreads();
26132 wxSizeEvent_SetSize(arg1,arg2);
26133 wxPyEndAllowThreads(__tstate);
26134 if (PyErr_Occurred()) SWIG_fail;
26135 }
26136 resultobj = SWIG_Py_Void();
26137 return resultobj;
26138 fail:
26139 return NULL;
26140 }
26141
26142
26143 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26144 PyObject *resultobj = 0;
26145 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26146 wxSize *arg2 = (wxSize *) 0 ;
26147 void *argp1 = 0 ;
26148 int res1 = 0 ;
26149 void *argp2 = 0 ;
26150 int res2 = 0 ;
26151 PyObject *swig_obj[2] ;
26152
26153 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26155 if (!SWIG_IsOK(res1)) {
26156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26157 }
26158 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26159 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26160 if (!SWIG_IsOK(res2)) {
26161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26162 }
26163 arg2 = reinterpret_cast< wxSize * >(argp2);
26164 if (arg1) (arg1)->m_size = *arg2;
26165
26166 resultobj = SWIG_Py_Void();
26167 return resultobj;
26168 fail:
26169 return NULL;
26170 }
26171
26172
26173 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26174 PyObject *resultobj = 0;
26175 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26176 wxSize *result = 0 ;
26177 void *argp1 = 0 ;
26178 int res1 = 0 ;
26179 PyObject *swig_obj[1] ;
26180
26181 if (!args) SWIG_fail;
26182 swig_obj[0] = args;
26183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26184 if (!SWIG_IsOK(res1)) {
26185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26186 }
26187 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26188 result = (wxSize *)& ((arg1)->m_size);
26189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26190 return resultobj;
26191 fail:
26192 return NULL;
26193 }
26194
26195
26196 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26197 PyObject *resultobj = 0;
26198 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26199 wxRect *arg2 = (wxRect *) 0 ;
26200 void *argp1 = 0 ;
26201 int res1 = 0 ;
26202 void *argp2 = 0 ;
26203 int res2 = 0 ;
26204 PyObject *swig_obj[2] ;
26205
26206 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26208 if (!SWIG_IsOK(res1)) {
26209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26210 }
26211 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26212 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26213 if (!SWIG_IsOK(res2)) {
26214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26215 }
26216 arg2 = reinterpret_cast< wxRect * >(argp2);
26217 if (arg1) (arg1)->m_rect = *arg2;
26218
26219 resultobj = SWIG_Py_Void();
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26227 PyObject *resultobj = 0;
26228 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26229 wxRect *result = 0 ;
26230 void *argp1 = 0 ;
26231 int res1 = 0 ;
26232 PyObject *swig_obj[1] ;
26233
26234 if (!args) SWIG_fail;
26235 swig_obj[0] = args;
26236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26237 if (!SWIG_IsOK(res1)) {
26238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26239 }
26240 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26241 result = (wxRect *)& ((arg1)->m_rect);
26242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26250 PyObject *obj;
26251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26252 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26253 return SWIG_Py_Void();
26254 }
26255
26256 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26257 return SWIG_Python_InitShadowInstance(args);
26258 }
26259
26260 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26261 PyObject *resultobj = 0;
26262 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26263 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26264 int arg2 = (int) 0 ;
26265 wxMoveEvent *result = 0 ;
26266 wxPoint temp1 ;
26267 int val2 ;
26268 int ecode2 = 0 ;
26269 PyObject * obj0 = 0 ;
26270 PyObject * obj1 = 0 ;
26271 char * kwnames[] = {
26272 (char *) "pos",(char *) "winid", NULL
26273 };
26274
26275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26276 if (obj0) {
26277 {
26278 arg1 = &temp1;
26279 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26280 }
26281 }
26282 if (obj1) {
26283 ecode2 = SWIG_AsVal_int(obj1, &val2);
26284 if (!SWIG_IsOK(ecode2)) {
26285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26286 }
26287 arg2 = static_cast< int >(val2);
26288 }
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *resultobj = 0;
26304 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26305 wxPoint result;
26306 void *argp1 = 0 ;
26307 int res1 = 0 ;
26308 PyObject *swig_obj[1] ;
26309
26310 if (!args) SWIG_fail;
26311 swig_obj[0] = args;
26312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26315 }
26316 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = ((wxMoveEvent const *)arg1)->GetPosition();
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26331 PyObject *resultobj = 0;
26332 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26333 wxRect result;
26334 void *argp1 = 0 ;
26335 int res1 = 0 ;
26336 PyObject *swig_obj[1] ;
26337
26338 if (!args) SWIG_fail;
26339 swig_obj[0] = args;
26340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26341 if (!SWIG_IsOK(res1)) {
26342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26343 }
26344 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26345 {
26346 PyThreadState* __tstate = wxPyBeginAllowThreads();
26347 result = ((wxMoveEvent const *)arg1)->GetRect();
26348 wxPyEndAllowThreads(__tstate);
26349 if (PyErr_Occurred()) SWIG_fail;
26350 }
26351 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26352 return resultobj;
26353 fail:
26354 return NULL;
26355 }
26356
26357
26358 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26359 PyObject *resultobj = 0;
26360 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26361 wxRect *arg2 = 0 ;
26362 void *argp1 = 0 ;
26363 int res1 = 0 ;
26364 wxRect temp2 ;
26365 PyObject * obj0 = 0 ;
26366 PyObject * obj1 = 0 ;
26367 char * kwnames[] = {
26368 (char *) "self",(char *) "rect", NULL
26369 };
26370
26371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26375 }
26376 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26377 {
26378 arg2 = &temp2;
26379 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26380 }
26381 {
26382 PyThreadState* __tstate = wxPyBeginAllowThreads();
26383 (arg1)->SetRect((wxRect const &)*arg2);
26384 wxPyEndAllowThreads(__tstate);
26385 if (PyErr_Occurred()) SWIG_fail;
26386 }
26387 resultobj = SWIG_Py_Void();
26388 return resultobj;
26389 fail:
26390 return NULL;
26391 }
26392
26393
26394 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26395 PyObject *resultobj = 0;
26396 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26397 wxPoint *arg2 = 0 ;
26398 void *argp1 = 0 ;
26399 int res1 = 0 ;
26400 wxPoint temp2 ;
26401 PyObject * obj0 = 0 ;
26402 PyObject * obj1 = 0 ;
26403 char * kwnames[] = {
26404 (char *) "self",(char *) "pos", NULL
26405 };
26406
26407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26409 if (!SWIG_IsOK(res1)) {
26410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26411 }
26412 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26413 {
26414 arg2 = &temp2;
26415 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26416 }
26417 {
26418 PyThreadState* __tstate = wxPyBeginAllowThreads();
26419 (arg1)->SetPosition((wxPoint const &)*arg2);
26420 wxPyEndAllowThreads(__tstate);
26421 if (PyErr_Occurred()) SWIG_fail;
26422 }
26423 resultobj = SWIG_Py_Void();
26424 return resultobj;
26425 fail:
26426 return NULL;
26427 }
26428
26429
26430 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26431 PyObject *obj;
26432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26433 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26434 return SWIG_Py_Void();
26435 }
26436
26437 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26438 return SWIG_Python_InitShadowInstance(args);
26439 }
26440
26441 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26442 PyObject *resultobj = 0;
26443 int arg1 = (int) 0 ;
26444 wxPaintEvent *result = 0 ;
26445 int val1 ;
26446 int ecode1 = 0 ;
26447 PyObject * obj0 = 0 ;
26448 char * kwnames[] = {
26449 (char *) "Id", NULL
26450 };
26451
26452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26453 if (obj0) {
26454 ecode1 = SWIG_AsVal_int(obj0, &val1);
26455 if (!SWIG_IsOK(ecode1)) {
26456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26457 }
26458 arg1 = static_cast< int >(val1);
26459 }
26460 {
26461 PyThreadState* __tstate = wxPyBeginAllowThreads();
26462 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26463 wxPyEndAllowThreads(__tstate);
26464 if (PyErr_Occurred()) SWIG_fail;
26465 }
26466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26474 PyObject *obj;
26475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26476 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26477 return SWIG_Py_Void();
26478 }
26479
26480 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26481 return SWIG_Python_InitShadowInstance(args);
26482 }
26483
26484 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj = 0;
26486 int arg1 = (int) 0 ;
26487 wxNcPaintEvent *result = 0 ;
26488 int val1 ;
26489 int ecode1 = 0 ;
26490 PyObject * obj0 = 0 ;
26491 char * kwnames[] = {
26492 (char *) "winid", NULL
26493 };
26494
26495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26496 if (obj0) {
26497 ecode1 = SWIG_AsVal_int(obj0, &val1);
26498 if (!SWIG_IsOK(ecode1)) {
26499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26500 }
26501 arg1 = static_cast< int >(val1);
26502 }
26503 {
26504 PyThreadState* __tstate = wxPyBeginAllowThreads();
26505 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26506 wxPyEndAllowThreads(__tstate);
26507 if (PyErr_Occurred()) SWIG_fail;
26508 }
26509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26510 return resultobj;
26511 fail:
26512 return NULL;
26513 }
26514
26515
26516 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26517 PyObject *obj;
26518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26519 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26520 return SWIG_Py_Void();
26521 }
26522
26523 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26524 return SWIG_Python_InitShadowInstance(args);
26525 }
26526
26527 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26528 PyObject *resultobj = 0;
26529 int arg1 = (int) 0 ;
26530 wxDC *arg2 = (wxDC *) NULL ;
26531 wxEraseEvent *result = 0 ;
26532 int val1 ;
26533 int ecode1 = 0 ;
26534 void *argp2 = 0 ;
26535 int res2 = 0 ;
26536 PyObject * obj0 = 0 ;
26537 PyObject * obj1 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "Id",(char *) "dc", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26543 if (obj0) {
26544 ecode1 = SWIG_AsVal_int(obj0, &val1);
26545 if (!SWIG_IsOK(ecode1)) {
26546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26547 }
26548 arg1 = static_cast< int >(val1);
26549 }
26550 if (obj1) {
26551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26552 if (!SWIG_IsOK(res2)) {
26553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26554 }
26555 arg2 = reinterpret_cast< wxDC * >(argp2);
26556 }
26557 {
26558 PyThreadState* __tstate = wxPyBeginAllowThreads();
26559 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26560 wxPyEndAllowThreads(__tstate);
26561 if (PyErr_Occurred()) SWIG_fail;
26562 }
26563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26564 return resultobj;
26565 fail:
26566 return NULL;
26567 }
26568
26569
26570 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26571 PyObject *resultobj = 0;
26572 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26573 wxDC *result = 0 ;
26574 void *argp1 = 0 ;
26575 int res1 = 0 ;
26576 PyObject *swig_obj[1] ;
26577
26578 if (!args) SWIG_fail;
26579 swig_obj[0] = args;
26580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26581 if (!SWIG_IsOK(res1)) {
26582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26583 }
26584 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26585 {
26586 PyThreadState* __tstate = wxPyBeginAllowThreads();
26587 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26588 wxPyEndAllowThreads(__tstate);
26589 if (PyErr_Occurred()) SWIG_fail;
26590 }
26591 {
26592 resultobj = wxPyMake_wxObject(result, (bool)0);
26593 }
26594 return resultobj;
26595 fail:
26596 return NULL;
26597 }
26598
26599
26600 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26601 PyObject *obj;
26602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26603 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26604 return SWIG_Py_Void();
26605 }
26606
26607 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26608 return SWIG_Python_InitShadowInstance(args);
26609 }
26610
26611 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26612 PyObject *resultobj = 0;
26613 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26614 int arg2 = (int) 0 ;
26615 wxFocusEvent *result = 0 ;
26616 int val1 ;
26617 int ecode1 = 0 ;
26618 int val2 ;
26619 int ecode2 = 0 ;
26620 PyObject * obj0 = 0 ;
26621 PyObject * obj1 = 0 ;
26622 char * kwnames[] = {
26623 (char *) "type",(char *) "winid", NULL
26624 };
26625
26626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26627 if (obj0) {
26628 ecode1 = SWIG_AsVal_int(obj0, &val1);
26629 if (!SWIG_IsOK(ecode1)) {
26630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26631 }
26632 arg1 = static_cast< wxEventType >(val1);
26633 }
26634 if (obj1) {
26635 ecode2 = SWIG_AsVal_int(obj1, &val2);
26636 if (!SWIG_IsOK(ecode2)) {
26637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26638 }
26639 arg2 = static_cast< int >(val2);
26640 }
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26655 PyObject *resultobj = 0;
26656 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26657 wxWindow *result = 0 ;
26658 void *argp1 = 0 ;
26659 int res1 = 0 ;
26660 PyObject *swig_obj[1] ;
26661
26662 if (!args) SWIG_fail;
26663 swig_obj[0] = args;
26664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26665 if (!SWIG_IsOK(res1)) {
26666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26667 }
26668 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 {
26676 resultobj = wxPyMake_wxObject(result, (bool)0);
26677 }
26678 return resultobj;
26679 fail:
26680 return NULL;
26681 }
26682
26683
26684 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26685 PyObject *resultobj = 0;
26686 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26687 wxWindow *arg2 = (wxWindow *) 0 ;
26688 void *argp1 = 0 ;
26689 int res1 = 0 ;
26690 void *argp2 = 0 ;
26691 int res2 = 0 ;
26692 PyObject * obj0 = 0 ;
26693 PyObject * obj1 = 0 ;
26694 char * kwnames[] = {
26695 (char *) "self",(char *) "win", NULL
26696 };
26697
26698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26700 if (!SWIG_IsOK(res1)) {
26701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26702 }
26703 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26705 if (!SWIG_IsOK(res2)) {
26706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26707 }
26708 arg2 = reinterpret_cast< wxWindow * >(argp2);
26709 {
26710 PyThreadState* __tstate = wxPyBeginAllowThreads();
26711 (arg1)->SetWindow(arg2);
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 resultobj = SWIG_Py_Void();
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26723 PyObject *obj;
26724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26725 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26726 return SWIG_Py_Void();
26727 }
26728
26729 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26730 return SWIG_Python_InitShadowInstance(args);
26731 }
26732
26733 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26734 PyObject *resultobj = 0;
26735 wxWindow *arg1 = (wxWindow *) NULL ;
26736 wxChildFocusEvent *result = 0 ;
26737 void *argp1 = 0 ;
26738 int res1 = 0 ;
26739 PyObject * obj0 = 0 ;
26740 char * kwnames[] = {
26741 (char *) "win", NULL
26742 };
26743
26744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26745 if (obj0) {
26746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26747 if (!SWIG_IsOK(res1)) {
26748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26749 }
26750 arg1 = reinterpret_cast< wxWindow * >(argp1);
26751 }
26752 {
26753 PyThreadState* __tstate = wxPyBeginAllowThreads();
26754 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26755 wxPyEndAllowThreads(__tstate);
26756 if (PyErr_Occurred()) SWIG_fail;
26757 }
26758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26766 PyObject *resultobj = 0;
26767 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26768 wxWindow *result = 0 ;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 PyObject *swig_obj[1] ;
26772
26773 if (!args) SWIG_fail;
26774 swig_obj[0] = args;
26775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26776 if (!SWIG_IsOK(res1)) {
26777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26778 }
26779 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 {
26787 resultobj = wxPyMake_wxObject(result, (bool)0);
26788 }
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *obj;
26797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26798 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26799 return SWIG_Py_Void();
26800 }
26801
26802 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26803 return SWIG_Python_InitShadowInstance(args);
26804 }
26805
26806 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26807 PyObject *resultobj = 0;
26808 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26809 bool arg2 = (bool) true ;
26810 int arg3 = (int) 0 ;
26811 wxActivateEvent *result = 0 ;
26812 int val1 ;
26813 int ecode1 = 0 ;
26814 bool val2 ;
26815 int ecode2 = 0 ;
26816 int val3 ;
26817 int ecode3 = 0 ;
26818 PyObject * obj0 = 0 ;
26819 PyObject * obj1 = 0 ;
26820 PyObject * obj2 = 0 ;
26821 char * kwnames[] = {
26822 (char *) "type",(char *) "active",(char *) "Id", NULL
26823 };
26824
26825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26826 if (obj0) {
26827 ecode1 = SWIG_AsVal_int(obj0, &val1);
26828 if (!SWIG_IsOK(ecode1)) {
26829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26830 }
26831 arg1 = static_cast< wxEventType >(val1);
26832 }
26833 if (obj1) {
26834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26835 if (!SWIG_IsOK(ecode2)) {
26836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26837 }
26838 arg2 = static_cast< bool >(val2);
26839 }
26840 if (obj2) {
26841 ecode3 = SWIG_AsVal_int(obj2, &val3);
26842 if (!SWIG_IsOK(ecode3)) {
26843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26844 }
26845 arg3 = static_cast< int >(val3);
26846 }
26847 {
26848 PyThreadState* __tstate = wxPyBeginAllowThreads();
26849 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26850 wxPyEndAllowThreads(__tstate);
26851 if (PyErr_Occurred()) SWIG_fail;
26852 }
26853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26854 return resultobj;
26855 fail:
26856 return NULL;
26857 }
26858
26859
26860 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26861 PyObject *resultobj = 0;
26862 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26863 bool result;
26864 void *argp1 = 0 ;
26865 int res1 = 0 ;
26866 PyObject *swig_obj[1] ;
26867
26868 if (!args) SWIG_fail;
26869 swig_obj[0] = args;
26870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26871 if (!SWIG_IsOK(res1)) {
26872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26873 }
26874 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26875 {
26876 PyThreadState* __tstate = wxPyBeginAllowThreads();
26877 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 {
26882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26883 }
26884 return resultobj;
26885 fail:
26886 return NULL;
26887 }
26888
26889
26890 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26891 PyObject *obj;
26892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26893 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26894 return SWIG_Py_Void();
26895 }
26896
26897 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26898 return SWIG_Python_InitShadowInstance(args);
26899 }
26900
26901 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj = 0;
26903 int arg1 = (int) 0 ;
26904 wxInitDialogEvent *result = 0 ;
26905 int val1 ;
26906 int ecode1 = 0 ;
26907 PyObject * obj0 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "Id", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26913 if (obj0) {
26914 ecode1 = SWIG_AsVal_int(obj0, &val1);
26915 if (!SWIG_IsOK(ecode1)) {
26916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26917 }
26918 arg1 = static_cast< int >(val1);
26919 }
26920 {
26921 PyThreadState* __tstate = wxPyBeginAllowThreads();
26922 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26923 wxPyEndAllowThreads(__tstate);
26924 if (PyErr_Occurred()) SWIG_fail;
26925 }
26926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26927 return resultobj;
26928 fail:
26929 return NULL;
26930 }
26931
26932
26933 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26934 PyObject *obj;
26935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26936 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26937 return SWIG_Py_Void();
26938 }
26939
26940 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26941 return SWIG_Python_InitShadowInstance(args);
26942 }
26943
26944 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj = 0;
26946 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26947 int arg2 = (int) 0 ;
26948 wxMenu *arg3 = (wxMenu *) NULL ;
26949 wxMenuEvent *result = 0 ;
26950 int val1 ;
26951 int ecode1 = 0 ;
26952 int val2 ;
26953 int ecode2 = 0 ;
26954 void *argp3 = 0 ;
26955 int res3 = 0 ;
26956 PyObject * obj0 = 0 ;
26957 PyObject * obj1 = 0 ;
26958 PyObject * obj2 = 0 ;
26959 char * kwnames[] = {
26960 (char *) "type",(char *) "winid",(char *) "menu", NULL
26961 };
26962
26963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26964 if (obj0) {
26965 ecode1 = SWIG_AsVal_int(obj0, &val1);
26966 if (!SWIG_IsOK(ecode1)) {
26967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26968 }
26969 arg1 = static_cast< wxEventType >(val1);
26970 }
26971 if (obj1) {
26972 ecode2 = SWIG_AsVal_int(obj1, &val2);
26973 if (!SWIG_IsOK(ecode2)) {
26974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26975 }
26976 arg2 = static_cast< int >(val2);
26977 }
26978 if (obj2) {
26979 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26980 if (!SWIG_IsOK(res3)) {
26981 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26982 }
26983 arg3 = reinterpret_cast< wxMenu * >(argp3);
26984 }
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26992 return resultobj;
26993 fail:
26994 return NULL;
26995 }
26996
26997
26998 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26999 PyObject *resultobj = 0;
27000 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27001 int result;
27002 void *argp1 = 0 ;
27003 int res1 = 0 ;
27004 PyObject *swig_obj[1] ;
27005
27006 if (!args) SWIG_fail;
27007 swig_obj[0] = args;
27008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27009 if (!SWIG_IsOK(res1)) {
27010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27011 }
27012 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27013 {
27014 PyThreadState* __tstate = wxPyBeginAllowThreads();
27015 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27016 wxPyEndAllowThreads(__tstate);
27017 if (PyErr_Occurred()) SWIG_fail;
27018 }
27019 resultobj = SWIG_From_int(static_cast< int >(result));
27020 return resultobj;
27021 fail:
27022 return NULL;
27023 }
27024
27025
27026 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27027 PyObject *resultobj = 0;
27028 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27029 bool result;
27030 void *argp1 = 0 ;
27031 int res1 = 0 ;
27032 PyObject *swig_obj[1] ;
27033
27034 if (!args) SWIG_fail;
27035 swig_obj[0] = args;
27036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27037 if (!SWIG_IsOK(res1)) {
27038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27039 }
27040 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 {
27048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27049 }
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27057 PyObject *resultobj = 0;
27058 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27059 wxMenu *result = 0 ;
27060 void *argp1 = 0 ;
27061 int res1 = 0 ;
27062 PyObject *swig_obj[1] ;
27063
27064 if (!args) SWIG_fail;
27065 swig_obj[0] = args;
27066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27067 if (!SWIG_IsOK(res1)) {
27068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27069 }
27070 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27071 {
27072 PyThreadState* __tstate = wxPyBeginAllowThreads();
27073 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27074 wxPyEndAllowThreads(__tstate);
27075 if (PyErr_Occurred()) SWIG_fail;
27076 }
27077 {
27078 resultobj = wxPyMake_wxObject(result, (bool)0);
27079 }
27080 return resultobj;
27081 fail:
27082 return NULL;
27083 }
27084
27085
27086 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27087 PyObject *obj;
27088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27089 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27090 return SWIG_Py_Void();
27091 }
27092
27093 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27094 return SWIG_Python_InitShadowInstance(args);
27095 }
27096
27097 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj = 0;
27099 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27100 int arg2 = (int) 0 ;
27101 wxCloseEvent *result = 0 ;
27102 int val1 ;
27103 int ecode1 = 0 ;
27104 int val2 ;
27105 int ecode2 = 0 ;
27106 PyObject * obj0 = 0 ;
27107 PyObject * obj1 = 0 ;
27108 char * kwnames[] = {
27109 (char *) "type",(char *) "winid", NULL
27110 };
27111
27112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27113 if (obj0) {
27114 ecode1 = SWIG_AsVal_int(obj0, &val1);
27115 if (!SWIG_IsOK(ecode1)) {
27116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27117 }
27118 arg1 = static_cast< wxEventType >(val1);
27119 }
27120 if (obj1) {
27121 ecode2 = SWIG_AsVal_int(obj1, &val2);
27122 if (!SWIG_IsOK(ecode2)) {
27123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27124 }
27125 arg2 = static_cast< int >(val2);
27126 }
27127 {
27128 PyThreadState* __tstate = wxPyBeginAllowThreads();
27129 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj = 0;
27142 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27143 bool arg2 ;
27144 void *argp1 = 0 ;
27145 int res1 = 0 ;
27146 bool val2 ;
27147 int ecode2 = 0 ;
27148 PyObject * obj0 = 0 ;
27149 PyObject * obj1 = 0 ;
27150 char * kwnames[] = {
27151 (char *) "self",(char *) "logOff", NULL
27152 };
27153
27154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27156 if (!SWIG_IsOK(res1)) {
27157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27158 }
27159 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27160 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27161 if (!SWIG_IsOK(ecode2)) {
27162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27163 }
27164 arg2 = static_cast< bool >(val2);
27165 {
27166 PyThreadState* __tstate = wxPyBeginAllowThreads();
27167 (arg1)->SetLoggingOff(arg2);
27168 wxPyEndAllowThreads(__tstate);
27169 if (PyErr_Occurred()) SWIG_fail;
27170 }
27171 resultobj = SWIG_Py_Void();
27172 return resultobj;
27173 fail:
27174 return NULL;
27175 }
27176
27177
27178 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27179 PyObject *resultobj = 0;
27180 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27181 bool result;
27182 void *argp1 = 0 ;
27183 int res1 = 0 ;
27184 PyObject *swig_obj[1] ;
27185
27186 if (!args) SWIG_fail;
27187 swig_obj[0] = args;
27188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27189 if (!SWIG_IsOK(res1)) {
27190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27191 }
27192 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 {
27200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27201 }
27202 return resultobj;
27203 fail:
27204 return NULL;
27205 }
27206
27207
27208 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27209 PyObject *resultobj = 0;
27210 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27211 bool arg2 = (bool) true ;
27212 void *argp1 = 0 ;
27213 int res1 = 0 ;
27214 bool val2 ;
27215 int ecode2 = 0 ;
27216 PyObject * obj0 = 0 ;
27217 PyObject * obj1 = 0 ;
27218 char * kwnames[] = {
27219 (char *) "self",(char *) "veto", NULL
27220 };
27221
27222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27224 if (!SWIG_IsOK(res1)) {
27225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27226 }
27227 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27228 if (obj1) {
27229 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27230 if (!SWIG_IsOK(ecode2)) {
27231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27232 }
27233 arg2 = static_cast< bool >(val2);
27234 }
27235 {
27236 PyThreadState* __tstate = wxPyBeginAllowThreads();
27237 (arg1)->Veto(arg2);
27238 wxPyEndAllowThreads(__tstate);
27239 if (PyErr_Occurred()) SWIG_fail;
27240 }
27241 resultobj = SWIG_Py_Void();
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27249 PyObject *resultobj = 0;
27250 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27251 bool result;
27252 void *argp1 = 0 ;
27253 int res1 = 0 ;
27254 PyObject *swig_obj[1] ;
27255
27256 if (!args) SWIG_fail;
27257 swig_obj[0] = args;
27258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27259 if (!SWIG_IsOK(res1)) {
27260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27261 }
27262 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 {
27270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27271 }
27272 return resultobj;
27273 fail:
27274 return NULL;
27275 }
27276
27277
27278 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27279 PyObject *resultobj = 0;
27280 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27281 bool arg2 ;
27282 void *argp1 = 0 ;
27283 int res1 = 0 ;
27284 bool val2 ;
27285 int ecode2 = 0 ;
27286 PyObject * obj0 = 0 ;
27287 PyObject * obj1 = 0 ;
27288 char * kwnames[] = {
27289 (char *) "self",(char *) "canVeto", NULL
27290 };
27291
27292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27294 if (!SWIG_IsOK(res1)) {
27295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27296 }
27297 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27298 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27299 if (!SWIG_IsOK(ecode2)) {
27300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27301 }
27302 arg2 = static_cast< bool >(val2);
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 (arg1)->SetCanVeto(arg2);
27306 wxPyEndAllowThreads(__tstate);
27307 if (PyErr_Occurred()) SWIG_fail;
27308 }
27309 resultobj = SWIG_Py_Void();
27310 return resultobj;
27311 fail:
27312 return NULL;
27313 }
27314
27315
27316 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27317 PyObject *resultobj = 0;
27318 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27319 bool result;
27320 void *argp1 = 0 ;
27321 int res1 = 0 ;
27322 PyObject *swig_obj[1] ;
27323
27324 if (!args) SWIG_fail;
27325 swig_obj[0] = args;
27326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27329 }
27330 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 {
27338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27339 }
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27347 PyObject *obj;
27348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27349 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27350 return SWIG_Py_Void();
27351 }
27352
27353 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27354 return SWIG_Python_InitShadowInstance(args);
27355 }
27356
27357 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj = 0;
27359 int arg1 = (int) 0 ;
27360 bool arg2 = (bool) false ;
27361 wxShowEvent *result = 0 ;
27362 int val1 ;
27363 int ecode1 = 0 ;
27364 bool val2 ;
27365 int ecode2 = 0 ;
27366 PyObject * obj0 = 0 ;
27367 PyObject * obj1 = 0 ;
27368 char * kwnames[] = {
27369 (char *) "winid",(char *) "show", NULL
27370 };
27371
27372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27373 if (obj0) {
27374 ecode1 = SWIG_AsVal_int(obj0, &val1);
27375 if (!SWIG_IsOK(ecode1)) {
27376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27377 }
27378 arg1 = static_cast< int >(val1);
27379 }
27380 if (obj1) {
27381 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27382 if (!SWIG_IsOK(ecode2)) {
27383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27384 }
27385 arg2 = static_cast< bool >(val2);
27386 }
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27401 PyObject *resultobj = 0;
27402 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27403 bool arg2 ;
27404 void *argp1 = 0 ;
27405 int res1 = 0 ;
27406 bool val2 ;
27407 int ecode2 = 0 ;
27408 PyObject * obj0 = 0 ;
27409 PyObject * obj1 = 0 ;
27410 char * kwnames[] = {
27411 (char *) "self",(char *) "show", NULL
27412 };
27413
27414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27416 if (!SWIG_IsOK(res1)) {
27417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27418 }
27419 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27420 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27421 if (!SWIG_IsOK(ecode2)) {
27422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27423 }
27424 arg2 = static_cast< bool >(val2);
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 (arg1)->SetShow(arg2);
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_Py_Void();
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *resultobj = 0;
27440 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27441 bool result;
27442 void *argp1 = 0 ;
27443 int res1 = 0 ;
27444 PyObject *swig_obj[1] ;
27445
27446 if (!args) SWIG_fail;
27447 swig_obj[0] = args;
27448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27451 }
27452 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 {
27460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27461 }
27462 return resultobj;
27463 fail:
27464 return NULL;
27465 }
27466
27467
27468 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27469 PyObject *obj;
27470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27471 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27472 return SWIG_Py_Void();
27473 }
27474
27475 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 return SWIG_Python_InitShadowInstance(args);
27477 }
27478
27479 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27480 PyObject *resultobj = 0;
27481 int arg1 = (int) 0 ;
27482 bool arg2 = (bool) true ;
27483 wxIconizeEvent *result = 0 ;
27484 int val1 ;
27485 int ecode1 = 0 ;
27486 bool val2 ;
27487 int ecode2 = 0 ;
27488 PyObject * obj0 = 0 ;
27489 PyObject * obj1 = 0 ;
27490 char * kwnames[] = {
27491 (char *) "id",(char *) "iconized", NULL
27492 };
27493
27494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27495 if (obj0) {
27496 ecode1 = SWIG_AsVal_int(obj0, &val1);
27497 if (!SWIG_IsOK(ecode1)) {
27498 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27499 }
27500 arg1 = static_cast< int >(val1);
27501 }
27502 if (obj1) {
27503 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27504 if (!SWIG_IsOK(ecode2)) {
27505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27506 }
27507 arg2 = static_cast< bool >(val2);
27508 }
27509 {
27510 PyThreadState* __tstate = wxPyBeginAllowThreads();
27511 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27523 PyObject *resultobj = 0;
27524 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27525 bool result;
27526 void *argp1 = 0 ;
27527 int res1 = 0 ;
27528 PyObject *swig_obj[1] ;
27529
27530 if (!args) SWIG_fail;
27531 swig_obj[0] = args;
27532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27533 if (!SWIG_IsOK(res1)) {
27534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27535 }
27536 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = (bool)(arg1)->Iconized();
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 {
27544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27545 }
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27553 PyObject *obj;
27554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27555 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27556 return SWIG_Py_Void();
27557 }
27558
27559 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27560 return SWIG_Python_InitShadowInstance(args);
27561 }
27562
27563 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27564 PyObject *resultobj = 0;
27565 int arg1 = (int) 0 ;
27566 wxMaximizeEvent *result = 0 ;
27567 int val1 ;
27568 int ecode1 = 0 ;
27569 PyObject * obj0 = 0 ;
27570 char * kwnames[] = {
27571 (char *) "id", NULL
27572 };
27573
27574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27575 if (obj0) {
27576 ecode1 = SWIG_AsVal_int(obj0, &val1);
27577 if (!SWIG_IsOK(ecode1)) {
27578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27579 }
27580 arg1 = static_cast< int >(val1);
27581 }
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *obj;
27597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27598 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27599 return SWIG_Py_Void();
27600 }
27601
27602 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27603 return SWIG_Python_InitShadowInstance(args);
27604 }
27605
27606 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27607 PyObject *resultobj = 0;
27608 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27609 wxPoint result;
27610 void *argp1 = 0 ;
27611 int res1 = 0 ;
27612 PyObject *swig_obj[1] ;
27613
27614 if (!args) SWIG_fail;
27615 swig_obj[0] = args;
27616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27617 if (!SWIG_IsOK(res1)) {
27618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27619 }
27620 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27621 {
27622 PyThreadState* __tstate = wxPyBeginAllowThreads();
27623 result = (arg1)->GetPosition();
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27628 return resultobj;
27629 fail:
27630 return NULL;
27631 }
27632
27633
27634 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27635 PyObject *resultobj = 0;
27636 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27637 int result;
27638 void *argp1 = 0 ;
27639 int res1 = 0 ;
27640 PyObject *swig_obj[1] ;
27641
27642 if (!args) SWIG_fail;
27643 swig_obj[0] = args;
27644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27645 if (!SWIG_IsOK(res1)) {
27646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27647 }
27648 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (int)(arg1)->GetNumberOfFiles();
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = SWIG_From_int(static_cast< int >(result));
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27665 PyObject *result = 0 ;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27675 }
27676 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 resultobj = result;
27684 return resultobj;
27685 fail:
27686 return NULL;
27687 }
27688
27689
27690 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27691 PyObject *obj;
27692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27693 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27694 return SWIG_Py_Void();
27695 }
27696
27697 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj = 0;
27699 int arg1 = (int) 0 ;
27700 wxUpdateUIEvent *result = 0 ;
27701 int val1 ;
27702 int ecode1 = 0 ;
27703 PyObject * obj0 = 0 ;
27704 char * kwnames[] = {
27705 (char *) "commandId", NULL
27706 };
27707
27708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27709 if (obj0) {
27710 ecode1 = SWIG_AsVal_int(obj0, &val1);
27711 if (!SWIG_IsOK(ecode1)) {
27712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27713 }
27714 arg1 = static_cast< int >(val1);
27715 }
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27730 PyObject *resultobj = 0;
27731 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27732 bool result;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 PyObject *swig_obj[1] ;
27736
27737 if (!args) SWIG_fail;
27738 swig_obj[0] = args;
27739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27740 if (!SWIG_IsOK(res1)) {
27741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27742 }
27743 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27747 wxPyEndAllowThreads(__tstate);
27748 if (PyErr_Occurred()) SWIG_fail;
27749 }
27750 {
27751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27752 }
27753 return resultobj;
27754 fail:
27755 return NULL;
27756 }
27757
27758
27759 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27760 PyObject *resultobj = 0;
27761 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27762 bool result;
27763 void *argp1 = 0 ;
27764 int res1 = 0 ;
27765 PyObject *swig_obj[1] ;
27766
27767 if (!args) SWIG_fail;
27768 swig_obj[0] = args;
27769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27770 if (!SWIG_IsOK(res1)) {
27771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27772 }
27773 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27777 wxPyEndAllowThreads(__tstate);
27778 if (PyErr_Occurred()) SWIG_fail;
27779 }
27780 {
27781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27782 }
27783 return resultobj;
27784 fail:
27785 return NULL;
27786 }
27787
27788
27789 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27790 PyObject *resultobj = 0;
27791 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27792 bool result;
27793 void *argp1 = 0 ;
27794 int res1 = 0 ;
27795 PyObject *swig_obj[1] ;
27796
27797 if (!args) SWIG_fail;
27798 swig_obj[0] = args;
27799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27800 if (!SWIG_IsOK(res1)) {
27801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27802 }
27803 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 {
27811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27812 }
27813 return resultobj;
27814 fail:
27815 return NULL;
27816 }
27817
27818
27819 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27820 PyObject *resultobj = 0;
27821 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27822 wxString result;
27823 void *argp1 = 0 ;
27824 int res1 = 0 ;
27825 PyObject *swig_obj[1] ;
27826
27827 if (!args) SWIG_fail;
27828 swig_obj[0] = args;
27829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27830 if (!SWIG_IsOK(res1)) {
27831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27832 }
27833 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 {
27841 #if wxUSE_UNICODE
27842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27843 #else
27844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27845 #endif
27846 }
27847 return resultobj;
27848 fail:
27849 return NULL;
27850 }
27851
27852
27853 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27854 PyObject *resultobj = 0;
27855 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27856 bool result;
27857 void *argp1 = 0 ;
27858 int res1 = 0 ;
27859 PyObject *swig_obj[1] ;
27860
27861 if (!args) SWIG_fail;
27862 swig_obj[0] = args;
27863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27864 if (!SWIG_IsOK(res1)) {
27865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27866 }
27867 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 {
27875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27876 }
27877 return resultobj;
27878 fail:
27879 return NULL;
27880 }
27881
27882
27883 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27884 PyObject *resultobj = 0;
27885 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27886 bool result;
27887 void *argp1 = 0 ;
27888 int res1 = 0 ;
27889 PyObject *swig_obj[1] ;
27890
27891 if (!args) SWIG_fail;
27892 swig_obj[0] = args;
27893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27894 if (!SWIG_IsOK(res1)) {
27895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27896 }
27897 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27898 {
27899 PyThreadState* __tstate = wxPyBeginAllowThreads();
27900 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27901 wxPyEndAllowThreads(__tstate);
27902 if (PyErr_Occurred()) SWIG_fail;
27903 }
27904 {
27905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27906 }
27907 return resultobj;
27908 fail:
27909 return NULL;
27910 }
27911
27912
27913 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27914 PyObject *resultobj = 0;
27915 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27916 bool result;
27917 void *argp1 = 0 ;
27918 int res1 = 0 ;
27919 PyObject *swig_obj[1] ;
27920
27921 if (!args) SWIG_fail;
27922 swig_obj[0] = args;
27923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27924 if (!SWIG_IsOK(res1)) {
27925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27926 }
27927 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27931 wxPyEndAllowThreads(__tstate);
27932 if (PyErr_Occurred()) SWIG_fail;
27933 }
27934 {
27935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27936 }
27937 return resultobj;
27938 fail:
27939 return NULL;
27940 }
27941
27942
27943 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27944 PyObject *resultobj = 0;
27945 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27946 bool result;
27947 void *argp1 = 0 ;
27948 int res1 = 0 ;
27949 PyObject *swig_obj[1] ;
27950
27951 if (!args) SWIG_fail;
27952 swig_obj[0] = args;
27953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27954 if (!SWIG_IsOK(res1)) {
27955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27956 }
27957 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27958 {
27959 PyThreadState* __tstate = wxPyBeginAllowThreads();
27960 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27961 wxPyEndAllowThreads(__tstate);
27962 if (PyErr_Occurred()) SWIG_fail;
27963 }
27964 {
27965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27966 }
27967 return resultobj;
27968 fail:
27969 return NULL;
27970 }
27971
27972
27973 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27974 PyObject *resultobj = 0;
27975 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27976 bool arg2 ;
27977 void *argp1 = 0 ;
27978 int res1 = 0 ;
27979 bool val2 ;
27980 int ecode2 = 0 ;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char * kwnames[] = {
27984 (char *) "self",(char *) "check", NULL
27985 };
27986
27987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27989 if (!SWIG_IsOK(res1)) {
27990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27991 }
27992 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27994 if (!SWIG_IsOK(ecode2)) {
27995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27996 }
27997 arg2 = static_cast< bool >(val2);
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 (arg1)->Check(arg2);
28001 wxPyEndAllowThreads(__tstate);
28002 if (PyErr_Occurred()) SWIG_fail;
28003 }
28004 resultobj = SWIG_Py_Void();
28005 return resultobj;
28006 fail:
28007 return NULL;
28008 }
28009
28010
28011 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28012 PyObject *resultobj = 0;
28013 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28014 bool arg2 ;
28015 void *argp1 = 0 ;
28016 int res1 = 0 ;
28017 bool val2 ;
28018 int ecode2 = 0 ;
28019 PyObject * obj0 = 0 ;
28020 PyObject * obj1 = 0 ;
28021 char * kwnames[] = {
28022 (char *) "self",(char *) "enable", NULL
28023 };
28024
28025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28027 if (!SWIG_IsOK(res1)) {
28028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28029 }
28030 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28032 if (!SWIG_IsOK(ecode2)) {
28033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28034 }
28035 arg2 = static_cast< bool >(val2);
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 (arg1)->Enable(arg2);
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_Py_Void();
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj = 0;
28051 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28052 bool arg2 ;
28053 void *argp1 = 0 ;
28054 int res1 = 0 ;
28055 bool val2 ;
28056 int ecode2 = 0 ;
28057 PyObject * obj0 = 0 ;
28058 PyObject * obj1 = 0 ;
28059 char * kwnames[] = {
28060 (char *) "self",(char *) "show", NULL
28061 };
28062
28063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28065 if (!SWIG_IsOK(res1)) {
28066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28067 }
28068 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28070 if (!SWIG_IsOK(ecode2)) {
28071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28072 }
28073 arg2 = static_cast< bool >(val2);
28074 {
28075 PyThreadState* __tstate = wxPyBeginAllowThreads();
28076 (arg1)->Show(arg2);
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 resultobj = SWIG_Py_Void();
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28088 PyObject *resultobj = 0;
28089 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28090 wxString *arg2 = 0 ;
28091 void *argp1 = 0 ;
28092 int res1 = 0 ;
28093 bool temp2 = false ;
28094 PyObject * obj0 = 0 ;
28095 PyObject * obj1 = 0 ;
28096 char * kwnames[] = {
28097 (char *) "self",(char *) "text", NULL
28098 };
28099
28100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28102 if (!SWIG_IsOK(res1)) {
28103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28104 }
28105 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28106 {
28107 arg2 = wxString_in_helper(obj1);
28108 if (arg2 == NULL) SWIG_fail;
28109 temp2 = true;
28110 }
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 (arg1)->SetText((wxString const &)*arg2);
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 resultobj = SWIG_Py_Void();
28118 {
28119 if (temp2)
28120 delete arg2;
28121 }
28122 return resultobj;
28123 fail:
28124 {
28125 if (temp2)
28126 delete arg2;
28127 }
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 long arg1 ;
28135 long val1 ;
28136 int ecode1 = 0 ;
28137 PyObject * obj0 = 0 ;
28138 char * kwnames[] = {
28139 (char *) "updateInterval", NULL
28140 };
28141
28142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28143 ecode1 = SWIG_AsVal_long(obj0, &val1);
28144 if (!SWIG_IsOK(ecode1)) {
28145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28146 }
28147 arg1 = static_cast< long >(val1);
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxUpdateUIEvent::SetUpdateInterval(arg1);
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28162 PyObject *resultobj = 0;
28163 long result;
28164
28165 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 resultobj = SWIG_From_long(static_cast< long >(result));
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 wxWindow *arg1 = (wxWindow *) 0 ;
28182 bool result;
28183 void *argp1 = 0 ;
28184 int res1 = 0 ;
28185 PyObject * obj0 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "win", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28192 if (!SWIG_IsOK(res1)) {
28193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28194 }
28195 arg1 = reinterpret_cast< wxWindow * >(argp1);
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 {
28203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28204 }
28205 return resultobj;
28206 fail:
28207 return NULL;
28208 }
28209
28210
28211 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28212 PyObject *resultobj = 0;
28213
28214 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28215 {
28216 PyThreadState* __tstate = wxPyBeginAllowThreads();
28217 wxUpdateUIEvent::ResetUpdateTime();
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 resultobj = SWIG_Py_Void();
28222 return resultobj;
28223 fail:
28224 return NULL;
28225 }
28226
28227
28228 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28229 PyObject *resultobj = 0;
28230 wxUpdateUIMode arg1 ;
28231 int val1 ;
28232 int ecode1 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "mode", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28239 ecode1 = SWIG_AsVal_int(obj0, &val1);
28240 if (!SWIG_IsOK(ecode1)) {
28241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28242 }
28243 arg1 = static_cast< wxUpdateUIMode >(val1);
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 wxUpdateUIEvent::SetMode(arg1);
28247 wxPyEndAllowThreads(__tstate);
28248 if (PyErr_Occurred()) SWIG_fail;
28249 }
28250 resultobj = SWIG_Py_Void();
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28258 PyObject *resultobj = 0;
28259 wxUpdateUIMode result;
28260
28261 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = SWIG_From_int(static_cast< int >(result));
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28276 PyObject *obj;
28277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28278 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28279 return SWIG_Py_Void();
28280 }
28281
28282 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28283 return SWIG_Python_InitShadowInstance(args);
28284 }
28285
28286 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28287 PyObject *resultobj = 0;
28288 wxSysColourChangedEvent *result = 0 ;
28289
28290 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *obj;
28306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28307 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28308 return SWIG_Py_Void();
28309 }
28310
28311 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 return SWIG_Python_InitShadowInstance(args);
28313 }
28314
28315 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28316 PyObject *resultobj = 0;
28317 int arg1 = (int) 0 ;
28318 wxWindow *arg2 = (wxWindow *) NULL ;
28319 wxMouseCaptureChangedEvent *result = 0 ;
28320 int val1 ;
28321 int ecode1 = 0 ;
28322 void *argp2 = 0 ;
28323 int res2 = 0 ;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 char * kwnames[] = {
28327 (char *) "winid",(char *) "gainedCapture", NULL
28328 };
28329
28330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28331 if (obj0) {
28332 ecode1 = SWIG_AsVal_int(obj0, &val1);
28333 if (!SWIG_IsOK(ecode1)) {
28334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28335 }
28336 arg1 = static_cast< int >(val1);
28337 }
28338 if (obj1) {
28339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28340 if (!SWIG_IsOK(res2)) {
28341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28342 }
28343 arg2 = reinterpret_cast< wxWindow * >(argp2);
28344 }
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 PyObject *resultobj = 0;
28360 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28361 wxWindow *result = 0 ;
28362 void *argp1 = 0 ;
28363 int res1 = 0 ;
28364 PyObject *swig_obj[1] ;
28365
28366 if (!args) SWIG_fail;
28367 swig_obj[0] = args;
28368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28369 if (!SWIG_IsOK(res1)) {
28370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28371 }
28372 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 resultobj = wxPyMake_wxObject(result, (bool)0);
28381 }
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 PyObject *obj;
28390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28391 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28392 return SWIG_Py_Void();
28393 }
28394
28395 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28396 return SWIG_Python_InitShadowInstance(args);
28397 }
28398
28399 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28400 PyObject *resultobj = 0;
28401 int arg1 = (int) 0 ;
28402 wxMouseCaptureLostEvent *result = 0 ;
28403 int val1 ;
28404 int ecode1 = 0 ;
28405 PyObject * obj0 = 0 ;
28406 char * kwnames[] = {
28407 (char *) "winid", NULL
28408 };
28409
28410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28411 if (obj0) {
28412 ecode1 = SWIG_AsVal_int(obj0, &val1);
28413 if (!SWIG_IsOK(ecode1)) {
28414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28415 }
28416 arg1 = static_cast< int >(val1);
28417 }
28418 {
28419 PyThreadState* __tstate = wxPyBeginAllowThreads();
28420 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28425 return resultobj;
28426 fail:
28427 return NULL;
28428 }
28429
28430
28431 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28432 PyObject *obj;
28433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28434 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28435 return SWIG_Py_Void();
28436 }
28437
28438 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 return SWIG_Python_InitShadowInstance(args);
28440 }
28441
28442 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28443 PyObject *resultobj = 0;
28444 wxDisplayChangedEvent *result = 0 ;
28445
28446 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28447 {
28448 PyThreadState* __tstate = wxPyBeginAllowThreads();
28449 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28461 PyObject *obj;
28462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28463 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28464 return SWIG_Py_Void();
28465 }
28466
28467 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28468 return SWIG_Python_InitShadowInstance(args);
28469 }
28470
28471 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28472 PyObject *resultobj = 0;
28473 int arg1 = (int) 0 ;
28474 wxPaletteChangedEvent *result = 0 ;
28475 int val1 ;
28476 int ecode1 = 0 ;
28477 PyObject * obj0 = 0 ;
28478 char * kwnames[] = {
28479 (char *) "id", NULL
28480 };
28481
28482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28483 if (obj0) {
28484 ecode1 = SWIG_AsVal_int(obj0, &val1);
28485 if (!SWIG_IsOK(ecode1)) {
28486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28487 }
28488 arg1 = static_cast< int >(val1);
28489 }
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28504 PyObject *resultobj = 0;
28505 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28506 wxWindow *arg2 = (wxWindow *) 0 ;
28507 void *argp1 = 0 ;
28508 int res1 = 0 ;
28509 void *argp2 = 0 ;
28510 int res2 = 0 ;
28511 PyObject * obj0 = 0 ;
28512 PyObject * obj1 = 0 ;
28513 char * kwnames[] = {
28514 (char *) "self",(char *) "win", NULL
28515 };
28516
28517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28519 if (!SWIG_IsOK(res1)) {
28520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28521 }
28522 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28524 if (!SWIG_IsOK(res2)) {
28525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28526 }
28527 arg2 = reinterpret_cast< wxWindow * >(argp2);
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 (arg1)->SetChangedWindow(arg2);
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 resultobj = SWIG_Py_Void();
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28542 PyObject *resultobj = 0;
28543 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28544 wxWindow *result = 0 ;
28545 void *argp1 = 0 ;
28546 int res1 = 0 ;
28547 PyObject *swig_obj[1] ;
28548
28549 if (!args) SWIG_fail;
28550 swig_obj[0] = args;
28551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28554 }
28555 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (wxWindow *)(arg1)->GetChangedWindow();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 {
28563 resultobj = wxPyMake_wxObject(result, (bool)0);
28564 }
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28572 PyObject *obj;
28573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28574 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28575 return SWIG_Py_Void();
28576 }
28577
28578 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28579 return SWIG_Python_InitShadowInstance(args);
28580 }
28581
28582 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj = 0;
28584 int arg1 = (int) 0 ;
28585 wxQueryNewPaletteEvent *result = 0 ;
28586 int val1 ;
28587 int ecode1 = 0 ;
28588 PyObject * obj0 = 0 ;
28589 char * kwnames[] = {
28590 (char *) "winid", NULL
28591 };
28592
28593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28594 if (obj0) {
28595 ecode1 = SWIG_AsVal_int(obj0, &val1);
28596 if (!SWIG_IsOK(ecode1)) {
28597 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28598 }
28599 arg1 = static_cast< int >(val1);
28600 }
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28617 bool arg2 ;
28618 void *argp1 = 0 ;
28619 int res1 = 0 ;
28620 bool val2 ;
28621 int ecode2 = 0 ;
28622 PyObject * obj0 = 0 ;
28623 PyObject * obj1 = 0 ;
28624 char * kwnames[] = {
28625 (char *) "self",(char *) "realized", NULL
28626 };
28627
28628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28630 if (!SWIG_IsOK(res1)) {
28631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28632 }
28633 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28635 if (!SWIG_IsOK(ecode2)) {
28636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28637 }
28638 arg2 = static_cast< bool >(val2);
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 (arg1)->SetPaletteRealized(arg2);
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 resultobj = SWIG_Py_Void();
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 PyObject *resultobj = 0;
28654 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28655 bool result;
28656 void *argp1 = 0 ;
28657 int res1 = 0 ;
28658 PyObject *swig_obj[1] ;
28659
28660 if (!args) SWIG_fail;
28661 swig_obj[0] = args;
28662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28663 if (!SWIG_IsOK(res1)) {
28664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28665 }
28666 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 {
28674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28675 }
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28683 PyObject *obj;
28684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28685 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28686 return SWIG_Py_Void();
28687 }
28688
28689 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28690 return SWIG_Python_InitShadowInstance(args);
28691 }
28692
28693 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28694 PyObject *resultobj = 0;
28695 wxNavigationKeyEvent *result = 0 ;
28696
28697 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28701 wxPyEndAllowThreads(__tstate);
28702 if (PyErr_Occurred()) SWIG_fail;
28703 }
28704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28712 PyObject *resultobj = 0;
28713 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28714 bool result;
28715 void *argp1 = 0 ;
28716 int res1 = 0 ;
28717 PyObject *swig_obj[1] ;
28718
28719 if (!args) SWIG_fail;
28720 swig_obj[0] = args;
28721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28722 if (!SWIG_IsOK(res1)) {
28723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28724 }
28725 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28729 wxPyEndAllowThreads(__tstate);
28730 if (PyErr_Occurred()) SWIG_fail;
28731 }
28732 {
28733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28734 }
28735 return resultobj;
28736 fail:
28737 return NULL;
28738 }
28739
28740
28741 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28742 PyObject *resultobj = 0;
28743 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28744 bool arg2 ;
28745 void *argp1 = 0 ;
28746 int res1 = 0 ;
28747 bool val2 ;
28748 int ecode2 = 0 ;
28749 PyObject * obj0 = 0 ;
28750 PyObject * obj1 = 0 ;
28751 char * kwnames[] = {
28752 (char *) "self",(char *) "forward", NULL
28753 };
28754
28755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28757 if (!SWIG_IsOK(res1)) {
28758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28759 }
28760 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28762 if (!SWIG_IsOK(ecode2)) {
28763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28764 }
28765 arg2 = static_cast< bool >(val2);
28766 {
28767 PyThreadState* __tstate = wxPyBeginAllowThreads();
28768 (arg1)->SetDirection(arg2);
28769 wxPyEndAllowThreads(__tstate);
28770 if (PyErr_Occurred()) SWIG_fail;
28771 }
28772 resultobj = SWIG_Py_Void();
28773 return resultobj;
28774 fail:
28775 return NULL;
28776 }
28777
28778
28779 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28780 PyObject *resultobj = 0;
28781 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28782 bool result;
28783 void *argp1 = 0 ;
28784 int res1 = 0 ;
28785 PyObject *swig_obj[1] ;
28786
28787 if (!args) SWIG_fail;
28788 swig_obj[0] = args;
28789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28790 if (!SWIG_IsOK(res1)) {
28791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28792 }
28793 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28794 {
28795 PyThreadState* __tstate = wxPyBeginAllowThreads();
28796 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28797 wxPyEndAllowThreads(__tstate);
28798 if (PyErr_Occurred()) SWIG_fail;
28799 }
28800 {
28801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28802 }
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj = 0;
28811 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28812 bool arg2 ;
28813 void *argp1 = 0 ;
28814 int res1 = 0 ;
28815 bool val2 ;
28816 int ecode2 = 0 ;
28817 PyObject * obj0 = 0 ;
28818 PyObject * obj1 = 0 ;
28819 char * kwnames[] = {
28820 (char *) "self",(char *) "ischange", NULL
28821 };
28822
28823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28825 if (!SWIG_IsOK(res1)) {
28826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28827 }
28828 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28830 if (!SWIG_IsOK(ecode2)) {
28831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28832 }
28833 arg2 = static_cast< bool >(val2);
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 (arg1)->SetWindowChange(arg2);
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 resultobj = SWIG_Py_Void();
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28848 PyObject *resultobj = 0;
28849 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28850 bool result;
28851 void *argp1 = 0 ;
28852 int res1 = 0 ;
28853 PyObject *swig_obj[1] ;
28854
28855 if (!args) SWIG_fail;
28856 swig_obj[0] = args;
28857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28858 if (!SWIG_IsOK(res1)) {
28859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28860 }
28861 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28862 {
28863 PyThreadState* __tstate = wxPyBeginAllowThreads();
28864 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28865 wxPyEndAllowThreads(__tstate);
28866 if (PyErr_Occurred()) SWIG_fail;
28867 }
28868 {
28869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28870 }
28871 return resultobj;
28872 fail:
28873 return NULL;
28874 }
28875
28876
28877 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28878 PyObject *resultobj = 0;
28879 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28880 bool arg2 ;
28881 void *argp1 = 0 ;
28882 int res1 = 0 ;
28883 bool val2 ;
28884 int ecode2 = 0 ;
28885 PyObject * obj0 = 0 ;
28886 PyObject * obj1 = 0 ;
28887 char * kwnames[] = {
28888 (char *) "self",(char *) "bIs", NULL
28889 };
28890
28891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28893 if (!SWIG_IsOK(res1)) {
28894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28895 }
28896 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28897 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28898 if (!SWIG_IsOK(ecode2)) {
28899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28900 }
28901 arg2 = static_cast< bool >(val2);
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 (arg1)->SetFromTab(arg2);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_Py_Void();
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28916 PyObject *resultobj = 0;
28917 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28918 long arg2 ;
28919 void *argp1 = 0 ;
28920 int res1 = 0 ;
28921 long val2 ;
28922 int ecode2 = 0 ;
28923 PyObject * obj0 = 0 ;
28924 PyObject * obj1 = 0 ;
28925 char * kwnames[] = {
28926 (char *) "self",(char *) "flags", NULL
28927 };
28928
28929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28931 if (!SWIG_IsOK(res1)) {
28932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28933 }
28934 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28935 ecode2 = SWIG_AsVal_long(obj1, &val2);
28936 if (!SWIG_IsOK(ecode2)) {
28937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28938 }
28939 arg2 = static_cast< long >(val2);
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 (arg1)->SetFlags(arg2);
28943 wxPyEndAllowThreads(__tstate);
28944 if (PyErr_Occurred()) SWIG_fail;
28945 }
28946 resultobj = SWIG_Py_Void();
28947 return resultobj;
28948 fail:
28949 return NULL;
28950 }
28951
28952
28953 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28954 PyObject *resultobj = 0;
28955 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28956 wxWindow *result = 0 ;
28957 void *argp1 = 0 ;
28958 int res1 = 0 ;
28959 PyObject *swig_obj[1] ;
28960
28961 if (!args) SWIG_fail;
28962 swig_obj[0] = args;
28963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28964 if (!SWIG_IsOK(res1)) {
28965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28966 }
28967 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28971 wxPyEndAllowThreads(__tstate);
28972 if (PyErr_Occurred()) SWIG_fail;
28973 }
28974 {
28975 resultobj = wxPyMake_wxObject(result, (bool)0);
28976 }
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28986 wxWindow *arg2 = (wxWindow *) 0 ;
28987 void *argp1 = 0 ;
28988 int res1 = 0 ;
28989 void *argp2 = 0 ;
28990 int res2 = 0 ;
28991 PyObject * obj0 = 0 ;
28992 PyObject * obj1 = 0 ;
28993 char * kwnames[] = {
28994 (char *) "self",(char *) "win", NULL
28995 };
28996
28997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28999 if (!SWIG_IsOK(res1)) {
29000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29001 }
29002 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29004 if (!SWIG_IsOK(res2)) {
29005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29006 }
29007 arg2 = reinterpret_cast< wxWindow * >(argp2);
29008 {
29009 PyThreadState* __tstate = wxPyBeginAllowThreads();
29010 (arg1)->SetCurrentFocus(arg2);
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 resultobj = SWIG_Py_Void();
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29022 PyObject *obj;
29023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29024 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29025 return SWIG_Py_Void();
29026 }
29027
29028 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29029 return SWIG_Python_InitShadowInstance(args);
29030 }
29031
29032 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj = 0;
29034 wxWindow *arg1 = (wxWindow *) NULL ;
29035 wxWindowCreateEvent *result = 0 ;
29036 void *argp1 = 0 ;
29037 int res1 = 0 ;
29038 PyObject * obj0 = 0 ;
29039 char * kwnames[] = {
29040 (char *) "win", NULL
29041 };
29042
29043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29044 if (obj0) {
29045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29046 if (!SWIG_IsOK(res1)) {
29047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29048 }
29049 arg1 = reinterpret_cast< wxWindow * >(argp1);
29050 }
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29065 PyObject *resultobj = 0;
29066 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29067 wxWindow *result = 0 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 PyObject *swig_obj[1] ;
29071
29072 if (!args) SWIG_fail;
29073 swig_obj[0] = args;
29074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29075 if (!SWIG_IsOK(res1)) {
29076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29077 }
29078 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 {
29086 resultobj = wxPyMake_wxObject(result, (bool)0);
29087 }
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29095 PyObject *obj;
29096 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29097 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29098 return SWIG_Py_Void();
29099 }
29100
29101 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29102 return SWIG_Python_InitShadowInstance(args);
29103 }
29104
29105 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29106 PyObject *resultobj = 0;
29107 wxWindow *arg1 = (wxWindow *) NULL ;
29108 wxWindowDestroyEvent *result = 0 ;
29109 void *argp1 = 0 ;
29110 int res1 = 0 ;
29111 PyObject * obj0 = 0 ;
29112 char * kwnames[] = {
29113 (char *) "win", NULL
29114 };
29115
29116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29117 if (obj0) {
29118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29119 if (!SWIG_IsOK(res1)) {
29120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29121 }
29122 arg1 = reinterpret_cast< wxWindow * >(argp1);
29123 }
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29138 PyObject *resultobj = 0;
29139 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29140 wxWindow *result = 0 ;
29141 void *argp1 = 0 ;
29142 int res1 = 0 ;
29143 PyObject *swig_obj[1] ;
29144
29145 if (!args) SWIG_fail;
29146 swig_obj[0] = args;
29147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29148 if (!SWIG_IsOK(res1)) {
29149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29150 }
29151 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 {
29159 resultobj = wxPyMake_wxObject(result, (bool)0);
29160 }
29161 return resultobj;
29162 fail:
29163 return NULL;
29164 }
29165
29166
29167 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29168 PyObject *obj;
29169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29170 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29171 return SWIG_Py_Void();
29172 }
29173
29174 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29175 return SWIG_Python_InitShadowInstance(args);
29176 }
29177
29178 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29179 PyObject *resultobj = 0;
29180 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29181 int arg2 = (int) 0 ;
29182 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29183 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29184 wxContextMenuEvent *result = 0 ;
29185 int val1 ;
29186 int ecode1 = 0 ;
29187 int val2 ;
29188 int ecode2 = 0 ;
29189 wxPoint temp3 ;
29190 PyObject * obj0 = 0 ;
29191 PyObject * obj1 = 0 ;
29192 PyObject * obj2 = 0 ;
29193 char * kwnames[] = {
29194 (char *) "type",(char *) "winid",(char *) "pt", NULL
29195 };
29196
29197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29198 if (obj0) {
29199 ecode1 = SWIG_AsVal_int(obj0, &val1);
29200 if (!SWIG_IsOK(ecode1)) {
29201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29202 }
29203 arg1 = static_cast< wxEventType >(val1);
29204 }
29205 if (obj1) {
29206 ecode2 = SWIG_AsVal_int(obj1, &val2);
29207 if (!SWIG_IsOK(ecode2)) {
29208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29209 }
29210 arg2 = static_cast< int >(val2);
29211 }
29212 if (obj2) {
29213 {
29214 arg3 = &temp3;
29215 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29216 }
29217 }
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *resultobj = 0;
29233 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29234 wxPoint *result = 0 ;
29235 void *argp1 = 0 ;
29236 int res1 = 0 ;
29237 PyObject *swig_obj[1] ;
29238
29239 if (!args) SWIG_fail;
29240 swig_obj[0] = args;
29241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29242 if (!SWIG_IsOK(res1)) {
29243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29244 }
29245 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 {
29249 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29250 result = (wxPoint *) &_result_ref;
29251 }
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29263 PyObject *resultobj = 0;
29264 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29265 wxPoint *arg2 = 0 ;
29266 void *argp1 = 0 ;
29267 int res1 = 0 ;
29268 wxPoint temp2 ;
29269 PyObject * obj0 = 0 ;
29270 PyObject * obj1 = 0 ;
29271 char * kwnames[] = {
29272 (char *) "self",(char *) "pos", NULL
29273 };
29274
29275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29277 if (!SWIG_IsOK(res1)) {
29278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29279 }
29280 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29281 {
29282 arg2 = &temp2;
29283 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29284 }
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 (arg1)->SetPosition((wxPoint const &)*arg2);
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 resultobj = SWIG_Py_Void();
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29299 PyObject *obj;
29300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29301 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29302 return SWIG_Py_Void();
29303 }
29304
29305 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29306 return SWIG_Python_InitShadowInstance(args);
29307 }
29308
29309 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29310 PyObject *resultobj = 0;
29311 wxIdleEvent *result = 0 ;
29312
29313 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29314 {
29315 PyThreadState* __tstate = wxPyBeginAllowThreads();
29316 result = (wxIdleEvent *)new wxIdleEvent();
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29328 PyObject *resultobj = 0;
29329 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29330 bool arg2 = (bool) true ;
29331 void *argp1 = 0 ;
29332 int res1 = 0 ;
29333 bool val2 ;
29334 int ecode2 = 0 ;
29335 PyObject * obj0 = 0 ;
29336 PyObject * obj1 = 0 ;
29337 char * kwnames[] = {
29338 (char *) "self",(char *) "needMore", NULL
29339 };
29340
29341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29343 if (!SWIG_IsOK(res1)) {
29344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29345 }
29346 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29347 if (obj1) {
29348 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29349 if (!SWIG_IsOK(ecode2)) {
29350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29351 }
29352 arg2 = static_cast< bool >(val2);
29353 }
29354 {
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 (arg1)->RequestMore(arg2);
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 resultobj = SWIG_Py_Void();
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29368 PyObject *resultobj = 0;
29369 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29370 bool result;
29371 void *argp1 = 0 ;
29372 int res1 = 0 ;
29373 PyObject *swig_obj[1] ;
29374
29375 if (!args) SWIG_fail;
29376 swig_obj[0] = args;
29377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29378 if (!SWIG_IsOK(res1)) {
29379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29380 }
29381 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29382 {
29383 PyThreadState* __tstate = wxPyBeginAllowThreads();
29384 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29385 wxPyEndAllowThreads(__tstate);
29386 if (PyErr_Occurred()) SWIG_fail;
29387 }
29388 {
29389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29390 }
29391 return resultobj;
29392 fail:
29393 return NULL;
29394 }
29395
29396
29397 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29398 PyObject *resultobj = 0;
29399 wxIdleMode arg1 ;
29400 int val1 ;
29401 int ecode1 = 0 ;
29402 PyObject * obj0 = 0 ;
29403 char * kwnames[] = {
29404 (char *) "mode", NULL
29405 };
29406
29407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29408 ecode1 = SWIG_AsVal_int(obj0, &val1);
29409 if (!SWIG_IsOK(ecode1)) {
29410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29411 }
29412 arg1 = static_cast< wxIdleMode >(val1);
29413 {
29414 PyThreadState* __tstate = wxPyBeginAllowThreads();
29415 wxIdleEvent::SetMode(arg1);
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 resultobj = SWIG_Py_Void();
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29427 PyObject *resultobj = 0;
29428 wxIdleMode result;
29429
29430 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (wxIdleMode)wxIdleEvent::GetMode();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 resultobj = SWIG_From_int(static_cast< int >(result));
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj = 0;
29446 wxWindow *arg1 = (wxWindow *) 0 ;
29447 bool result;
29448 void *argp1 = 0 ;
29449 int res1 = 0 ;
29450 PyObject * obj0 = 0 ;
29451 char * kwnames[] = {
29452 (char *) "win", NULL
29453 };
29454
29455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29457 if (!SWIG_IsOK(res1)) {
29458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29459 }
29460 arg1 = reinterpret_cast< wxWindow * >(argp1);
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (bool)wxIdleEvent::CanSend(arg1);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29477 PyObject *obj;
29478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29479 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29480 return SWIG_Py_Void();
29481 }
29482
29483 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29484 return SWIG_Python_InitShadowInstance(args);
29485 }
29486
29487 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj = 0;
29489 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29490 int arg2 = (int) 0 ;
29491 wxClipboardTextEvent *result = 0 ;
29492 int val1 ;
29493 int ecode1 = 0 ;
29494 int val2 ;
29495 int ecode2 = 0 ;
29496 PyObject * obj0 = 0 ;
29497 PyObject * obj1 = 0 ;
29498 char * kwnames[] = {
29499 (char *) "type",(char *) "winid", NULL
29500 };
29501
29502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29503 if (obj0) {
29504 ecode1 = SWIG_AsVal_int(obj0, &val1);
29505 if (!SWIG_IsOK(ecode1)) {
29506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29507 }
29508 arg1 = static_cast< wxEventType >(val1);
29509 }
29510 if (obj1) {
29511 ecode2 = SWIG_AsVal_int(obj1, &val2);
29512 if (!SWIG_IsOK(ecode2)) {
29513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29514 }
29515 arg2 = static_cast< int >(val2);
29516 }
29517 {
29518 PyThreadState* __tstate = wxPyBeginAllowThreads();
29519 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29520 wxPyEndAllowThreads(__tstate);
29521 if (PyErr_Occurred()) SWIG_fail;
29522 }
29523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29531 PyObject *obj;
29532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29533 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29534 return SWIG_Py_Void();
29535 }
29536
29537 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29538 return SWIG_Python_InitShadowInstance(args);
29539 }
29540
29541 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29542 PyObject *resultobj = 0;
29543 int arg1 = (int) 0 ;
29544 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29545 wxPyEvent *result = 0 ;
29546 int val1 ;
29547 int ecode1 = 0 ;
29548 int val2 ;
29549 int ecode2 = 0 ;
29550 PyObject * obj0 = 0 ;
29551 PyObject * obj1 = 0 ;
29552 char * kwnames[] = {
29553 (char *) "winid",(char *) "eventType", NULL
29554 };
29555
29556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29557 if (obj0) {
29558 ecode1 = SWIG_AsVal_int(obj0, &val1);
29559 if (!SWIG_IsOK(ecode1)) {
29560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29561 }
29562 arg1 = static_cast< int >(val1);
29563 }
29564 if (obj1) {
29565 ecode2 = SWIG_AsVal_int(obj1, &val2);
29566 if (!SWIG_IsOK(ecode2)) {
29567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29568 }
29569 arg2 = static_cast< wxEventType >(val2);
29570 }
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29585 PyObject *resultobj = 0;
29586 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29587 void *argp1 = 0 ;
29588 int res1 = 0 ;
29589 PyObject *swig_obj[1] ;
29590
29591 if (!args) SWIG_fail;
29592 swig_obj[0] = args;
29593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29594 if (!SWIG_IsOK(res1)) {
29595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29596 }
29597 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29598 {
29599 PyThreadState* __tstate = wxPyBeginAllowThreads();
29600 delete arg1;
29601
29602 wxPyEndAllowThreads(__tstate);
29603 if (PyErr_Occurred()) SWIG_fail;
29604 }
29605 resultobj = SWIG_Py_Void();
29606 return resultobj;
29607 fail:
29608 return NULL;
29609 }
29610
29611
29612 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29613 PyObject *resultobj = 0;
29614 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29615 PyObject *arg2 = (PyObject *) 0 ;
29616 void *argp1 = 0 ;
29617 int res1 = 0 ;
29618 PyObject * obj0 = 0 ;
29619 PyObject * obj1 = 0 ;
29620 char * kwnames[] = {
29621 (char *) "self",(char *) "self", NULL
29622 };
29623
29624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29626 if (!SWIG_IsOK(res1)) {
29627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29628 }
29629 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29630 arg2 = obj1;
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 (arg1)->SetSelf(arg2);
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 resultobj = SWIG_Py_Void();
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29645 PyObject *resultobj = 0;
29646 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29647 PyObject *result = 0 ;
29648 void *argp1 = 0 ;
29649 int res1 = 0 ;
29650 PyObject *swig_obj[1] ;
29651
29652 if (!args) SWIG_fail;
29653 swig_obj[0] = args;
29654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29655 if (!SWIG_IsOK(res1)) {
29656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29657 }
29658 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29659 {
29660 PyThreadState* __tstate = wxPyBeginAllowThreads();
29661 result = (PyObject *)(arg1)->GetSelf();
29662 wxPyEndAllowThreads(__tstate);
29663 if (PyErr_Occurred()) SWIG_fail;
29664 }
29665 resultobj = result;
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29673 PyObject *obj;
29674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29675 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29676 return SWIG_Py_Void();
29677 }
29678
29679 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 return SWIG_Python_InitShadowInstance(args);
29681 }
29682
29683 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29684 PyObject *resultobj = 0;
29685 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29686 int arg2 = (int) 0 ;
29687 wxPyCommandEvent *result = 0 ;
29688 int val1 ;
29689 int ecode1 = 0 ;
29690 int val2 ;
29691 int ecode2 = 0 ;
29692 PyObject * obj0 = 0 ;
29693 PyObject * obj1 = 0 ;
29694 char * kwnames[] = {
29695 (char *) "eventType",(char *) "id", NULL
29696 };
29697
29698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29699 if (obj0) {
29700 ecode1 = SWIG_AsVal_int(obj0, &val1);
29701 if (!SWIG_IsOK(ecode1)) {
29702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29703 }
29704 arg1 = static_cast< wxEventType >(val1);
29705 }
29706 if (obj1) {
29707 ecode2 = SWIG_AsVal_int(obj1, &val2);
29708 if (!SWIG_IsOK(ecode2)) {
29709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29710 }
29711 arg2 = static_cast< int >(val2);
29712 }
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29716 wxPyEndAllowThreads(__tstate);
29717 if (PyErr_Occurred()) SWIG_fail;
29718 }
29719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29727 PyObject *resultobj = 0;
29728 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29729 void *argp1 = 0 ;
29730 int res1 = 0 ;
29731 PyObject *swig_obj[1] ;
29732
29733 if (!args) SWIG_fail;
29734 swig_obj[0] = args;
29735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29736 if (!SWIG_IsOK(res1)) {
29737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29738 }
29739 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29740 {
29741 PyThreadState* __tstate = wxPyBeginAllowThreads();
29742 delete arg1;
29743
29744 wxPyEndAllowThreads(__tstate);
29745 if (PyErr_Occurred()) SWIG_fail;
29746 }
29747 resultobj = SWIG_Py_Void();
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj = 0;
29756 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29757 PyObject *arg2 = (PyObject *) 0 ;
29758 void *argp1 = 0 ;
29759 int res1 = 0 ;
29760 PyObject * obj0 = 0 ;
29761 PyObject * obj1 = 0 ;
29762 char * kwnames[] = {
29763 (char *) "self",(char *) "self", NULL
29764 };
29765
29766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29770 }
29771 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29772 arg2 = obj1;
29773 {
29774 PyThreadState* __tstate = wxPyBeginAllowThreads();
29775 (arg1)->SetSelf(arg2);
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = SWIG_Py_Void();
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29787 PyObject *resultobj = 0;
29788 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29789 PyObject *result = 0 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 PyObject *swig_obj[1] ;
29793
29794 if (!args) SWIG_fail;
29795 swig_obj[0] = args;
29796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29797 if (!SWIG_IsOK(res1)) {
29798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29799 }
29800 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29801 {
29802 PyThreadState* __tstate = wxPyBeginAllowThreads();
29803 result = (PyObject *)(arg1)->GetSelf();
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 resultobj = result;
29808 return resultobj;
29809 fail:
29810 return NULL;
29811 }
29812
29813
29814 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29815 PyObject *obj;
29816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29817 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29818 return SWIG_Py_Void();
29819 }
29820
29821 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29822 return SWIG_Python_InitShadowInstance(args);
29823 }
29824
29825 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29826 PyObject *resultobj = 0;
29827 wxWindow *arg1 = (wxWindow *) 0 ;
29828 wxDateTime *arg2 = 0 ;
29829 wxEventType arg3 ;
29830 wxDateEvent *result = 0 ;
29831 void *argp1 = 0 ;
29832 int res1 = 0 ;
29833 void *argp2 = 0 ;
29834 int res2 = 0 ;
29835 int val3 ;
29836 int ecode3 = 0 ;
29837 PyObject * obj0 = 0 ;
29838 PyObject * obj1 = 0 ;
29839 PyObject * obj2 = 0 ;
29840 char * kwnames[] = {
29841 (char *) "win",(char *) "dt",(char *) "type", NULL
29842 };
29843
29844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29848 }
29849 arg1 = reinterpret_cast< wxWindow * >(argp1);
29850 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29851 if (!SWIG_IsOK(res2)) {
29852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29853 }
29854 if (!argp2) {
29855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29856 }
29857 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29858 ecode3 = SWIG_AsVal_int(obj2, &val3);
29859 if (!SWIG_IsOK(ecode3)) {
29860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29861 }
29862 arg3 = static_cast< wxEventType >(val3);
29863 {
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29866 wxPyEndAllowThreads(__tstate);
29867 if (PyErr_Occurred()) SWIG_fail;
29868 }
29869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29870 return resultobj;
29871 fail:
29872 return NULL;
29873 }
29874
29875
29876 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29877 PyObject *resultobj = 0;
29878 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29879 wxDateTime *result = 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_wxDateEvent, 0 | 0 );
29887 if (!SWIG_IsOK(res1)) {
29888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29889 }
29890 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29891 {
29892 PyThreadState* __tstate = wxPyBeginAllowThreads();
29893 {
29894 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29895 result = (wxDateTime *) &_result_ref;
29896 }
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29908 PyObject *resultobj = 0;
29909 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29910 wxDateTime *arg2 = 0 ;
29911 void *argp1 = 0 ;
29912 int res1 = 0 ;
29913 void *argp2 = 0 ;
29914 int res2 = 0 ;
29915 PyObject * obj0 = 0 ;
29916 PyObject * obj1 = 0 ;
29917 char * kwnames[] = {
29918 (char *) "self",(char *) "date", NULL
29919 };
29920
29921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29923 if (!SWIG_IsOK(res1)) {
29924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29925 }
29926 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29928 if (!SWIG_IsOK(res2)) {
29929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29930 }
29931 if (!argp2) {
29932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29933 }
29934 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 (arg1)->SetDate((wxDateTime const &)*arg2);
29938 wxPyEndAllowThreads(__tstate);
29939 if (PyErr_Occurred()) SWIG_fail;
29940 }
29941 resultobj = SWIG_Py_Void();
29942 return resultobj;
29943 fail:
29944 return NULL;
29945 }
29946
29947
29948 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29949 PyObject *obj;
29950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29951 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29952 return SWIG_Py_Void();
29953 }
29954
29955 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29956 return SWIG_Python_InitShadowInstance(args);
29957 }
29958
29959 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29960 PyObject *resultobj = 0;
29961 wxPyApp *result = 0 ;
29962
29963 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (wxPyApp *)new_wxPyApp();
29967 wxPyEndAllowThreads(__tstate);
29968 if (PyErr_Occurred()) SWIG_fail;
29969 }
29970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29971 return resultobj;
29972 fail:
29973 return NULL;
29974 }
29975
29976
29977 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29978 PyObject *resultobj = 0;
29979 wxPyApp *arg1 = (wxPyApp *) 0 ;
29980 void *argp1 = 0 ;
29981 int res1 = 0 ;
29982 PyObject *swig_obj[1] ;
29983
29984 if (!args) SWIG_fail;
29985 swig_obj[0] = args;
29986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29987 if (!SWIG_IsOK(res1)) {
29988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29989 }
29990 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29991 {
29992 PyThreadState* __tstate = wxPyBeginAllowThreads();
29993 delete arg1;
29994
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 resultobj = SWIG_Py_Void();
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30006 PyObject *resultobj = 0;
30007 wxPyApp *arg1 = (wxPyApp *) 0 ;
30008 PyObject *arg2 = (PyObject *) 0 ;
30009 PyObject *arg3 = (PyObject *) 0 ;
30010 bool arg4 ;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 bool val4 ;
30014 int ecode4 = 0 ;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 PyObject * obj2 = 0 ;
30018 PyObject * obj3 = 0 ;
30019 char * kwnames[] = {
30020 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30021 };
30022
30023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30025 if (!SWIG_IsOK(res1)) {
30026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30027 }
30028 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30029 arg2 = obj1;
30030 arg3 = obj2;
30031 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30032 if (!SWIG_IsOK(ecode4)) {
30033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30034 }
30035 arg4 = static_cast< bool >(val4);
30036 {
30037 PyThreadState* __tstate = wxPyBeginAllowThreads();
30038 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 resultobj = SWIG_Py_Void();
30043 return resultobj;
30044 fail:
30045 return NULL;
30046 }
30047
30048
30049 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30050 PyObject *resultobj = 0;
30051 wxPyApp *arg1 = (wxPyApp *) 0 ;
30052 wxString result;
30053 void *argp1 = 0 ;
30054 int res1 = 0 ;
30055 PyObject *swig_obj[1] ;
30056
30057 if (!args) SWIG_fail;
30058 swig_obj[0] = args;
30059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30060 if (!SWIG_IsOK(res1)) {
30061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30062 }
30063 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = ((wxPyApp const *)arg1)->GetAppName();
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 {
30071 #if wxUSE_UNICODE
30072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30073 #else
30074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30075 #endif
30076 }
30077 return resultobj;
30078 fail:
30079 return NULL;
30080 }
30081
30082
30083 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30084 PyObject *resultobj = 0;
30085 wxPyApp *arg1 = (wxPyApp *) 0 ;
30086 wxString *arg2 = 0 ;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 bool temp2 = false ;
30090 PyObject * obj0 = 0 ;
30091 PyObject * obj1 = 0 ;
30092 char * kwnames[] = {
30093 (char *) "self",(char *) "name", NULL
30094 };
30095
30096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30098 if (!SWIG_IsOK(res1)) {
30099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30100 }
30101 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30102 {
30103 arg2 = wxString_in_helper(obj1);
30104 if (arg2 == NULL) SWIG_fail;
30105 temp2 = true;
30106 }
30107 {
30108 PyThreadState* __tstate = wxPyBeginAllowThreads();
30109 (arg1)->SetAppName((wxString const &)*arg2);
30110 wxPyEndAllowThreads(__tstate);
30111 if (PyErr_Occurred()) SWIG_fail;
30112 }
30113 resultobj = SWIG_Py_Void();
30114 {
30115 if (temp2)
30116 delete arg2;
30117 }
30118 return resultobj;
30119 fail:
30120 {
30121 if (temp2)
30122 delete arg2;
30123 }
30124 return NULL;
30125 }
30126
30127
30128 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30129 PyObject *resultobj = 0;
30130 wxPyApp *arg1 = (wxPyApp *) 0 ;
30131 wxString result;
30132 void *argp1 = 0 ;
30133 int res1 = 0 ;
30134 PyObject *swig_obj[1] ;
30135
30136 if (!args) SWIG_fail;
30137 swig_obj[0] = args;
30138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30139 if (!SWIG_IsOK(res1)) {
30140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30141 }
30142 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 result = ((wxPyApp const *)arg1)->GetClassName();
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 {
30150 #if wxUSE_UNICODE
30151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30152 #else
30153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30154 #endif
30155 }
30156 return resultobj;
30157 fail:
30158 return NULL;
30159 }
30160
30161
30162 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30163 PyObject *resultobj = 0;
30164 wxPyApp *arg1 = (wxPyApp *) 0 ;
30165 wxString *arg2 = 0 ;
30166 void *argp1 = 0 ;
30167 int res1 = 0 ;
30168 bool temp2 = false ;
30169 PyObject * obj0 = 0 ;
30170 PyObject * obj1 = 0 ;
30171 char * kwnames[] = {
30172 (char *) "self",(char *) "name", NULL
30173 };
30174
30175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30177 if (!SWIG_IsOK(res1)) {
30178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30179 }
30180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30181 {
30182 arg2 = wxString_in_helper(obj1);
30183 if (arg2 == NULL) SWIG_fail;
30184 temp2 = true;
30185 }
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 (arg1)->SetClassName((wxString const &)*arg2);
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 resultobj = SWIG_Py_Void();
30193 {
30194 if (temp2)
30195 delete arg2;
30196 }
30197 return resultobj;
30198 fail:
30199 {
30200 if (temp2)
30201 delete arg2;
30202 }
30203 return NULL;
30204 }
30205
30206
30207 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30208 PyObject *resultobj = 0;
30209 wxPyApp *arg1 = (wxPyApp *) 0 ;
30210 wxString *result = 0 ;
30211 void *argp1 = 0 ;
30212 int res1 = 0 ;
30213 PyObject *swig_obj[1] ;
30214
30215 if (!args) SWIG_fail;
30216 swig_obj[0] = args;
30217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30218 if (!SWIG_IsOK(res1)) {
30219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30220 }
30221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30222 {
30223 PyThreadState* __tstate = wxPyBeginAllowThreads();
30224 {
30225 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30226 result = (wxString *) &_result_ref;
30227 }
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 {
30232 #if wxUSE_UNICODE
30233 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30234 #else
30235 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30236 #endif
30237 }
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30245 PyObject *resultobj = 0;
30246 wxPyApp *arg1 = (wxPyApp *) 0 ;
30247 wxString *arg2 = 0 ;
30248 void *argp1 = 0 ;
30249 int res1 = 0 ;
30250 bool temp2 = false ;
30251 PyObject * obj0 = 0 ;
30252 PyObject * obj1 = 0 ;
30253 char * kwnames[] = {
30254 (char *) "self",(char *) "name", NULL
30255 };
30256
30257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30259 if (!SWIG_IsOK(res1)) {
30260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30261 }
30262 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30263 {
30264 arg2 = wxString_in_helper(obj1);
30265 if (arg2 == NULL) SWIG_fail;
30266 temp2 = true;
30267 }
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 (arg1)->SetVendorName((wxString const &)*arg2);
30271 wxPyEndAllowThreads(__tstate);
30272 if (PyErr_Occurred()) SWIG_fail;
30273 }
30274 resultobj = SWIG_Py_Void();
30275 {
30276 if (temp2)
30277 delete arg2;
30278 }
30279 return resultobj;
30280 fail:
30281 {
30282 if (temp2)
30283 delete arg2;
30284 }
30285 return NULL;
30286 }
30287
30288
30289 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30290 PyObject *resultobj = 0;
30291 wxPyApp *arg1 = (wxPyApp *) 0 ;
30292 wxAppTraits *result = 0 ;
30293 void *argp1 = 0 ;
30294 int res1 = 0 ;
30295 PyObject *swig_obj[1] ;
30296
30297 if (!args) SWIG_fail;
30298 swig_obj[0] = args;
30299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30300 if (!SWIG_IsOK(res1)) {
30301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30302 }
30303 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 result = (wxAppTraits *)(arg1)->GetTraits();
30307 wxPyEndAllowThreads(__tstate);
30308 if (PyErr_Occurred()) SWIG_fail;
30309 }
30310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30311 return resultobj;
30312 fail:
30313 return NULL;
30314 }
30315
30316
30317 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30318 PyObject *resultobj = 0;
30319 wxPyApp *arg1 = (wxPyApp *) 0 ;
30320 void *argp1 = 0 ;
30321 int res1 = 0 ;
30322 PyObject *swig_obj[1] ;
30323
30324 if (!args) SWIG_fail;
30325 swig_obj[0] = args;
30326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30327 if (!SWIG_IsOK(res1)) {
30328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30329 }
30330 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 (arg1)->ProcessPendingEvents();
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 resultobj = SWIG_Py_Void();
30338 return resultobj;
30339 fail:
30340 return NULL;
30341 }
30342
30343
30344 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30345 PyObject *resultobj = 0;
30346 wxPyApp *arg1 = (wxPyApp *) 0 ;
30347 bool arg2 = (bool) false ;
30348 bool result;
30349 void *argp1 = 0 ;
30350 int res1 = 0 ;
30351 bool val2 ;
30352 int ecode2 = 0 ;
30353 PyObject * obj0 = 0 ;
30354 PyObject * obj1 = 0 ;
30355 char * kwnames[] = {
30356 (char *) "self",(char *) "onlyIfNeeded", NULL
30357 };
30358
30359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30361 if (!SWIG_IsOK(res1)) {
30362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30363 }
30364 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30365 if (obj1) {
30366 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30367 if (!SWIG_IsOK(ecode2)) {
30368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30369 }
30370 arg2 = static_cast< bool >(val2);
30371 }
30372 {
30373 PyThreadState* __tstate = wxPyBeginAllowThreads();
30374 result = (bool)(arg1)->Yield(arg2);
30375 wxPyEndAllowThreads(__tstate);
30376 if (PyErr_Occurred()) SWIG_fail;
30377 }
30378 {
30379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30380 }
30381 return resultobj;
30382 fail:
30383 return NULL;
30384 }
30385
30386
30387 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30388 PyObject *resultobj = 0;
30389 wxPyApp *arg1 = (wxPyApp *) 0 ;
30390 void *argp1 = 0 ;
30391 int res1 = 0 ;
30392 PyObject *swig_obj[1] ;
30393
30394 if (!args) SWIG_fail;
30395 swig_obj[0] = args;
30396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30397 if (!SWIG_IsOK(res1)) {
30398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30399 }
30400 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30401 {
30402 PyThreadState* __tstate = wxPyBeginAllowThreads();
30403 (arg1)->WakeUpIdle();
30404 wxPyEndAllowThreads(__tstate);
30405 if (PyErr_Occurred()) SWIG_fail;
30406 }
30407 resultobj = SWIG_Py_Void();
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30415 PyObject *resultobj = 0;
30416 bool result;
30417
30418 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30419 {
30420 PyThreadState* __tstate = wxPyBeginAllowThreads();
30421 result = (bool)wxPyApp::IsMainLoopRunning();
30422 wxPyEndAllowThreads(__tstate);
30423 if (PyErr_Occurred()) SWIG_fail;
30424 }
30425 {
30426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30427 }
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30435 PyObject *resultobj = 0;
30436 wxPyApp *arg1 = (wxPyApp *) 0 ;
30437 int result;
30438 void *argp1 = 0 ;
30439 int res1 = 0 ;
30440 PyObject *swig_obj[1] ;
30441
30442 if (!args) SWIG_fail;
30443 swig_obj[0] = args;
30444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30445 if (!SWIG_IsOK(res1)) {
30446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30447 }
30448 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = (int)(arg1)->MainLoop();
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 resultobj = SWIG_From_int(static_cast< int >(result));
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30463 PyObject *resultobj = 0;
30464 wxPyApp *arg1 = (wxPyApp *) 0 ;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 PyObject *swig_obj[1] ;
30468
30469 if (!args) SWIG_fail;
30470 swig_obj[0] = args;
30471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30474 }
30475 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 (arg1)->Exit();
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_Py_Void();
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30490 PyObject *resultobj = 0;
30491 wxPyApp *arg1 = (wxPyApp *) 0 ;
30492 wxLayoutDirection result;
30493 void *argp1 = 0 ;
30494 int res1 = 0 ;
30495 PyObject *swig_obj[1] ;
30496
30497 if (!args) SWIG_fail;
30498 swig_obj[0] = args;
30499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30500 if (!SWIG_IsOK(res1)) {
30501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30502 }
30503 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 resultobj = SWIG_From_int(static_cast< int >(result));
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30518 PyObject *resultobj = 0;
30519 wxPyApp *arg1 = (wxPyApp *) 0 ;
30520 void *argp1 = 0 ;
30521 int res1 = 0 ;
30522 PyObject *swig_obj[1] ;
30523
30524 if (!args) SWIG_fail;
30525 swig_obj[0] = args;
30526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30527 if (!SWIG_IsOK(res1)) {
30528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30529 }
30530 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 (arg1)->ExitMainLoop();
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 resultobj = SWIG_Py_Void();
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30545 PyObject *resultobj = 0;
30546 wxPyApp *arg1 = (wxPyApp *) 0 ;
30547 bool result;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 PyObject *swig_obj[1] ;
30551
30552 if (!args) SWIG_fail;
30553 swig_obj[0] = args;
30554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30555 if (!SWIG_IsOK(res1)) {
30556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30557 }
30558 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30559 {
30560 PyThreadState* __tstate = wxPyBeginAllowThreads();
30561 result = (bool)(arg1)->Pending();
30562 wxPyEndAllowThreads(__tstate);
30563 if (PyErr_Occurred()) SWIG_fail;
30564 }
30565 {
30566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30567 }
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30575 PyObject *resultobj = 0;
30576 wxPyApp *arg1 = (wxPyApp *) 0 ;
30577 bool result;
30578 void *argp1 = 0 ;
30579 int res1 = 0 ;
30580 PyObject *swig_obj[1] ;
30581
30582 if (!args) SWIG_fail;
30583 swig_obj[0] = args;
30584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30585 if (!SWIG_IsOK(res1)) {
30586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30587 }
30588 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 result = (bool)(arg1)->Dispatch();
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 {
30596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30597 }
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30605 PyObject *resultobj = 0;
30606 wxPyApp *arg1 = (wxPyApp *) 0 ;
30607 bool result;
30608 void *argp1 = 0 ;
30609 int res1 = 0 ;
30610 PyObject *swig_obj[1] ;
30611
30612 if (!args) SWIG_fail;
30613 swig_obj[0] = args;
30614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30615 if (!SWIG_IsOK(res1)) {
30616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30617 }
30618 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30619 {
30620 PyThreadState* __tstate = wxPyBeginAllowThreads();
30621 result = (bool)(arg1)->ProcessIdle();
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 {
30626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30627 }
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj = 0;
30636 wxPyApp *arg1 = (wxPyApp *) 0 ;
30637 wxWindow *arg2 = (wxWindow *) 0 ;
30638 wxIdleEvent *arg3 = 0 ;
30639 bool result;
30640 void *argp1 = 0 ;
30641 int res1 = 0 ;
30642 void *argp2 = 0 ;
30643 int res2 = 0 ;
30644 void *argp3 = 0 ;
30645 int res3 = 0 ;
30646 PyObject * obj0 = 0 ;
30647 PyObject * obj1 = 0 ;
30648 PyObject * obj2 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "win",(char *) "event", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30657 }
30658 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30660 if (!SWIG_IsOK(res2)) {
30661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30662 }
30663 arg2 = reinterpret_cast< wxWindow * >(argp2);
30664 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30665 if (!SWIG_IsOK(res3)) {
30666 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30667 }
30668 if (!argp3) {
30669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30670 }
30671 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 {
30679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30680 }
30681 return resultobj;
30682 fail:
30683 return NULL;
30684 }
30685
30686
30687 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30688 PyObject *resultobj = 0;
30689 wxPyApp *arg1 = (wxPyApp *) 0 ;
30690 bool result;
30691 void *argp1 = 0 ;
30692 int res1 = 0 ;
30693 PyObject *swig_obj[1] ;
30694
30695 if (!args) SWIG_fail;
30696 swig_obj[0] = args;
30697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30698 if (!SWIG_IsOK(res1)) {
30699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30700 }
30701 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30702 {
30703 PyThreadState* __tstate = wxPyBeginAllowThreads();
30704 result = (bool)((wxPyApp const *)arg1)->IsActive();
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 {
30709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30710 }
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30718 PyObject *resultobj = 0;
30719 wxPyApp *arg1 = (wxPyApp *) 0 ;
30720 wxWindow *arg2 = (wxWindow *) 0 ;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 void *argp2 = 0 ;
30724 int res2 = 0 ;
30725 PyObject * obj0 = 0 ;
30726 PyObject * obj1 = 0 ;
30727 char * kwnames[] = {
30728 (char *) "self",(char *) "win", NULL
30729 };
30730
30731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30733 if (!SWIG_IsOK(res1)) {
30734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30735 }
30736 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30738 if (!SWIG_IsOK(res2)) {
30739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30740 }
30741 arg2 = reinterpret_cast< wxWindow * >(argp2);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 (arg1)->SetTopWindow(arg2);
30745 wxPyEndAllowThreads(__tstate);
30746 if (PyErr_Occurred()) SWIG_fail;
30747 }
30748 resultobj = SWIG_Py_Void();
30749 return resultobj;
30750 fail:
30751 return NULL;
30752 }
30753
30754
30755 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30756 PyObject *resultobj = 0;
30757 wxPyApp *arg1 = (wxPyApp *) 0 ;
30758 wxWindow *result = 0 ;
30759 void *argp1 = 0 ;
30760 int res1 = 0 ;
30761 PyObject *swig_obj[1] ;
30762
30763 if (!args) SWIG_fail;
30764 swig_obj[0] = args;
30765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30766 if (!SWIG_IsOK(res1)) {
30767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30768 }
30769 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30770 {
30771 PyThreadState* __tstate = wxPyBeginAllowThreads();
30772 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30773 wxPyEndAllowThreads(__tstate);
30774 if (PyErr_Occurred()) SWIG_fail;
30775 }
30776 {
30777 resultobj = wxPyMake_wxObject(result, (bool)0);
30778 }
30779 return resultobj;
30780 fail:
30781 return NULL;
30782 }
30783
30784
30785 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30786 PyObject *resultobj = 0;
30787 wxPyApp *arg1 = (wxPyApp *) 0 ;
30788 bool arg2 ;
30789 void *argp1 = 0 ;
30790 int res1 = 0 ;
30791 bool val2 ;
30792 int ecode2 = 0 ;
30793 PyObject * obj0 = 0 ;
30794 PyObject * obj1 = 0 ;
30795 char * kwnames[] = {
30796 (char *) "self",(char *) "flag", NULL
30797 };
30798
30799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30801 if (!SWIG_IsOK(res1)) {
30802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30803 }
30804 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30806 if (!SWIG_IsOK(ecode2)) {
30807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30808 }
30809 arg2 = static_cast< bool >(val2);
30810 {
30811 PyThreadState* __tstate = wxPyBeginAllowThreads();
30812 (arg1)->SetExitOnFrameDelete(arg2);
30813 wxPyEndAllowThreads(__tstate);
30814 if (PyErr_Occurred()) SWIG_fail;
30815 }
30816 resultobj = SWIG_Py_Void();
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30824 PyObject *resultobj = 0;
30825 wxPyApp *arg1 = (wxPyApp *) 0 ;
30826 bool result;
30827 void *argp1 = 0 ;
30828 int res1 = 0 ;
30829 PyObject *swig_obj[1] ;
30830
30831 if (!args) SWIG_fail;
30832 swig_obj[0] = args;
30833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30834 if (!SWIG_IsOK(res1)) {
30835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30836 }
30837 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30838 {
30839 PyThreadState* __tstate = wxPyBeginAllowThreads();
30840 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30841 wxPyEndAllowThreads(__tstate);
30842 if (PyErr_Occurred()) SWIG_fail;
30843 }
30844 {
30845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30854 PyObject *resultobj = 0;
30855 wxPyApp *arg1 = (wxPyApp *) 0 ;
30856 bool arg2 ;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 bool val2 ;
30860 int ecode2 = 0 ;
30861 PyObject * obj0 = 0 ;
30862 PyObject * obj1 = 0 ;
30863 char * kwnames[] = {
30864 (char *) "self",(char *) "flag", NULL
30865 };
30866
30867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30869 if (!SWIG_IsOK(res1)) {
30870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30871 }
30872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30874 if (!SWIG_IsOK(ecode2)) {
30875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30876 }
30877 arg2 = static_cast< bool >(val2);
30878 {
30879 PyThreadState* __tstate = wxPyBeginAllowThreads();
30880 (arg1)->SetUseBestVisual(arg2);
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 resultobj = SWIG_Py_Void();
30885 return resultobj;
30886 fail:
30887 return NULL;
30888 }
30889
30890
30891 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30892 PyObject *resultobj = 0;
30893 wxPyApp *arg1 = (wxPyApp *) 0 ;
30894 bool result;
30895 void *argp1 = 0 ;
30896 int res1 = 0 ;
30897 PyObject *swig_obj[1] ;
30898
30899 if (!args) SWIG_fail;
30900 swig_obj[0] = args;
30901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30902 if (!SWIG_IsOK(res1)) {
30903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30904 }
30905 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30906 {
30907 PyThreadState* __tstate = wxPyBeginAllowThreads();
30908 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 {
30913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30914 }
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj = 0;
30923 wxPyApp *arg1 = (wxPyApp *) 0 ;
30924 int arg2 ;
30925 void *argp1 = 0 ;
30926 int res1 = 0 ;
30927 int val2 ;
30928 int ecode2 = 0 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 char * kwnames[] = {
30932 (char *) "self",(char *) "mode", NULL
30933 };
30934
30935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30937 if (!SWIG_IsOK(res1)) {
30938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30939 }
30940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30941 ecode2 = SWIG_AsVal_int(obj1, &val2);
30942 if (!SWIG_IsOK(ecode2)) {
30943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30944 }
30945 arg2 = static_cast< int >(val2);
30946 {
30947 PyThreadState* __tstate = wxPyBeginAllowThreads();
30948 (arg1)->SetPrintMode(arg2);
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 resultobj = SWIG_Py_Void();
30953 return resultobj;
30954 fail:
30955 return NULL;
30956 }
30957
30958
30959 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30960 PyObject *resultobj = 0;
30961 wxPyApp *arg1 = (wxPyApp *) 0 ;
30962 int result;
30963 void *argp1 = 0 ;
30964 int res1 = 0 ;
30965 PyObject *swig_obj[1] ;
30966
30967 if (!args) SWIG_fail;
30968 swig_obj[0] = args;
30969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30970 if (!SWIG_IsOK(res1)) {
30971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30972 }
30973 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 resultobj = SWIG_From_int(static_cast< int >(result));
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30988 PyObject *resultobj = 0;
30989 wxPyApp *arg1 = (wxPyApp *) 0 ;
30990 int arg2 ;
30991 void *argp1 = 0 ;
30992 int res1 = 0 ;
30993 int val2 ;
30994 int ecode2 = 0 ;
30995 PyObject * obj0 = 0 ;
30996 PyObject * obj1 = 0 ;
30997 char * kwnames[] = {
30998 (char *) "self",(char *) "mode", NULL
30999 };
31000
31001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31003 if (!SWIG_IsOK(res1)) {
31004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31005 }
31006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31007 ecode2 = SWIG_AsVal_int(obj1, &val2);
31008 if (!SWIG_IsOK(ecode2)) {
31009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31010 }
31011 arg2 = static_cast< int >(val2);
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 (arg1)->SetAssertMode(arg2);
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_Py_Void();
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxPyApp *arg1 = (wxPyApp *) 0 ;
31028 int result;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 PyObject *swig_obj[1] ;
31032
31033 if (!args) SWIG_fail;
31034 swig_obj[0] = args;
31035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31038 }
31039 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 result = (int)(arg1)->GetAssertMode();
31043 wxPyEndAllowThreads(__tstate);
31044 if (PyErr_Occurred()) SWIG_fail;
31045 }
31046 resultobj = SWIG_From_int(static_cast< int >(result));
31047 return resultobj;
31048 fail:
31049 return NULL;
31050 }
31051
31052
31053 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31054 PyObject *resultobj = 0;
31055 bool result;
31056
31057 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31061 wxPyEndAllowThreads(__tstate);
31062 if (PyErr_Occurred()) SWIG_fail;
31063 }
31064 {
31065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31066 }
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074 PyObject *resultobj = 0;
31075 long result;
31076
31077 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = (long)wxPyApp::GetMacAboutMenuItemId();
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = SWIG_From_long(static_cast< long >(result));
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31092 PyObject *resultobj = 0;
31093 long result;
31094
31095 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31096 {
31097 PyThreadState* __tstate = wxPyBeginAllowThreads();
31098 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31099 wxPyEndAllowThreads(__tstate);
31100 if (PyErr_Occurred()) SWIG_fail;
31101 }
31102 resultobj = SWIG_From_long(static_cast< long >(result));
31103 return resultobj;
31104 fail:
31105 return NULL;
31106 }
31107
31108
31109 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31110 PyObject *resultobj = 0;
31111 long result;
31112
31113 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31114 {
31115 PyThreadState* __tstate = wxPyBeginAllowThreads();
31116 result = (long)wxPyApp::GetMacExitMenuItemId();
31117 wxPyEndAllowThreads(__tstate);
31118 if (PyErr_Occurred()) SWIG_fail;
31119 }
31120 resultobj = SWIG_From_long(static_cast< long >(result));
31121 return resultobj;
31122 fail:
31123 return NULL;
31124 }
31125
31126
31127 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31128 PyObject *resultobj = 0;
31129 wxString result;
31130
31131 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 result = wxPyApp::GetMacHelpMenuTitleName();
31135 wxPyEndAllowThreads(__tstate);
31136 if (PyErr_Occurred()) SWIG_fail;
31137 }
31138 {
31139 #if wxUSE_UNICODE
31140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31141 #else
31142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31143 #endif
31144 }
31145 return resultobj;
31146 fail:
31147 return NULL;
31148 }
31149
31150
31151 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31152 PyObject *resultobj = 0;
31153 bool arg1 ;
31154 bool val1 ;
31155 int ecode1 = 0 ;
31156 PyObject * obj0 = 0 ;
31157 char * kwnames[] = {
31158 (char *) "val", NULL
31159 };
31160
31161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31162 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31163 if (!SWIG_IsOK(ecode1)) {
31164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31165 }
31166 arg1 = static_cast< bool >(val1);
31167 {
31168 PyThreadState* __tstate = wxPyBeginAllowThreads();
31169 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 resultobj = SWIG_Py_Void();
31174 return resultobj;
31175 fail:
31176 return NULL;
31177 }
31178
31179
31180 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31181 PyObject *resultobj = 0;
31182 long arg1 ;
31183 long val1 ;
31184 int ecode1 = 0 ;
31185 PyObject * obj0 = 0 ;
31186 char * kwnames[] = {
31187 (char *) "val", NULL
31188 };
31189
31190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31191 ecode1 = SWIG_AsVal_long(obj0, &val1);
31192 if (!SWIG_IsOK(ecode1)) {
31193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31194 }
31195 arg1 = static_cast< long >(val1);
31196 {
31197 PyThreadState* __tstate = wxPyBeginAllowThreads();
31198 wxPyApp::SetMacAboutMenuItemId(arg1);
31199 wxPyEndAllowThreads(__tstate);
31200 if (PyErr_Occurred()) SWIG_fail;
31201 }
31202 resultobj = SWIG_Py_Void();
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj = 0;
31211 long arg1 ;
31212 long val1 ;
31213 int ecode1 = 0 ;
31214 PyObject * obj0 = 0 ;
31215 char * kwnames[] = {
31216 (char *) "val", NULL
31217 };
31218
31219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31220 ecode1 = SWIG_AsVal_long(obj0, &val1);
31221 if (!SWIG_IsOK(ecode1)) {
31222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31223 }
31224 arg1 = static_cast< long >(val1);
31225 {
31226 PyThreadState* __tstate = wxPyBeginAllowThreads();
31227 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 resultobj = SWIG_Py_Void();
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj = 0;
31240 long arg1 ;
31241 long val1 ;
31242 int ecode1 = 0 ;
31243 PyObject * obj0 = 0 ;
31244 char * kwnames[] = {
31245 (char *) "val", NULL
31246 };
31247
31248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31249 ecode1 = SWIG_AsVal_long(obj0, &val1);
31250 if (!SWIG_IsOK(ecode1)) {
31251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31252 }
31253 arg1 = static_cast< long >(val1);
31254 {
31255 PyThreadState* __tstate = wxPyBeginAllowThreads();
31256 wxPyApp::SetMacExitMenuItemId(arg1);
31257 wxPyEndAllowThreads(__tstate);
31258 if (PyErr_Occurred()) SWIG_fail;
31259 }
31260 resultobj = SWIG_Py_Void();
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31268 PyObject *resultobj = 0;
31269 wxString *arg1 = 0 ;
31270 bool temp1 = false ;
31271 PyObject * obj0 = 0 ;
31272 char * kwnames[] = {
31273 (char *) "val", NULL
31274 };
31275
31276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31277 {
31278 arg1 = wxString_in_helper(obj0);
31279 if (arg1 == NULL) SWIG_fail;
31280 temp1 = true;
31281 }
31282 {
31283 PyThreadState* __tstate = wxPyBeginAllowThreads();
31284 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31285 wxPyEndAllowThreads(__tstate);
31286 if (PyErr_Occurred()) SWIG_fail;
31287 }
31288 resultobj = SWIG_Py_Void();
31289 {
31290 if (temp1)
31291 delete arg1;
31292 }
31293 return resultobj;
31294 fail:
31295 {
31296 if (temp1)
31297 delete arg1;
31298 }
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31304 PyObject *resultobj = 0;
31305 wxPyApp *arg1 = (wxPyApp *) 0 ;
31306 void *argp1 = 0 ;
31307 int res1 = 0 ;
31308 PyObject *swig_obj[1] ;
31309
31310 if (!args) SWIG_fail;
31311 swig_obj[0] = args;
31312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31313 if (!SWIG_IsOK(res1)) {
31314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31315 }
31316 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 (arg1)->_BootstrapApp();
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 resultobj = SWIG_Py_Void();
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31331 PyObject *resultobj = 0;
31332 int result;
31333
31334 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31335 {
31336 PyThreadState* __tstate = wxPyBeginAllowThreads();
31337 result = (int)wxPyApp::GetComCtl32Version();
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 resultobj = SWIG_From_int(static_cast< int >(result));
31342 return resultobj;
31343 fail:
31344 return NULL;
31345 }
31346
31347
31348 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31349 PyObject *resultobj = 0;
31350 bool result;
31351
31352 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 result = (bool)wxPyApp_IsDisplayAvailable();
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 {
31360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31361 }
31362 return resultobj;
31363 fail:
31364 return NULL;
31365 }
31366
31367
31368 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31369 PyObject *obj;
31370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31371 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31372 return SWIG_Py_Void();
31373 }
31374
31375 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31376 return SWIG_Python_InitShadowInstance(args);
31377 }
31378
31379 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31380 PyObject *resultobj = 0;
31381
31382 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 wxExit();
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 resultobj = SWIG_Py_Void();
31390 return resultobj;
31391 fail:
31392 return NULL;
31393 }
31394
31395
31396 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31397 PyObject *resultobj = 0;
31398 bool result;
31399
31400 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = (bool)wxYield();
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31409 }
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31417 PyObject *resultobj = 0;
31418 bool result;
31419
31420 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 result = (bool)wxYieldIfNeeded();
31424 wxPyEndAllowThreads(__tstate);
31425 if (PyErr_Occurred()) SWIG_fail;
31426 }
31427 {
31428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31429 }
31430 return resultobj;
31431 fail:
31432 return NULL;
31433 }
31434
31435
31436 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31437 PyObject *resultobj = 0;
31438 wxWindow *arg1 = (wxWindow *) NULL ;
31439 bool arg2 = (bool) false ;
31440 bool result;
31441 void *argp1 = 0 ;
31442 int res1 = 0 ;
31443 bool val2 ;
31444 int ecode2 = 0 ;
31445 PyObject * obj0 = 0 ;
31446 PyObject * obj1 = 0 ;
31447 char * kwnames[] = {
31448 (char *) "win",(char *) "onlyIfNeeded", NULL
31449 };
31450
31451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31452 if (obj0) {
31453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31454 if (!SWIG_IsOK(res1)) {
31455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31456 }
31457 arg1 = reinterpret_cast< wxWindow * >(argp1);
31458 }
31459 if (obj1) {
31460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31461 if (!SWIG_IsOK(ecode2)) {
31462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31463 }
31464 arg2 = static_cast< bool >(val2);
31465 }
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 result = (bool)wxSafeYield(arg1,arg2);
31469 wxPyEndAllowThreads(__tstate);
31470 if (PyErr_Occurred()) SWIG_fail;
31471 }
31472 {
31473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31474 }
31475 return resultobj;
31476 fail:
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *resultobj = 0;
31483
31484 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31485 {
31486 PyThreadState* __tstate = wxPyBeginAllowThreads();
31487 wxWakeUpIdle();
31488 wxPyEndAllowThreads(__tstate);
31489 if (PyErr_Occurred()) SWIG_fail;
31490 }
31491 resultobj = SWIG_Py_Void();
31492 return resultobj;
31493 fail:
31494 return NULL;
31495 }
31496
31497
31498 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31499 PyObject *resultobj = 0;
31500 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31501 wxEvent *arg2 = 0 ;
31502 void *argp1 = 0 ;
31503 int res1 = 0 ;
31504 void *argp2 = 0 ;
31505 int res2 = 0 ;
31506 PyObject * obj0 = 0 ;
31507 PyObject * obj1 = 0 ;
31508 char * kwnames[] = {
31509 (char *) "dest",(char *) "event", NULL
31510 };
31511
31512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31514 if (!SWIG_IsOK(res1)) {
31515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31516 }
31517 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31519 if (!SWIG_IsOK(res2)) {
31520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31521 }
31522 if (!argp2) {
31523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31524 }
31525 arg2 = reinterpret_cast< wxEvent * >(argp2);
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 wxPostEvent(arg1,*arg2);
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_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31540 PyObject *resultobj = 0;
31541
31542 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31543 {
31544 PyThreadState* __tstate = wxPyBeginAllowThreads();
31545 wxApp_CleanUp();
31546 wxPyEndAllowThreads(__tstate);
31547 if (PyErr_Occurred()) SWIG_fail;
31548 }
31549 resultobj = SWIG_Py_Void();
31550 return resultobj;
31551 fail:
31552 return NULL;
31553 }
31554
31555
31556 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31557 PyObject *resultobj = 0;
31558 wxPyApp *result = 0 ;
31559
31560 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 result = (wxPyApp *)wxPyGetApp();
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 {
31568 resultobj = wxPyMake_wxObject(result, 0);
31569 }
31570 return resultobj;
31571 fail:
31572 return NULL;
31573 }
31574
31575
31576 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31577 PyObject *resultobj = 0;
31578 char *arg1 = (char *) 0 ;
31579 int res1 ;
31580 char *buf1 = 0 ;
31581 int alloc1 = 0 ;
31582 PyObject * obj0 = 0 ;
31583 char * kwnames[] = {
31584 (char *) "encoding", NULL
31585 };
31586
31587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31588 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31589 if (!SWIG_IsOK(res1)) {
31590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31591 }
31592 arg1 = buf1;
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 wxSetDefaultPyEncoding((char const *)arg1);
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 resultobj = SWIG_Py_Void();
31600 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31601 return resultobj;
31602 fail:
31603 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31604 return NULL;
31605 }
31606
31607
31608 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31609 PyObject *resultobj = 0;
31610 char *result = 0 ;
31611
31612 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31613 {
31614 PyThreadState* __tstate = wxPyBeginAllowThreads();
31615 result = (char *)wxGetDefaultPyEncoding();
31616 wxPyEndAllowThreads(__tstate);
31617 if (PyErr_Occurred()) SWIG_fail;
31618 }
31619 resultobj = SWIG_FromCharPtr(result);
31620 return resultobj;
31621 fail:
31622 return NULL;
31623 }
31624
31625
31626 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31627 PyObject *resultobj = 0;
31628 wxEventLoop *result = 0 ;
31629
31630 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 result = (wxEventLoop *)new wxEventLoop();
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31647 void *argp1 = 0 ;
31648 int res1 = 0 ;
31649 PyObject *swig_obj[1] ;
31650
31651 if (!args) SWIG_fail;
31652 swig_obj[0] = args;
31653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31654 if (!SWIG_IsOK(res1)) {
31655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31656 }
31657 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31658 {
31659 PyThreadState* __tstate = wxPyBeginAllowThreads();
31660 delete arg1;
31661
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 resultobj = SWIG_Py_Void();
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31673 PyObject *resultobj = 0;
31674 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31675 int result;
31676 void *argp1 = 0 ;
31677 int res1 = 0 ;
31678 PyObject *swig_obj[1] ;
31679
31680 if (!args) SWIG_fail;
31681 swig_obj[0] = args;
31682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31683 if (!SWIG_IsOK(res1)) {
31684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31685 }
31686 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = (int)(arg1)->Run();
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 resultobj = SWIG_From_int(static_cast< int >(result));
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj = 0;
31702 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31703 int arg2 = (int) 0 ;
31704 void *argp1 = 0 ;
31705 int res1 = 0 ;
31706 int val2 ;
31707 int ecode2 = 0 ;
31708 PyObject * obj0 = 0 ;
31709 PyObject * obj1 = 0 ;
31710 char * kwnames[] = {
31711 (char *) "self",(char *) "rc", NULL
31712 };
31713
31714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31716 if (!SWIG_IsOK(res1)) {
31717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31718 }
31719 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31720 if (obj1) {
31721 ecode2 = SWIG_AsVal_int(obj1, &val2);
31722 if (!SWIG_IsOK(ecode2)) {
31723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31724 }
31725 arg2 = static_cast< int >(val2);
31726 }
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 (arg1)->Exit(arg2);
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 resultobj = SWIG_Py_Void();
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31741 PyObject *resultobj = 0;
31742 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31743 bool result;
31744 void *argp1 = 0 ;
31745 int res1 = 0 ;
31746 PyObject *swig_obj[1] ;
31747
31748 if (!args) SWIG_fail;
31749 swig_obj[0] = args;
31750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31751 if (!SWIG_IsOK(res1)) {
31752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31753 }
31754 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31755 {
31756 PyThreadState* __tstate = wxPyBeginAllowThreads();
31757 result = (bool)((wxEventLoop const *)arg1)->Pending();
31758 wxPyEndAllowThreads(__tstate);
31759 if (PyErr_Occurred()) SWIG_fail;
31760 }
31761 {
31762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31763 }
31764 return resultobj;
31765 fail:
31766 return NULL;
31767 }
31768
31769
31770 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31771 PyObject *resultobj = 0;
31772 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31773 bool result;
31774 void *argp1 = 0 ;
31775 int res1 = 0 ;
31776 PyObject *swig_obj[1] ;
31777
31778 if (!args) SWIG_fail;
31779 swig_obj[0] = args;
31780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31781 if (!SWIG_IsOK(res1)) {
31782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31783 }
31784 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31785 {
31786 PyThreadState* __tstate = wxPyBeginAllowThreads();
31787 result = (bool)(arg1)->Dispatch();
31788 wxPyEndAllowThreads(__tstate);
31789 if (PyErr_Occurred()) SWIG_fail;
31790 }
31791 {
31792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31793 }
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31801 PyObject *resultobj = 0;
31802 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31803 bool result;
31804 void *argp1 = 0 ;
31805 int res1 = 0 ;
31806 PyObject *swig_obj[1] ;
31807
31808 if (!args) SWIG_fail;
31809 swig_obj[0] = args;
31810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31811 if (!SWIG_IsOK(res1)) {
31812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31813 }
31814 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31815 {
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 {
31822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31823 }
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 PyObject *resultobj = 0;
31832 wxEventLoop *result = 0 ;
31833
31834 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31835 {
31836 PyThreadState* __tstate = wxPyBeginAllowThreads();
31837 result = (wxEventLoop *)wxEventLoop::GetActive();
31838 wxPyEndAllowThreads(__tstate);
31839 if (PyErr_Occurred()) SWIG_fail;
31840 }
31841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31842 return resultobj;
31843 fail:
31844 return NULL;
31845 }
31846
31847
31848 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31849 PyObject *resultobj = 0;
31850 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31851 void *argp1 = 0 ;
31852 int res1 = 0 ;
31853 PyObject * obj0 = 0 ;
31854 char * kwnames[] = {
31855 (char *) "loop", NULL
31856 };
31857
31858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31860 if (!SWIG_IsOK(res1)) {
31861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31862 }
31863 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31864 {
31865 PyThreadState* __tstate = wxPyBeginAllowThreads();
31866 wxEventLoop::SetActive(arg1);
31867 wxPyEndAllowThreads(__tstate);
31868 if (PyErr_Occurred()) SWIG_fail;
31869 }
31870 resultobj = SWIG_Py_Void();
31871 return resultobj;
31872 fail:
31873 return NULL;
31874 }
31875
31876
31877 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31878 PyObject *obj;
31879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31880 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31881 return SWIG_Py_Void();
31882 }
31883
31884 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31885 return SWIG_Python_InitShadowInstance(args);
31886 }
31887
31888 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31889 PyObject *resultobj = 0;
31890 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31891 wxEventLoopActivator *result = 0 ;
31892 void *argp1 = 0 ;
31893 int res1 = 0 ;
31894 PyObject * obj0 = 0 ;
31895 char * kwnames[] = {
31896 (char *) "evtLoop", NULL
31897 };
31898
31899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31903 }
31904 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *resultobj = 0;
31920 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 PyObject *swig_obj[1] ;
31924
31925 if (!args) SWIG_fail;
31926 swig_obj[0] = args;
31927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31930 }
31931 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 delete arg1;
31935
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_Py_Void();
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31947 PyObject *obj;
31948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31949 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31950 return SWIG_Py_Void();
31951 }
31952
31953 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 return SWIG_Python_InitShadowInstance(args);
31955 }
31956
31957 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31958 PyObject *resultobj = 0;
31959 int arg1 = (int) 0 ;
31960 int arg2 = (int) 0 ;
31961 int arg3 = (int) 0 ;
31962 wxAcceleratorEntry *result = 0 ;
31963 int val1 ;
31964 int ecode1 = 0 ;
31965 int val2 ;
31966 int ecode2 = 0 ;
31967 int val3 ;
31968 int ecode3 = 0 ;
31969 PyObject * obj0 = 0 ;
31970 PyObject * obj1 = 0 ;
31971 PyObject * obj2 = 0 ;
31972 char * kwnames[] = {
31973 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31974 };
31975
31976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31977 if (obj0) {
31978 ecode1 = SWIG_AsVal_int(obj0, &val1);
31979 if (!SWIG_IsOK(ecode1)) {
31980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31981 }
31982 arg1 = static_cast< int >(val1);
31983 }
31984 if (obj1) {
31985 ecode2 = SWIG_AsVal_int(obj1, &val2);
31986 if (!SWIG_IsOK(ecode2)) {
31987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31988 }
31989 arg2 = static_cast< int >(val2);
31990 }
31991 if (obj2) {
31992 ecode3 = SWIG_AsVal_int(obj2, &val3);
31993 if (!SWIG_IsOK(ecode3)) {
31994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31995 }
31996 arg3 = static_cast< int >(val3);
31997 }
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32012 PyObject *resultobj = 0;
32013 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 PyObject *swig_obj[1] ;
32017
32018 if (!args) SWIG_fail;
32019 swig_obj[0] = args;
32020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32021 if (!SWIG_IsOK(res1)) {
32022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32023 }
32024 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 delete arg1;
32028
32029 wxPyEndAllowThreads(__tstate);
32030 if (PyErr_Occurred()) SWIG_fail;
32031 }
32032 resultobj = SWIG_Py_Void();
32033 return resultobj;
32034 fail:
32035 return NULL;
32036 }
32037
32038
32039 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32040 PyObject *resultobj = 0;
32041 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32042 int arg2 ;
32043 int arg3 ;
32044 int arg4 ;
32045 void *argp1 = 0 ;
32046 int res1 = 0 ;
32047 int val2 ;
32048 int ecode2 = 0 ;
32049 int val3 ;
32050 int ecode3 = 0 ;
32051 int val4 ;
32052 int ecode4 = 0 ;
32053 PyObject * obj0 = 0 ;
32054 PyObject * obj1 = 0 ;
32055 PyObject * obj2 = 0 ;
32056 PyObject * obj3 = 0 ;
32057 char * kwnames[] = {
32058 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32059 };
32060
32061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32063 if (!SWIG_IsOK(res1)) {
32064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32065 }
32066 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32067 ecode2 = SWIG_AsVal_int(obj1, &val2);
32068 if (!SWIG_IsOK(ecode2)) {
32069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32070 }
32071 arg2 = static_cast< int >(val2);
32072 ecode3 = SWIG_AsVal_int(obj2, &val3);
32073 if (!SWIG_IsOK(ecode3)) {
32074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32075 }
32076 arg3 = static_cast< int >(val3);
32077 ecode4 = SWIG_AsVal_int(obj3, &val4);
32078 if (!SWIG_IsOK(ecode4)) {
32079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32080 }
32081 arg4 = static_cast< int >(val4);
32082 {
32083 PyThreadState* __tstate = wxPyBeginAllowThreads();
32084 (arg1)->Set(arg2,arg3,arg4);
32085 wxPyEndAllowThreads(__tstate);
32086 if (PyErr_Occurred()) SWIG_fail;
32087 }
32088 resultobj = SWIG_Py_Void();
32089 return resultobj;
32090 fail:
32091 return NULL;
32092 }
32093
32094
32095 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj = 0;
32097 wxString *arg1 = 0 ;
32098 wxAcceleratorEntry *result = 0 ;
32099 bool temp1 = false ;
32100 PyObject * obj0 = 0 ;
32101 char * kwnames[] = {
32102 (char *) "str", NULL
32103 };
32104
32105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32106 {
32107 arg1 = wxString_in_helper(obj0);
32108 if (arg1 == NULL) SWIG_fail;
32109 temp1 = true;
32110 }
32111 {
32112 PyThreadState* __tstate = wxPyBeginAllowThreads();
32113 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32118 {
32119 if (temp1)
32120 delete arg1;
32121 }
32122 return resultobj;
32123 fail:
32124 {
32125 if (temp1)
32126 delete arg1;
32127 }
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32135 int result;
32136 void *argp1 = 0 ;
32137 int res1 = 0 ;
32138 PyObject *swig_obj[1] ;
32139
32140 if (!args) SWIG_fail;
32141 swig_obj[0] = args;
32142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32145 }
32146 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = (int)(arg1)->GetFlags();
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_From_int(static_cast< int >(result));
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32163 int result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject *swig_obj[1] ;
32167
32168 if (!args) SWIG_fail;
32169 swig_obj[0] = args;
32170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32173 }
32174 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = (int)(arg1)->GetKeyCode();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 resultobj = SWIG_From_int(static_cast< int >(result));
32182 return resultobj;
32183 fail:
32184 return NULL;
32185 }
32186
32187
32188 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32189 PyObject *resultobj = 0;
32190 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32191 int result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 PyObject *swig_obj[1] ;
32195
32196 if (!args) SWIG_fail;
32197 swig_obj[0] = args;
32198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32199 if (!SWIG_IsOK(res1)) {
32200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32201 }
32202 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32203 {
32204 PyThreadState* __tstate = wxPyBeginAllowThreads();
32205 result = (int)(arg1)->GetCommand();
32206 wxPyEndAllowThreads(__tstate);
32207 if (PyErr_Occurred()) SWIG_fail;
32208 }
32209 resultobj = SWIG_From_int(static_cast< int >(result));
32210 return resultobj;
32211 fail:
32212 return NULL;
32213 }
32214
32215
32216 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32217 PyObject *resultobj = 0;
32218 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32219 bool result;
32220 void *argp1 = 0 ;
32221 int res1 = 0 ;
32222 PyObject *swig_obj[1] ;
32223
32224 if (!args) SWIG_fail;
32225 swig_obj[0] = args;
32226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32227 if (!SWIG_IsOK(res1)) {
32228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32229 }
32230 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32231 {
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32234 wxPyEndAllowThreads(__tstate);
32235 if (PyErr_Occurred()) SWIG_fail;
32236 }
32237 {
32238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32239 }
32240 return resultobj;
32241 fail:
32242 return NULL;
32243 }
32244
32245
32246 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32247 PyObject *resultobj = 0;
32248 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32249 wxString result;
32250 void *argp1 = 0 ;
32251 int res1 = 0 ;
32252 PyObject *swig_obj[1] ;
32253
32254 if (!args) SWIG_fail;
32255 swig_obj[0] = args;
32256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32257 if (!SWIG_IsOK(res1)) {
32258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32259 }
32260 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 {
32268 #if wxUSE_UNICODE
32269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32270 #else
32271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32272 #endif
32273 }
32274 return resultobj;
32275 fail:
32276 return NULL;
32277 }
32278
32279
32280 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32281 PyObject *resultobj = 0;
32282 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32283 wxString *arg2 = 0 ;
32284 bool result;
32285 void *argp1 = 0 ;
32286 int res1 = 0 ;
32287 bool temp2 = false ;
32288 PyObject * obj0 = 0 ;
32289 PyObject * obj1 = 0 ;
32290 char * kwnames[] = {
32291 (char *) "self",(char *) "str", NULL
32292 };
32293
32294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32296 if (!SWIG_IsOK(res1)) {
32297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32298 }
32299 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32300 {
32301 arg2 = wxString_in_helper(obj1);
32302 if (arg2 == NULL) SWIG_fail;
32303 temp2 = true;
32304 }
32305 {
32306 PyThreadState* __tstate = wxPyBeginAllowThreads();
32307 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32308 wxPyEndAllowThreads(__tstate);
32309 if (PyErr_Occurred()) SWIG_fail;
32310 }
32311 {
32312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32313 }
32314 {
32315 if (temp2)
32316 delete arg2;
32317 }
32318 return resultobj;
32319 fail:
32320 {
32321 if (temp2)
32322 delete arg2;
32323 }
32324 return NULL;
32325 }
32326
32327
32328 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32329 PyObject *obj;
32330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32331 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32332 return SWIG_Py_Void();
32333 }
32334
32335 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32336 return SWIG_Python_InitShadowInstance(args);
32337 }
32338
32339 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32340 PyObject *resultobj = 0;
32341 int arg1 ;
32342 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32343 wxAcceleratorTable *result = 0 ;
32344 PyObject * obj0 = 0 ;
32345 char * kwnames[] = {
32346 (char *) "n", NULL
32347 };
32348
32349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32350 {
32351 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32352 if (arg2) arg1 = PyList_Size(obj0);
32353 else arg1 = 0;
32354 }
32355 {
32356 PyThreadState* __tstate = wxPyBeginAllowThreads();
32357 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32358 wxPyEndAllowThreads(__tstate);
32359 if (PyErr_Occurred()) SWIG_fail;
32360 }
32361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32362 return resultobj;
32363 fail:
32364 return NULL;
32365 }
32366
32367
32368 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32369 PyObject *resultobj = 0;
32370 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32371 void *argp1 = 0 ;
32372 int res1 = 0 ;
32373 PyObject *swig_obj[1] ;
32374
32375 if (!args) SWIG_fail;
32376 swig_obj[0] = args;
32377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32378 if (!SWIG_IsOK(res1)) {
32379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32380 }
32381 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 delete arg1;
32385
32386 wxPyEndAllowThreads(__tstate);
32387 if (PyErr_Occurred()) SWIG_fail;
32388 }
32389 resultobj = SWIG_Py_Void();
32390 return resultobj;
32391 fail:
32392 return NULL;
32393 }
32394
32395
32396 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32397 PyObject *resultobj = 0;
32398 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32399 bool result;
32400 void *argp1 = 0 ;
32401 int res1 = 0 ;
32402 PyObject *swig_obj[1] ;
32403
32404 if (!args) SWIG_fail;
32405 swig_obj[0] = args;
32406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32407 if (!SWIG_IsOK(res1)) {
32408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32409 }
32410 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32411 {
32412 PyThreadState* __tstate = wxPyBeginAllowThreads();
32413 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32414 wxPyEndAllowThreads(__tstate);
32415 if (PyErr_Occurred()) SWIG_fail;
32416 }
32417 {
32418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32419 }
32420 return resultobj;
32421 fail:
32422 return NULL;
32423 }
32424
32425
32426 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32427 PyObject *obj;
32428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32429 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32430 return SWIG_Py_Void();
32431 }
32432
32433 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32434 return SWIG_Python_InitShadowInstance(args);
32435 }
32436
32437 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32438 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32439 return 1;
32440 }
32441
32442
32443 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32444 PyObject *pyobj = 0;
32445
32446 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32447 return pyobj;
32448 }
32449
32450
32451 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32452 PyObject *resultobj = 0;
32453 wxString *arg1 = 0 ;
32454 wxAcceleratorEntry *result = 0 ;
32455 bool temp1 = false ;
32456 PyObject * obj0 = 0 ;
32457 char * kwnames[] = {
32458 (char *) "label", NULL
32459 };
32460
32461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32462 {
32463 arg1 = wxString_in_helper(obj0);
32464 if (arg1 == NULL) SWIG_fail;
32465 temp1 = true;
32466 }
32467 {
32468 PyThreadState* __tstate = wxPyBeginAllowThreads();
32469 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32470 wxPyEndAllowThreads(__tstate);
32471 if (PyErr_Occurred()) SWIG_fail;
32472 }
32473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32474 {
32475 if (temp1)
32476 delete arg1;
32477 }
32478 return resultobj;
32479 fail:
32480 {
32481 if (temp1)
32482 delete arg1;
32483 }
32484 return NULL;
32485 }
32486
32487
32488 SWIGINTERN int PanelNameStr_set(PyObject *) {
32489 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32490 return 1;
32491 }
32492
32493
32494 SWIGINTERN PyObject *PanelNameStr_get(void) {
32495 PyObject *pyobj = 0;
32496
32497 {
32498 #if wxUSE_UNICODE
32499 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32500 #else
32501 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32502 #endif
32503 }
32504 return pyobj;
32505 }
32506
32507
32508 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32509 PyObject *resultobj = 0;
32510 wxVisualAttributes *result = 0 ;
32511
32512 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32513 {
32514 PyThreadState* __tstate = wxPyBeginAllowThreads();
32515 result = (wxVisualAttributes *)new_wxVisualAttributes();
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32527 PyObject *resultobj = 0;
32528 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32529 void *argp1 = 0 ;
32530 int res1 = 0 ;
32531 PyObject *swig_obj[1] ;
32532
32533 if (!args) SWIG_fail;
32534 swig_obj[0] = args;
32535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32536 if (!SWIG_IsOK(res1)) {
32537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32538 }
32539 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32540 {
32541 PyThreadState* __tstate = wxPyBeginAllowThreads();
32542 delete_wxVisualAttributes(arg1);
32543
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 resultobj = SWIG_Py_Void();
32548 return resultobj;
32549 fail:
32550 return NULL;
32551 }
32552
32553
32554 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32555 PyObject *resultobj = 0;
32556 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32557 wxFont *arg2 = (wxFont *) 0 ;
32558 void *argp1 = 0 ;
32559 int res1 = 0 ;
32560 void *argp2 = 0 ;
32561 int res2 = 0 ;
32562 PyObject *swig_obj[2] ;
32563
32564 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32566 if (!SWIG_IsOK(res1)) {
32567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32568 }
32569 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32570 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32571 if (!SWIG_IsOK(res2)) {
32572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32573 }
32574 arg2 = reinterpret_cast< wxFont * >(argp2);
32575 if (arg1) (arg1)->font = *arg2;
32576
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 PyObject *resultobj = 0;
32586 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32587 wxFont *result = 0 ;
32588 void *argp1 = 0 ;
32589 int res1 = 0 ;
32590 PyObject *swig_obj[1] ;
32591
32592 if (!args) SWIG_fail;
32593 swig_obj[0] = args;
32594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32595 if (!SWIG_IsOK(res1)) {
32596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32597 }
32598 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32599 result = (wxFont *)& ((arg1)->font);
32600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32601 return resultobj;
32602 fail:
32603 return NULL;
32604 }
32605
32606
32607 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32608 PyObject *resultobj = 0;
32609 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32610 wxColour *arg2 = (wxColour *) 0 ;
32611 void *argp1 = 0 ;
32612 int res1 = 0 ;
32613 void *argp2 = 0 ;
32614 int res2 = 0 ;
32615 PyObject *swig_obj[2] ;
32616
32617 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32619 if (!SWIG_IsOK(res1)) {
32620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32621 }
32622 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32623 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32624 if (!SWIG_IsOK(res2)) {
32625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32626 }
32627 arg2 = reinterpret_cast< wxColour * >(argp2);
32628 if (arg1) (arg1)->colFg = *arg2;
32629
32630 resultobj = SWIG_Py_Void();
32631 return resultobj;
32632 fail:
32633 return NULL;
32634 }
32635
32636
32637 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32638 PyObject *resultobj = 0;
32639 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32640 wxColour *result = 0 ;
32641 void *argp1 = 0 ;
32642 int res1 = 0 ;
32643 PyObject *swig_obj[1] ;
32644
32645 if (!args) SWIG_fail;
32646 swig_obj[0] = args;
32647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32648 if (!SWIG_IsOK(res1)) {
32649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32650 }
32651 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32652 result = (wxColour *)& ((arg1)->colFg);
32653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32654 return resultobj;
32655 fail:
32656 return NULL;
32657 }
32658
32659
32660 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32661 PyObject *resultobj = 0;
32662 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32663 wxColour *arg2 = (wxColour *) 0 ;
32664 void *argp1 = 0 ;
32665 int res1 = 0 ;
32666 void *argp2 = 0 ;
32667 int res2 = 0 ;
32668 PyObject *swig_obj[2] ;
32669
32670 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32672 if (!SWIG_IsOK(res1)) {
32673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32674 }
32675 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32676 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32677 if (!SWIG_IsOK(res2)) {
32678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32679 }
32680 arg2 = reinterpret_cast< wxColour * >(argp2);
32681 if (arg1) (arg1)->colBg = *arg2;
32682
32683 resultobj = SWIG_Py_Void();
32684 return resultobj;
32685 fail:
32686 return NULL;
32687 }
32688
32689
32690 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32691 PyObject *resultobj = 0;
32692 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32693 wxColour *result = 0 ;
32694 void *argp1 = 0 ;
32695 int res1 = 0 ;
32696 PyObject *swig_obj[1] ;
32697
32698 if (!args) SWIG_fail;
32699 swig_obj[0] = args;
32700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32701 if (!SWIG_IsOK(res1)) {
32702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32703 }
32704 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32705 result = (wxColour *)& ((arg1)->colBg);
32706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32707 return resultobj;
32708 fail:
32709 return NULL;
32710 }
32711
32712
32713 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32714 PyObject *obj;
32715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32716 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32717 return SWIG_Py_Void();
32718 }
32719
32720 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32721 return SWIG_Python_InitShadowInstance(args);
32722 }
32723
32724 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32725 PyObject *resultobj = 0;
32726 wxWindow *arg1 = (wxWindow *) 0 ;
32727 int arg2 = (int) (int)-1 ;
32728 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32729 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32730 wxSize const &arg4_defvalue = wxDefaultSize ;
32731 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32732 long arg5 = (long) 0 ;
32733 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32734 wxString *arg6 = (wxString *) &arg6_defvalue ;
32735 wxWindow *result = 0 ;
32736 void *argp1 = 0 ;
32737 int res1 = 0 ;
32738 int val2 ;
32739 int ecode2 = 0 ;
32740 wxPoint temp3 ;
32741 wxSize temp4 ;
32742 long val5 ;
32743 int ecode5 = 0 ;
32744 bool temp6 = false ;
32745 PyObject * obj0 = 0 ;
32746 PyObject * obj1 = 0 ;
32747 PyObject * obj2 = 0 ;
32748 PyObject * obj3 = 0 ;
32749 PyObject * obj4 = 0 ;
32750 PyObject * obj5 = 0 ;
32751 char * kwnames[] = {
32752 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32753 };
32754
32755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32757 if (!SWIG_IsOK(res1)) {
32758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32759 }
32760 arg1 = reinterpret_cast< wxWindow * >(argp1);
32761 if (obj1) {
32762 ecode2 = SWIG_AsVal_int(obj1, &val2);
32763 if (!SWIG_IsOK(ecode2)) {
32764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32765 }
32766 arg2 = static_cast< int >(val2);
32767 }
32768 if (obj2) {
32769 {
32770 arg3 = &temp3;
32771 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32772 }
32773 }
32774 if (obj3) {
32775 {
32776 arg4 = &temp4;
32777 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32778 }
32779 }
32780 if (obj4) {
32781 ecode5 = SWIG_AsVal_long(obj4, &val5);
32782 if (!SWIG_IsOK(ecode5)) {
32783 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32784 }
32785 arg5 = static_cast< long >(val5);
32786 }
32787 if (obj5) {
32788 {
32789 arg6 = wxString_in_helper(obj5);
32790 if (arg6 == NULL) SWIG_fail;
32791 temp6 = true;
32792 }
32793 }
32794 {
32795 if (!wxPyCheckForApp()) SWIG_fail;
32796 PyThreadState* __tstate = wxPyBeginAllowThreads();
32797 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32798 wxPyEndAllowThreads(__tstate);
32799 if (PyErr_Occurred()) SWIG_fail;
32800 }
32801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32802 {
32803 if (temp6)
32804 delete arg6;
32805 }
32806 return resultobj;
32807 fail:
32808 {
32809 if (temp6)
32810 delete arg6;
32811 }
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32817 PyObject *resultobj = 0;
32818 wxWindow *result = 0 ;
32819
32820 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32821 {
32822 if (!wxPyCheckForApp()) SWIG_fail;
32823 PyThreadState* __tstate = wxPyBeginAllowThreads();
32824 result = (wxWindow *)new wxWindow();
32825 wxPyEndAllowThreads(__tstate);
32826 if (PyErr_Occurred()) SWIG_fail;
32827 }
32828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32829 return resultobj;
32830 fail:
32831 return NULL;
32832 }
32833
32834
32835 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32836 PyObject *resultobj = 0;
32837 wxWindow *arg1 = (wxWindow *) 0 ;
32838 wxWindow *arg2 = (wxWindow *) 0 ;
32839 int arg3 = (int) (int)-1 ;
32840 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32841 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32842 wxSize const &arg5_defvalue = wxDefaultSize ;
32843 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32844 long arg6 = (long) 0 ;
32845 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32846 wxString *arg7 = (wxString *) &arg7_defvalue ;
32847 bool result;
32848 void *argp1 = 0 ;
32849 int res1 = 0 ;
32850 void *argp2 = 0 ;
32851 int res2 = 0 ;
32852 int val3 ;
32853 int ecode3 = 0 ;
32854 wxPoint temp4 ;
32855 wxSize temp5 ;
32856 long val6 ;
32857 int ecode6 = 0 ;
32858 bool temp7 = false ;
32859 PyObject * obj0 = 0 ;
32860 PyObject * obj1 = 0 ;
32861 PyObject * obj2 = 0 ;
32862 PyObject * obj3 = 0 ;
32863 PyObject * obj4 = 0 ;
32864 PyObject * obj5 = 0 ;
32865 PyObject * obj6 = 0 ;
32866 char * kwnames[] = {
32867 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32868 };
32869
32870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32872 if (!SWIG_IsOK(res1)) {
32873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32874 }
32875 arg1 = reinterpret_cast< wxWindow * >(argp1);
32876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32877 if (!SWIG_IsOK(res2)) {
32878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32879 }
32880 arg2 = reinterpret_cast< wxWindow * >(argp2);
32881 if (obj2) {
32882 ecode3 = SWIG_AsVal_int(obj2, &val3);
32883 if (!SWIG_IsOK(ecode3)) {
32884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32885 }
32886 arg3 = static_cast< int >(val3);
32887 }
32888 if (obj3) {
32889 {
32890 arg4 = &temp4;
32891 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32892 }
32893 }
32894 if (obj4) {
32895 {
32896 arg5 = &temp5;
32897 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32898 }
32899 }
32900 if (obj5) {
32901 ecode6 = SWIG_AsVal_long(obj5, &val6);
32902 if (!SWIG_IsOK(ecode6)) {
32903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32904 }
32905 arg6 = static_cast< long >(val6);
32906 }
32907 if (obj6) {
32908 {
32909 arg7 = wxString_in_helper(obj6);
32910 if (arg7 == NULL) SWIG_fail;
32911 temp7 = true;
32912 }
32913 }
32914 {
32915 PyThreadState* __tstate = wxPyBeginAllowThreads();
32916 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32917 wxPyEndAllowThreads(__tstate);
32918 if (PyErr_Occurred()) SWIG_fail;
32919 }
32920 {
32921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32922 }
32923 {
32924 if (temp7)
32925 delete arg7;
32926 }
32927 return resultobj;
32928 fail:
32929 {
32930 if (temp7)
32931 delete arg7;
32932 }
32933 return NULL;
32934 }
32935
32936
32937 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32938 PyObject *resultobj = 0;
32939 wxWindow *arg1 = (wxWindow *) 0 ;
32940 bool arg2 = (bool) false ;
32941 bool result;
32942 void *argp1 = 0 ;
32943 int res1 = 0 ;
32944 bool val2 ;
32945 int ecode2 = 0 ;
32946 PyObject * obj0 = 0 ;
32947 PyObject * obj1 = 0 ;
32948 char * kwnames[] = {
32949 (char *) "self",(char *) "force", NULL
32950 };
32951
32952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32954 if (!SWIG_IsOK(res1)) {
32955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32956 }
32957 arg1 = reinterpret_cast< wxWindow * >(argp1);
32958 if (obj1) {
32959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32960 if (!SWIG_IsOK(ecode2)) {
32961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32962 }
32963 arg2 = static_cast< bool >(val2);
32964 }
32965 {
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 result = (bool)(arg1)->Close(arg2);
32968 wxPyEndAllowThreads(__tstate);
32969 if (PyErr_Occurred()) SWIG_fail;
32970 }
32971 {
32972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32973 }
32974 return resultobj;
32975 fail:
32976 return NULL;
32977 }
32978
32979
32980 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32981 PyObject *resultobj = 0;
32982 wxWindow *arg1 = (wxWindow *) 0 ;
32983 bool 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_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32993 }
32994 arg1 = reinterpret_cast< wxWindow * >(argp1);
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = (bool)(arg1)->Destroy();
32998 wxPyEndAllowThreads(__tstate);
32999 if (PyErr_Occurred()) SWIG_fail;
33000 }
33001 {
33002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33003 }
33004 return resultobj;
33005 fail:
33006 return NULL;
33007 }
33008
33009
33010 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33011 PyObject *resultobj = 0;
33012 wxWindow *arg1 = (wxWindow *) 0 ;
33013 bool result;
33014 void *argp1 = 0 ;
33015 int res1 = 0 ;
33016 PyObject *swig_obj[1] ;
33017
33018 if (!args) SWIG_fail;
33019 swig_obj[0] = args;
33020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33021 if (!SWIG_IsOK(res1)) {
33022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33023 }
33024 arg1 = reinterpret_cast< wxWindow * >(argp1);
33025 {
33026 PyThreadState* __tstate = wxPyBeginAllowThreads();
33027 result = (bool)(arg1)->DestroyChildren();
33028 wxPyEndAllowThreads(__tstate);
33029 if (PyErr_Occurred()) SWIG_fail;
33030 }
33031 {
33032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33033 }
33034 return resultobj;
33035 fail:
33036 return NULL;
33037 }
33038
33039
33040 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33041 PyObject *resultobj = 0;
33042 wxWindow *arg1 = (wxWindow *) 0 ;
33043 bool result;
33044 void *argp1 = 0 ;
33045 int res1 = 0 ;
33046 PyObject *swig_obj[1] ;
33047
33048 if (!args) SWIG_fail;
33049 swig_obj[0] = args;
33050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33051 if (!SWIG_IsOK(res1)) {
33052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33053 }
33054 arg1 = reinterpret_cast< wxWindow * >(argp1);
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 {
33062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33063 }
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33071 PyObject *resultobj = 0;
33072 wxWindow *arg1 = (wxWindow *) 0 ;
33073 wxString *arg2 = 0 ;
33074 void *argp1 = 0 ;
33075 int res1 = 0 ;
33076 bool temp2 = false ;
33077 PyObject * obj0 = 0 ;
33078 PyObject * obj1 = 0 ;
33079 char * kwnames[] = {
33080 (char *) "self",(char *) "label", NULL
33081 };
33082
33083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33085 if (!SWIG_IsOK(res1)) {
33086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33087 }
33088 arg1 = reinterpret_cast< wxWindow * >(argp1);
33089 {
33090 arg2 = wxString_in_helper(obj1);
33091 if (arg2 == NULL) SWIG_fail;
33092 temp2 = true;
33093 }
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 (arg1)->SetLabel((wxString const &)*arg2);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_Py_Void();
33101 {
33102 if (temp2)
33103 delete arg2;
33104 }
33105 return resultobj;
33106 fail:
33107 {
33108 if (temp2)
33109 delete arg2;
33110 }
33111 return NULL;
33112 }
33113
33114
33115 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33116 PyObject *resultobj = 0;
33117 wxWindow *arg1 = (wxWindow *) 0 ;
33118 wxString result;
33119 void *argp1 = 0 ;
33120 int res1 = 0 ;
33121 PyObject *swig_obj[1] ;
33122
33123 if (!args) SWIG_fail;
33124 swig_obj[0] = args;
33125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33128 }
33129 arg1 = reinterpret_cast< wxWindow * >(argp1);
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 result = ((wxWindow const *)arg1)->GetLabel();
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 {
33137 #if wxUSE_UNICODE
33138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33139 #else
33140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33141 #endif
33142 }
33143 return resultobj;
33144 fail:
33145 return NULL;
33146 }
33147
33148
33149 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33150 PyObject *resultobj = 0;
33151 wxWindow *arg1 = (wxWindow *) 0 ;
33152 wxString *arg2 = 0 ;
33153 void *argp1 = 0 ;
33154 int res1 = 0 ;
33155 bool temp2 = false ;
33156 PyObject * obj0 = 0 ;
33157 PyObject * obj1 = 0 ;
33158 char * kwnames[] = {
33159 (char *) "self",(char *) "name", NULL
33160 };
33161
33162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33164 if (!SWIG_IsOK(res1)) {
33165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33166 }
33167 arg1 = reinterpret_cast< wxWindow * >(argp1);
33168 {
33169 arg2 = wxString_in_helper(obj1);
33170 if (arg2 == NULL) SWIG_fail;
33171 temp2 = true;
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 (arg1)->SetName((wxString const &)*arg2);
33176 wxPyEndAllowThreads(__tstate);
33177 if (PyErr_Occurred()) SWIG_fail;
33178 }
33179 resultobj = SWIG_Py_Void();
33180 {
33181 if (temp2)
33182 delete arg2;
33183 }
33184 return resultobj;
33185 fail:
33186 {
33187 if (temp2)
33188 delete arg2;
33189 }
33190 return NULL;
33191 }
33192
33193
33194 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33195 PyObject *resultobj = 0;
33196 wxWindow *arg1 = (wxWindow *) 0 ;
33197 wxString result;
33198 void *argp1 = 0 ;
33199 int res1 = 0 ;
33200 PyObject *swig_obj[1] ;
33201
33202 if (!args) SWIG_fail;
33203 swig_obj[0] = args;
33204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33205 if (!SWIG_IsOK(res1)) {
33206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33207 }
33208 arg1 = reinterpret_cast< wxWindow * >(argp1);
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 result = ((wxWindow const *)arg1)->GetName();
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 {
33216 #if wxUSE_UNICODE
33217 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33218 #else
33219 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33220 #endif
33221 }
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33229 PyObject *resultobj = 0;
33230 wxWindow *arg1 = (wxWindow *) 0 ;
33231 wxWindowVariant arg2 ;
33232 void *argp1 = 0 ;
33233 int res1 = 0 ;
33234 int val2 ;
33235 int ecode2 = 0 ;
33236 PyObject * obj0 = 0 ;
33237 PyObject * obj1 = 0 ;
33238 char * kwnames[] = {
33239 (char *) "self",(char *) "variant", NULL
33240 };
33241
33242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33244 if (!SWIG_IsOK(res1)) {
33245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33246 }
33247 arg1 = reinterpret_cast< wxWindow * >(argp1);
33248 ecode2 = SWIG_AsVal_int(obj1, &val2);
33249 if (!SWIG_IsOK(ecode2)) {
33250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33251 }
33252 arg2 = static_cast< wxWindowVariant >(val2);
33253 {
33254 PyThreadState* __tstate = wxPyBeginAllowThreads();
33255 (arg1)->SetWindowVariant(arg2);
33256 wxPyEndAllowThreads(__tstate);
33257 if (PyErr_Occurred()) SWIG_fail;
33258 }
33259 resultobj = SWIG_Py_Void();
33260 return resultobj;
33261 fail:
33262 return NULL;
33263 }
33264
33265
33266 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33267 PyObject *resultobj = 0;
33268 wxWindow *arg1 = (wxWindow *) 0 ;
33269 wxWindowVariant result;
33270 void *argp1 = 0 ;
33271 int res1 = 0 ;
33272 PyObject *swig_obj[1] ;
33273
33274 if (!args) SWIG_fail;
33275 swig_obj[0] = args;
33276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33277 if (!SWIG_IsOK(res1)) {
33278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33279 }
33280 arg1 = reinterpret_cast< wxWindow * >(argp1);
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 resultobj = SWIG_From_int(static_cast< int >(result));
33288 return resultobj;
33289 fail:
33290 return NULL;
33291 }
33292
33293
33294 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33295 PyObject *resultobj = 0;
33296 wxWindow *arg1 = (wxWindow *) 0 ;
33297 int arg2 ;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300 int val2 ;
33301 int ecode2 = 0 ;
33302 PyObject * obj0 = 0 ;
33303 PyObject * obj1 = 0 ;
33304 char * kwnames[] = {
33305 (char *) "self",(char *) "winid", NULL
33306 };
33307
33308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33310 if (!SWIG_IsOK(res1)) {
33311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33312 }
33313 arg1 = reinterpret_cast< wxWindow * >(argp1);
33314 ecode2 = SWIG_AsVal_int(obj1, &val2);
33315 if (!SWIG_IsOK(ecode2)) {
33316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33317 }
33318 arg2 = static_cast< int >(val2);
33319 {
33320 PyThreadState* __tstate = wxPyBeginAllowThreads();
33321 (arg1)->SetId(arg2);
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 resultobj = SWIG_Py_Void();
33326 return resultobj;
33327 fail:
33328 return NULL;
33329 }
33330
33331
33332 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33333 PyObject *resultobj = 0;
33334 wxWindow *arg1 = (wxWindow *) 0 ;
33335 int result;
33336 void *argp1 = 0 ;
33337 int res1 = 0 ;
33338 PyObject *swig_obj[1] ;
33339
33340 if (!args) SWIG_fail;
33341 swig_obj[0] = args;
33342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33343 if (!SWIG_IsOK(res1)) {
33344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33345 }
33346 arg1 = reinterpret_cast< wxWindow * >(argp1);
33347 {
33348 PyThreadState* __tstate = wxPyBeginAllowThreads();
33349 result = (int)((wxWindow const *)arg1)->GetId();
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 resultobj = SWIG_From_int(static_cast< int >(result));
33354 return resultobj;
33355 fail:
33356 return NULL;
33357 }
33358
33359
33360 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33361 PyObject *resultobj = 0;
33362 int result;
33363
33364 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33365 {
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 result = (int)wxWindow::NewControlId();
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 resultobj = SWIG_From_int(static_cast< int >(result));
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj = 0;
33380 int arg1 ;
33381 int result;
33382 int val1 ;
33383 int ecode1 = 0 ;
33384 PyObject * obj0 = 0 ;
33385 char * kwnames[] = {
33386 (char *) "winid", NULL
33387 };
33388
33389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33390 ecode1 = SWIG_AsVal_int(obj0, &val1);
33391 if (!SWIG_IsOK(ecode1)) {
33392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33393 }
33394 arg1 = static_cast< int >(val1);
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 result = (int)wxWindow::NextControlId(arg1);
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 resultobj = SWIG_From_int(static_cast< int >(result));
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33409 PyObject *resultobj = 0;
33410 int arg1 ;
33411 int result;
33412 int val1 ;
33413 int ecode1 = 0 ;
33414 PyObject * obj0 = 0 ;
33415 char * kwnames[] = {
33416 (char *) "winid", NULL
33417 };
33418
33419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33420 ecode1 = SWIG_AsVal_int(obj0, &val1);
33421 if (!SWIG_IsOK(ecode1)) {
33422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33423 }
33424 arg1 = static_cast< int >(val1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (int)wxWindow::PrevControlId(arg1);
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_From_int(static_cast< int >(result));
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *resultobj = 0;
33440 wxWindow *arg1 = (wxWindow *) 0 ;
33441 wxLayoutDirection result;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 PyObject *swig_obj[1] ;
33445
33446 if (!args) SWIG_fail;
33447 swig_obj[0] = args;
33448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33449 if (!SWIG_IsOK(res1)) {
33450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33451 }
33452 arg1 = reinterpret_cast< wxWindow * >(argp1);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = SWIG_From_int(static_cast< int >(result));
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33467 PyObject *resultobj = 0;
33468 wxWindow *arg1 = (wxWindow *) 0 ;
33469 wxLayoutDirection arg2 ;
33470 void *argp1 = 0 ;
33471 int res1 = 0 ;
33472 int val2 ;
33473 int ecode2 = 0 ;
33474 PyObject * obj0 = 0 ;
33475 PyObject * obj1 = 0 ;
33476 char * kwnames[] = {
33477 (char *) "self",(char *) "dir", NULL
33478 };
33479
33480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33482 if (!SWIG_IsOK(res1)) {
33483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33484 }
33485 arg1 = reinterpret_cast< wxWindow * >(argp1);
33486 ecode2 = SWIG_AsVal_int(obj1, &val2);
33487 if (!SWIG_IsOK(ecode2)) {
33488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33489 }
33490 arg2 = static_cast< wxLayoutDirection >(val2);
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 (arg1)->SetLayoutDirection(arg2);
33494 wxPyEndAllowThreads(__tstate);
33495 if (PyErr_Occurred()) SWIG_fail;
33496 }
33497 resultobj = SWIG_Py_Void();
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33505 PyObject *resultobj = 0;
33506 wxWindow *arg1 = (wxWindow *) 0 ;
33507 int arg2 ;
33508 int arg3 ;
33509 int arg4 ;
33510 int result;
33511 void *argp1 = 0 ;
33512 int res1 = 0 ;
33513 int val2 ;
33514 int ecode2 = 0 ;
33515 int val3 ;
33516 int ecode3 = 0 ;
33517 int val4 ;
33518 int ecode4 = 0 ;
33519 PyObject * obj0 = 0 ;
33520 PyObject * obj1 = 0 ;
33521 PyObject * obj2 = 0 ;
33522 PyObject * obj3 = 0 ;
33523 char * kwnames[] = {
33524 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33525 };
33526
33527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33529 if (!SWIG_IsOK(res1)) {
33530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33531 }
33532 arg1 = reinterpret_cast< wxWindow * >(argp1);
33533 ecode2 = SWIG_AsVal_int(obj1, &val2);
33534 if (!SWIG_IsOK(ecode2)) {
33535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33536 }
33537 arg2 = static_cast< int >(val2);
33538 ecode3 = SWIG_AsVal_int(obj2, &val3);
33539 if (!SWIG_IsOK(ecode3)) {
33540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33541 }
33542 arg3 = static_cast< int >(val3);
33543 ecode4 = SWIG_AsVal_int(obj3, &val4);
33544 if (!SWIG_IsOK(ecode4)) {
33545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33546 }
33547 arg4 = static_cast< int >(val4);
33548 {
33549 PyThreadState* __tstate = wxPyBeginAllowThreads();
33550 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33551 wxPyEndAllowThreads(__tstate);
33552 if (PyErr_Occurred()) SWIG_fail;
33553 }
33554 resultobj = SWIG_From_int(static_cast< int >(result));
33555 return resultobj;
33556 fail:
33557 return NULL;
33558 }
33559
33560
33561 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33562 PyObject *resultobj = 0;
33563 wxWindow *arg1 = (wxWindow *) 0 ;
33564 wxSize *arg2 = 0 ;
33565 void *argp1 = 0 ;
33566 int res1 = 0 ;
33567 wxSize temp2 ;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 char * kwnames[] = {
33571 (char *) "self",(char *) "size", NULL
33572 };
33573
33574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33576 if (!SWIG_IsOK(res1)) {
33577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33578 }
33579 arg1 = reinterpret_cast< wxWindow * >(argp1);
33580 {
33581 arg2 = &temp2;
33582 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33583 }
33584 {
33585 PyThreadState* __tstate = wxPyBeginAllowThreads();
33586 (arg1)->SetSize((wxSize const &)*arg2);
33587 wxPyEndAllowThreads(__tstate);
33588 if (PyErr_Occurred()) SWIG_fail;
33589 }
33590 resultobj = SWIG_Py_Void();
33591 return resultobj;
33592 fail:
33593 return NULL;
33594 }
33595
33596
33597 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33598 PyObject *resultobj = 0;
33599 wxWindow *arg1 = (wxWindow *) 0 ;
33600 int arg2 ;
33601 int arg3 ;
33602 int arg4 ;
33603 int arg5 ;
33604 int arg6 = (int) wxSIZE_AUTO ;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 int val2 ;
33608 int ecode2 = 0 ;
33609 int val3 ;
33610 int ecode3 = 0 ;
33611 int val4 ;
33612 int ecode4 = 0 ;
33613 int val5 ;
33614 int ecode5 = 0 ;
33615 int val6 ;
33616 int ecode6 = 0 ;
33617 PyObject * obj0 = 0 ;
33618 PyObject * obj1 = 0 ;
33619 PyObject * obj2 = 0 ;
33620 PyObject * obj3 = 0 ;
33621 PyObject * obj4 = 0 ;
33622 PyObject * obj5 = 0 ;
33623 char * kwnames[] = {
33624 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33625 };
33626
33627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33629 if (!SWIG_IsOK(res1)) {
33630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33631 }
33632 arg1 = reinterpret_cast< wxWindow * >(argp1);
33633 ecode2 = SWIG_AsVal_int(obj1, &val2);
33634 if (!SWIG_IsOK(ecode2)) {
33635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33636 }
33637 arg2 = static_cast< int >(val2);
33638 ecode3 = SWIG_AsVal_int(obj2, &val3);
33639 if (!SWIG_IsOK(ecode3)) {
33640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33641 }
33642 arg3 = static_cast< int >(val3);
33643 ecode4 = SWIG_AsVal_int(obj3, &val4);
33644 if (!SWIG_IsOK(ecode4)) {
33645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33646 }
33647 arg4 = static_cast< int >(val4);
33648 ecode5 = SWIG_AsVal_int(obj4, &val5);
33649 if (!SWIG_IsOK(ecode5)) {
33650 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33651 }
33652 arg5 = static_cast< int >(val5);
33653 if (obj5) {
33654 ecode6 = SWIG_AsVal_int(obj5, &val6);
33655 if (!SWIG_IsOK(ecode6)) {
33656 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33657 }
33658 arg6 = static_cast< int >(val6);
33659 }
33660 {
33661 PyThreadState* __tstate = wxPyBeginAllowThreads();
33662 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33663 wxPyEndAllowThreads(__tstate);
33664 if (PyErr_Occurred()) SWIG_fail;
33665 }
33666 resultobj = SWIG_Py_Void();
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj = 0;
33675 wxWindow *arg1 = (wxWindow *) 0 ;
33676 wxRect *arg2 = 0 ;
33677 int arg3 = (int) wxSIZE_AUTO ;
33678 void *argp1 = 0 ;
33679 int res1 = 0 ;
33680 wxRect temp2 ;
33681 int val3 ;
33682 int ecode3 = 0 ;
33683 PyObject * obj0 = 0 ;
33684 PyObject * obj1 = 0 ;
33685 PyObject * obj2 = 0 ;
33686 char * kwnames[] = {
33687 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33688 };
33689
33690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33692 if (!SWIG_IsOK(res1)) {
33693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33694 }
33695 arg1 = reinterpret_cast< wxWindow * >(argp1);
33696 {
33697 arg2 = &temp2;
33698 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33699 }
33700 if (obj2) {
33701 ecode3 = SWIG_AsVal_int(obj2, &val3);
33702 if (!SWIG_IsOK(ecode3)) {
33703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33704 }
33705 arg3 = static_cast< int >(val3);
33706 }
33707 {
33708 PyThreadState* __tstate = wxPyBeginAllowThreads();
33709 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33710 wxPyEndAllowThreads(__tstate);
33711 if (PyErr_Occurred()) SWIG_fail;
33712 }
33713 resultobj = SWIG_Py_Void();
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 int arg2 ;
33724 int arg3 ;
33725 void *argp1 = 0 ;
33726 int res1 = 0 ;
33727 int val2 ;
33728 int ecode2 = 0 ;
33729 int val3 ;
33730 int ecode3 = 0 ;
33731 PyObject * obj0 = 0 ;
33732 PyObject * obj1 = 0 ;
33733 PyObject * obj2 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "width",(char *) "height", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 ecode2 = SWIG_AsVal_int(obj1, &val2);
33745 if (!SWIG_IsOK(ecode2)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33747 }
33748 arg2 = static_cast< int >(val2);
33749 ecode3 = SWIG_AsVal_int(obj2, &val3);
33750 if (!SWIG_IsOK(ecode3)) {
33751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33752 }
33753 arg3 = static_cast< int >(val3);
33754 {
33755 PyThreadState* __tstate = wxPyBeginAllowThreads();
33756 (arg1)->SetSize(arg2,arg3);
33757 wxPyEndAllowThreads(__tstate);
33758 if (PyErr_Occurred()) SWIG_fail;
33759 }
33760 resultobj = SWIG_Py_Void();
33761 return resultobj;
33762 fail:
33763 return NULL;
33764 }
33765
33766
33767 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33768 PyObject *resultobj = 0;
33769 wxWindow *arg1 = (wxWindow *) 0 ;
33770 wxPoint *arg2 = 0 ;
33771 int arg3 = (int) wxSIZE_USE_EXISTING ;
33772 void *argp1 = 0 ;
33773 int res1 = 0 ;
33774 wxPoint temp2 ;
33775 int val3 ;
33776 int ecode3 = 0 ;
33777 PyObject * obj0 = 0 ;
33778 PyObject * obj1 = 0 ;
33779 PyObject * obj2 = 0 ;
33780 char * kwnames[] = {
33781 (char *) "self",(char *) "pt",(char *) "flags", NULL
33782 };
33783
33784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33786 if (!SWIG_IsOK(res1)) {
33787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33788 }
33789 arg1 = reinterpret_cast< wxWindow * >(argp1);
33790 {
33791 arg2 = &temp2;
33792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33793 }
33794 if (obj2) {
33795 ecode3 = SWIG_AsVal_int(obj2, &val3);
33796 if (!SWIG_IsOK(ecode3)) {
33797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33798 }
33799 arg3 = static_cast< int >(val3);
33800 }
33801 {
33802 PyThreadState* __tstate = wxPyBeginAllowThreads();
33803 (arg1)->Move((wxPoint const &)*arg2,arg3);
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 resultobj = SWIG_Py_Void();
33808 return resultobj;
33809 fail:
33810 return NULL;
33811 }
33812
33813
33814 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33815 PyObject *resultobj = 0;
33816 wxWindow *arg1 = (wxWindow *) 0 ;
33817 int arg2 ;
33818 int arg3 ;
33819 int arg4 = (int) wxSIZE_USE_EXISTING ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 int val2 ;
33823 int ecode2 = 0 ;
33824 int val3 ;
33825 int ecode3 = 0 ;
33826 int val4 ;
33827 int ecode4 = 0 ;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 PyObject * obj2 = 0 ;
33831 PyObject * obj3 = 0 ;
33832 char * kwnames[] = {
33833 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33834 };
33835
33836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33838 if (!SWIG_IsOK(res1)) {
33839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33840 }
33841 arg1 = reinterpret_cast< wxWindow * >(argp1);
33842 ecode2 = SWIG_AsVal_int(obj1, &val2);
33843 if (!SWIG_IsOK(ecode2)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33845 }
33846 arg2 = static_cast< int >(val2);
33847 ecode3 = SWIG_AsVal_int(obj2, &val3);
33848 if (!SWIG_IsOK(ecode3)) {
33849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33850 }
33851 arg3 = static_cast< int >(val3);
33852 if (obj3) {
33853 ecode4 = SWIG_AsVal_int(obj3, &val4);
33854 if (!SWIG_IsOK(ecode4)) {
33855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33856 }
33857 arg4 = static_cast< int >(val4);
33858 }
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 (arg1)->Move(arg2,arg3,arg4);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_Py_Void();
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 wxSize const &arg2_defvalue = wxDefaultSize ;
33876 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33877 void *argp1 = 0 ;
33878 int res1 = 0 ;
33879 wxSize temp2 ;
33880 PyObject * obj0 = 0 ;
33881 PyObject * obj1 = 0 ;
33882 char * kwnames[] = {
33883 (char *) "self",(char *) "size", NULL
33884 };
33885
33886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
33887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33888 if (!SWIG_IsOK(res1)) {
33889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33890 }
33891 arg1 = reinterpret_cast< wxWindow * >(argp1);
33892 if (obj1) {
33893 {
33894 arg2 = &temp2;
33895 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33896 }
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 resultobj = SWIG_Py_Void();
33905 return resultobj;
33906 fail:
33907 return NULL;
33908 }
33909
33910
33911 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33912 PyObject *resultobj = 0;
33913 wxWindow *arg1 = (wxWindow *) 0 ;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 PyObject *swig_obj[1] ;
33917
33918 if (!args) SWIG_fail;
33919 swig_obj[0] = args;
33920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33921 if (!SWIG_IsOK(res1)) {
33922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33923 }
33924 arg1 = reinterpret_cast< wxWindow * >(argp1);
33925 {
33926 PyThreadState* __tstate = wxPyBeginAllowThreads();
33927 (arg1)->Raise();
33928 wxPyEndAllowThreads(__tstate);
33929 if (PyErr_Occurred()) SWIG_fail;
33930 }
33931 resultobj = SWIG_Py_Void();
33932 return resultobj;
33933 fail:
33934 return NULL;
33935 }
33936
33937
33938 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33939 PyObject *resultobj = 0;
33940 wxWindow *arg1 = (wxWindow *) 0 ;
33941 void *argp1 = 0 ;
33942 int res1 = 0 ;
33943 PyObject *swig_obj[1] ;
33944
33945 if (!args) SWIG_fail;
33946 swig_obj[0] = args;
33947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33948 if (!SWIG_IsOK(res1)) {
33949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33950 }
33951 arg1 = reinterpret_cast< wxWindow * >(argp1);
33952 {
33953 PyThreadState* __tstate = wxPyBeginAllowThreads();
33954 (arg1)->Lower();
33955 wxPyEndAllowThreads(__tstate);
33956 if (PyErr_Occurred()) SWIG_fail;
33957 }
33958 resultobj = SWIG_Py_Void();
33959 return resultobj;
33960 fail:
33961 return NULL;
33962 }
33963
33964
33965 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33966 PyObject *resultobj = 0;
33967 wxWindow *arg1 = (wxWindow *) 0 ;
33968 wxSize *arg2 = 0 ;
33969 void *argp1 = 0 ;
33970 int res1 = 0 ;
33971 wxSize temp2 ;
33972 PyObject * obj0 = 0 ;
33973 PyObject * obj1 = 0 ;
33974 char * kwnames[] = {
33975 (char *) "self",(char *) "size", NULL
33976 };
33977
33978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33980 if (!SWIG_IsOK(res1)) {
33981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33982 }
33983 arg1 = reinterpret_cast< wxWindow * >(argp1);
33984 {
33985 arg2 = &temp2;
33986 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33987 }
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 (arg1)->SetClientSize((wxSize const &)*arg2);
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 resultobj = SWIG_Py_Void();
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34002 PyObject *resultobj = 0;
34003 wxWindow *arg1 = (wxWindow *) 0 ;
34004 int arg2 ;
34005 int arg3 ;
34006 void *argp1 = 0 ;
34007 int res1 = 0 ;
34008 int val2 ;
34009 int ecode2 = 0 ;
34010 int val3 ;
34011 int ecode3 = 0 ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 PyObject * obj2 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "width",(char *) "height", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34023 }
34024 arg1 = reinterpret_cast< wxWindow * >(argp1);
34025 ecode2 = SWIG_AsVal_int(obj1, &val2);
34026 if (!SWIG_IsOK(ecode2)) {
34027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34028 }
34029 arg2 = static_cast< int >(val2);
34030 ecode3 = SWIG_AsVal_int(obj2, &val3);
34031 if (!SWIG_IsOK(ecode3)) {
34032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34033 }
34034 arg3 = static_cast< int >(val3);
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 (arg1)->SetClientSize(arg2,arg3);
34038 wxPyEndAllowThreads(__tstate);
34039 if (PyErr_Occurred()) SWIG_fail;
34040 }
34041 resultobj = SWIG_Py_Void();
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxWindow *arg1 = (wxWindow *) 0 ;
34051 wxRect *arg2 = 0 ;
34052 void *argp1 = 0 ;
34053 int res1 = 0 ;
34054 wxRect temp2 ;
34055 PyObject * obj0 = 0 ;
34056 PyObject * obj1 = 0 ;
34057 char * kwnames[] = {
34058 (char *) "self",(char *) "rect", NULL
34059 };
34060
34061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 arg2 = &temp2;
34069 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34070 }
34071 {
34072 PyThreadState* __tstate = wxPyBeginAllowThreads();
34073 (arg1)->SetClientSize((wxRect const &)*arg2);
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 resultobj = SWIG_Py_Void();
34078 return resultobj;
34079 fail:
34080 return NULL;
34081 }
34082
34083
34084 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34085 PyObject *resultobj = 0;
34086 wxWindow *arg1 = (wxWindow *) 0 ;
34087 wxPoint result;
34088 void *argp1 = 0 ;
34089 int res1 = 0 ;
34090 PyObject *swig_obj[1] ;
34091
34092 if (!args) SWIG_fail;
34093 swig_obj[0] = args;
34094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34095 if (!SWIG_IsOK(res1)) {
34096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34097 }
34098 arg1 = reinterpret_cast< wxWindow * >(argp1);
34099 {
34100 PyThreadState* __tstate = wxPyBeginAllowThreads();
34101 result = ((wxWindow const *)arg1)->GetPosition();
34102 wxPyEndAllowThreads(__tstate);
34103 if (PyErr_Occurred()) SWIG_fail;
34104 }
34105 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34106 return resultobj;
34107 fail:
34108 return NULL;
34109 }
34110
34111
34112 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34113 PyObject *resultobj = 0;
34114 wxWindow *arg1 = (wxWindow *) 0 ;
34115 int *arg2 = (int *) 0 ;
34116 int *arg3 = (int *) 0 ;
34117 void *argp1 = 0 ;
34118 int res1 = 0 ;
34119 int temp2 ;
34120 int res2 = SWIG_TMPOBJ ;
34121 int temp3 ;
34122 int res3 = SWIG_TMPOBJ ;
34123 PyObject *swig_obj[1] ;
34124
34125 arg2 = &temp2;
34126 arg3 = &temp3;
34127 if (!args) SWIG_fail;
34128 swig_obj[0] = args;
34129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34130 if (!SWIG_IsOK(res1)) {
34131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34132 }
34133 arg1 = reinterpret_cast< wxWindow * >(argp1);
34134 {
34135 PyThreadState* __tstate = wxPyBeginAllowThreads();
34136 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34137 wxPyEndAllowThreads(__tstate);
34138 if (PyErr_Occurred()) SWIG_fail;
34139 }
34140 resultobj = SWIG_Py_Void();
34141 if (SWIG_IsTmpObj(res2)) {
34142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34143 } else {
34144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34146 }
34147 if (SWIG_IsTmpObj(res3)) {
34148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34149 } else {
34150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34152 }
34153 return resultobj;
34154 fail:
34155 return NULL;
34156 }
34157
34158
34159 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34160 PyObject *resultobj = 0;
34161 wxWindow *arg1 = (wxWindow *) 0 ;
34162 wxPoint result;
34163 void *argp1 = 0 ;
34164 int res1 = 0 ;
34165 PyObject *swig_obj[1] ;
34166
34167 if (!args) SWIG_fail;
34168 swig_obj[0] = args;
34169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34172 }
34173 arg1 = reinterpret_cast< wxWindow * >(argp1);
34174 {
34175 PyThreadState* __tstate = wxPyBeginAllowThreads();
34176 result = ((wxWindow const *)arg1)->GetScreenPosition();
34177 wxPyEndAllowThreads(__tstate);
34178 if (PyErr_Occurred()) SWIG_fail;
34179 }
34180 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34181 return resultobj;
34182 fail:
34183 return NULL;
34184 }
34185
34186
34187 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34188 PyObject *resultobj = 0;
34189 wxWindow *arg1 = (wxWindow *) 0 ;
34190 int *arg2 = (int *) 0 ;
34191 int *arg3 = (int *) 0 ;
34192 void *argp1 = 0 ;
34193 int res1 = 0 ;
34194 int temp2 ;
34195 int res2 = SWIG_TMPOBJ ;
34196 int temp3 ;
34197 int res3 = SWIG_TMPOBJ ;
34198 PyObject *swig_obj[1] ;
34199
34200 arg2 = &temp2;
34201 arg3 = &temp3;
34202 if (!args) SWIG_fail;
34203 swig_obj[0] = args;
34204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34205 if (!SWIG_IsOK(res1)) {
34206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34207 }
34208 arg1 = reinterpret_cast< wxWindow * >(argp1);
34209 {
34210 PyThreadState* __tstate = wxPyBeginAllowThreads();
34211 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34212 wxPyEndAllowThreads(__tstate);
34213 if (PyErr_Occurred()) SWIG_fail;
34214 }
34215 resultobj = SWIG_Py_Void();
34216 if (SWIG_IsTmpObj(res2)) {
34217 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34218 } else {
34219 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34220 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34221 }
34222 if (SWIG_IsTmpObj(res3)) {
34223 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34224 } else {
34225 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34226 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34227 }
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34235 PyObject *resultobj = 0;
34236 wxWindow *arg1 = (wxWindow *) 0 ;
34237 wxRect result;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 PyObject *swig_obj[1] ;
34241
34242 if (!args) SWIG_fail;
34243 swig_obj[0] = args;
34244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34245 if (!SWIG_IsOK(res1)) {
34246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34247 }
34248 arg1 = reinterpret_cast< wxWindow * >(argp1);
34249 {
34250 PyThreadState* __tstate = wxPyBeginAllowThreads();
34251 result = ((wxWindow const *)arg1)->GetScreenRect();
34252 wxPyEndAllowThreads(__tstate);
34253 if (PyErr_Occurred()) SWIG_fail;
34254 }
34255 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34256 return resultobj;
34257 fail:
34258 return NULL;
34259 }
34260
34261
34262 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34263 PyObject *resultobj = 0;
34264 wxWindow *arg1 = (wxWindow *) 0 ;
34265 wxSize result;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 PyObject *swig_obj[1] ;
34269
34270 if (!args) SWIG_fail;
34271 swig_obj[0] = args;
34272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34273 if (!SWIG_IsOK(res1)) {
34274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34275 }
34276 arg1 = reinterpret_cast< wxWindow * >(argp1);
34277 {
34278 PyThreadState* __tstate = wxPyBeginAllowThreads();
34279 result = ((wxWindow const *)arg1)->GetSize();
34280 wxPyEndAllowThreads(__tstate);
34281 if (PyErr_Occurred()) SWIG_fail;
34282 }
34283 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34291 PyObject *resultobj = 0;
34292 wxWindow *arg1 = (wxWindow *) 0 ;
34293 int *arg2 = (int *) 0 ;
34294 int *arg3 = (int *) 0 ;
34295 void *argp1 = 0 ;
34296 int res1 = 0 ;
34297 int temp2 ;
34298 int res2 = SWIG_TMPOBJ ;
34299 int temp3 ;
34300 int res3 = SWIG_TMPOBJ ;
34301 PyObject *swig_obj[1] ;
34302
34303 arg2 = &temp2;
34304 arg3 = &temp3;
34305 if (!args) SWIG_fail;
34306 swig_obj[0] = args;
34307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34308 if (!SWIG_IsOK(res1)) {
34309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34310 }
34311 arg1 = reinterpret_cast< wxWindow * >(argp1);
34312 {
34313 PyThreadState* __tstate = wxPyBeginAllowThreads();
34314 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34315 wxPyEndAllowThreads(__tstate);
34316 if (PyErr_Occurred()) SWIG_fail;
34317 }
34318 resultobj = SWIG_Py_Void();
34319 if (SWIG_IsTmpObj(res2)) {
34320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34321 } else {
34322 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34324 }
34325 if (SWIG_IsTmpObj(res3)) {
34326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34327 } else {
34328 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34330 }
34331 return resultobj;
34332 fail:
34333 return NULL;
34334 }
34335
34336
34337 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34338 PyObject *resultobj = 0;
34339 wxWindow *arg1 = (wxWindow *) 0 ;
34340 wxRect result;
34341 void *argp1 = 0 ;
34342 int res1 = 0 ;
34343 PyObject *swig_obj[1] ;
34344
34345 if (!args) SWIG_fail;
34346 swig_obj[0] = args;
34347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34348 if (!SWIG_IsOK(res1)) {
34349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34350 }
34351 arg1 = reinterpret_cast< wxWindow * >(argp1);
34352 {
34353 PyThreadState* __tstate = wxPyBeginAllowThreads();
34354 result = ((wxWindow const *)arg1)->GetRect();
34355 wxPyEndAllowThreads(__tstate);
34356 if (PyErr_Occurred()) SWIG_fail;
34357 }
34358 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34359 return resultobj;
34360 fail:
34361 return NULL;
34362 }
34363
34364
34365 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34366 PyObject *resultobj = 0;
34367 wxWindow *arg1 = (wxWindow *) 0 ;
34368 wxSize result;
34369 void *argp1 = 0 ;
34370 int res1 = 0 ;
34371 PyObject *swig_obj[1] ;
34372
34373 if (!args) SWIG_fail;
34374 swig_obj[0] = args;
34375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34376 if (!SWIG_IsOK(res1)) {
34377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34378 }
34379 arg1 = reinterpret_cast< wxWindow * >(argp1);
34380 {
34381 PyThreadState* __tstate = wxPyBeginAllowThreads();
34382 result = ((wxWindow const *)arg1)->GetClientSize();
34383 wxPyEndAllowThreads(__tstate);
34384 if (PyErr_Occurred()) SWIG_fail;
34385 }
34386 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34387 return resultobj;
34388 fail:
34389 return NULL;
34390 }
34391
34392
34393 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34394 PyObject *resultobj = 0;
34395 wxWindow *arg1 = (wxWindow *) 0 ;
34396 int *arg2 = (int *) 0 ;
34397 int *arg3 = (int *) 0 ;
34398 void *argp1 = 0 ;
34399 int res1 = 0 ;
34400 int temp2 ;
34401 int res2 = SWIG_TMPOBJ ;
34402 int temp3 ;
34403 int res3 = SWIG_TMPOBJ ;
34404 PyObject *swig_obj[1] ;
34405
34406 arg2 = &temp2;
34407 arg3 = &temp3;
34408 if (!args) SWIG_fail;
34409 swig_obj[0] = args;
34410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34411 if (!SWIG_IsOK(res1)) {
34412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34413 }
34414 arg1 = reinterpret_cast< wxWindow * >(argp1);
34415 {
34416 PyThreadState* __tstate = wxPyBeginAllowThreads();
34417 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34418 wxPyEndAllowThreads(__tstate);
34419 if (PyErr_Occurred()) SWIG_fail;
34420 }
34421 resultobj = SWIG_Py_Void();
34422 if (SWIG_IsTmpObj(res2)) {
34423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34424 } else {
34425 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34427 }
34428 if (SWIG_IsTmpObj(res3)) {
34429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34430 } else {
34431 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34433 }
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34441 PyObject *resultobj = 0;
34442 wxWindow *arg1 = (wxWindow *) 0 ;
34443 wxPoint result;
34444 void *argp1 = 0 ;
34445 int res1 = 0 ;
34446 PyObject *swig_obj[1] ;
34447
34448 if (!args) SWIG_fail;
34449 swig_obj[0] = args;
34450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34451 if (!SWIG_IsOK(res1)) {
34452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34453 }
34454 arg1 = reinterpret_cast< wxWindow * >(argp1);
34455 {
34456 PyThreadState* __tstate = wxPyBeginAllowThreads();
34457 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34458 wxPyEndAllowThreads(__tstate);
34459 if (PyErr_Occurred()) SWIG_fail;
34460 }
34461 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34462 return resultobj;
34463 fail:
34464 return NULL;
34465 }
34466
34467
34468 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34469 PyObject *resultobj = 0;
34470 wxWindow *arg1 = (wxWindow *) 0 ;
34471 wxRect result;
34472 void *argp1 = 0 ;
34473 int res1 = 0 ;
34474 PyObject *swig_obj[1] ;
34475
34476 if (!args) SWIG_fail;
34477 swig_obj[0] = args;
34478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 result = ((wxWindow const *)arg1)->GetClientRect();
34486 wxPyEndAllowThreads(__tstate);
34487 if (PyErr_Occurred()) SWIG_fail;
34488 }
34489 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34490 return resultobj;
34491 fail:
34492 return NULL;
34493 }
34494
34495
34496 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34497 PyObject *resultobj = 0;
34498 wxWindow *arg1 = (wxWindow *) 0 ;
34499 wxSize result;
34500 void *argp1 = 0 ;
34501 int res1 = 0 ;
34502 PyObject *swig_obj[1] ;
34503
34504 if (!args) SWIG_fail;
34505 swig_obj[0] = args;
34506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34507 if (!SWIG_IsOK(res1)) {
34508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34509 }
34510 arg1 = reinterpret_cast< wxWindow * >(argp1);
34511 {
34512 PyThreadState* __tstate = wxPyBeginAllowThreads();
34513 result = ((wxWindow const *)arg1)->GetBestSize();
34514 wxPyEndAllowThreads(__tstate);
34515 if (PyErr_Occurred()) SWIG_fail;
34516 }
34517 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34518 return resultobj;
34519 fail:
34520 return NULL;
34521 }
34522
34523
34524 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34525 PyObject *resultobj = 0;
34526 wxWindow *arg1 = (wxWindow *) 0 ;
34527 int *arg2 = (int *) 0 ;
34528 int *arg3 = (int *) 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 int temp2 ;
34532 int res2 = SWIG_TMPOBJ ;
34533 int temp3 ;
34534 int res3 = SWIG_TMPOBJ ;
34535 PyObject *swig_obj[1] ;
34536
34537 arg2 = &temp2;
34538 arg3 = &temp3;
34539 if (!args) SWIG_fail;
34540 swig_obj[0] = args;
34541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34542 if (!SWIG_IsOK(res1)) {
34543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34544 }
34545 arg1 = reinterpret_cast< wxWindow * >(argp1);
34546 {
34547 PyThreadState* __tstate = wxPyBeginAllowThreads();
34548 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34549 wxPyEndAllowThreads(__tstate);
34550 if (PyErr_Occurred()) SWIG_fail;
34551 }
34552 resultobj = SWIG_Py_Void();
34553 if (SWIG_IsTmpObj(res2)) {
34554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34555 } else {
34556 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34558 }
34559 if (SWIG_IsTmpObj(res3)) {
34560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34561 } else {
34562 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34563 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34564 }
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34572 PyObject *resultobj = 0;
34573 wxWindow *arg1 = (wxWindow *) 0 ;
34574 void *argp1 = 0 ;
34575 int res1 = 0 ;
34576 PyObject *swig_obj[1] ;
34577
34578 if (!args) SWIG_fail;
34579 swig_obj[0] = args;
34580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34581 if (!SWIG_IsOK(res1)) {
34582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34583 }
34584 arg1 = reinterpret_cast< wxWindow * >(argp1);
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 (arg1)->InvalidateBestSize();
34588 wxPyEndAllowThreads(__tstate);
34589 if (PyErr_Occurred()) SWIG_fail;
34590 }
34591 resultobj = SWIG_Py_Void();
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34599 PyObject *resultobj = 0;
34600 wxWindow *arg1 = (wxWindow *) 0 ;
34601 wxSize *arg2 = 0 ;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 wxSize temp2 ;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 char * kwnames[] = {
34608 (char *) "self",(char *) "size", NULL
34609 };
34610
34611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34615 }
34616 arg1 = reinterpret_cast< wxWindow * >(argp1);
34617 {
34618 arg2 = &temp2;
34619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34620 }
34621 {
34622 PyThreadState* __tstate = wxPyBeginAllowThreads();
34623 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34624 wxPyEndAllowThreads(__tstate);
34625 if (PyErr_Occurred()) SWIG_fail;
34626 }
34627 resultobj = SWIG_Py_Void();
34628 return resultobj;
34629 fail:
34630 return NULL;
34631 }
34632
34633
34634 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34635 PyObject *resultobj = 0;
34636 wxWindow *arg1 = (wxWindow *) 0 ;
34637 wxSize result;
34638 void *argp1 = 0 ;
34639 int res1 = 0 ;
34640 PyObject *swig_obj[1] ;
34641
34642 if (!args) SWIG_fail;
34643 swig_obj[0] = args;
34644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34645 if (!SWIG_IsOK(res1)) {
34646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34647 }
34648 arg1 = reinterpret_cast< wxWindow * >(argp1);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = ((wxWindow const *)arg1)->GetBestFittingSize();
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj = 0;
34664 wxWindow *arg1 = (wxWindow *) 0 ;
34665 int arg2 = (int) wxBOTH ;
34666 void *argp1 = 0 ;
34667 int res1 = 0 ;
34668 int val2 ;
34669 int ecode2 = 0 ;
34670 PyObject * obj0 = 0 ;
34671 PyObject * obj1 = 0 ;
34672 char * kwnames[] = {
34673 (char *) "self",(char *) "direction", NULL
34674 };
34675
34676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34680 }
34681 arg1 = reinterpret_cast< wxWindow * >(argp1);
34682 if (obj1) {
34683 ecode2 = SWIG_AsVal_int(obj1, &val2);
34684 if (!SWIG_IsOK(ecode2)) {
34685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34686 }
34687 arg2 = static_cast< int >(val2);
34688 }
34689 {
34690 PyThreadState* __tstate = wxPyBeginAllowThreads();
34691 (arg1)->Center(arg2);
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 resultobj = SWIG_Py_Void();
34696 return resultobj;
34697 fail:
34698 return NULL;
34699 }
34700
34701
34702 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34703 PyObject *resultobj = 0;
34704 wxWindow *arg1 = (wxWindow *) 0 ;
34705 int arg2 = (int) wxBOTH ;
34706 void *argp1 = 0 ;
34707 int res1 = 0 ;
34708 int val2 ;
34709 int ecode2 = 0 ;
34710 PyObject * obj0 = 0 ;
34711 PyObject * obj1 = 0 ;
34712 char * kwnames[] = {
34713 (char *) "self",(char *) "dir", NULL
34714 };
34715
34716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34720 }
34721 arg1 = reinterpret_cast< wxWindow * >(argp1);
34722 if (obj1) {
34723 ecode2 = SWIG_AsVal_int(obj1, &val2);
34724 if (!SWIG_IsOK(ecode2)) {
34725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34726 }
34727 arg2 = static_cast< int >(val2);
34728 }
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 (arg1)->CenterOnParent(arg2);
34732 wxPyEndAllowThreads(__tstate);
34733 if (PyErr_Occurred()) SWIG_fail;
34734 }
34735 resultobj = SWIG_Py_Void();
34736 return resultobj;
34737 fail:
34738 return NULL;
34739 }
34740
34741
34742 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34743 PyObject *resultobj = 0;
34744 wxWindow *arg1 = (wxWindow *) 0 ;
34745 void *argp1 = 0 ;
34746 int res1 = 0 ;
34747 PyObject *swig_obj[1] ;
34748
34749 if (!args) SWIG_fail;
34750 swig_obj[0] = args;
34751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34752 if (!SWIG_IsOK(res1)) {
34753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34754 }
34755 arg1 = reinterpret_cast< wxWindow * >(argp1);
34756 {
34757 PyThreadState* __tstate = wxPyBeginAllowThreads();
34758 (arg1)->Fit();
34759 wxPyEndAllowThreads(__tstate);
34760 if (PyErr_Occurred()) SWIG_fail;
34761 }
34762 resultobj = SWIG_Py_Void();
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34770 PyObject *resultobj = 0;
34771 wxWindow *arg1 = (wxWindow *) 0 ;
34772 void *argp1 = 0 ;
34773 int res1 = 0 ;
34774 PyObject *swig_obj[1] ;
34775
34776 if (!args) SWIG_fail;
34777 swig_obj[0] = args;
34778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34779 if (!SWIG_IsOK(res1)) {
34780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34781 }
34782 arg1 = reinterpret_cast< wxWindow * >(argp1);
34783 {
34784 PyThreadState* __tstate = wxPyBeginAllowThreads();
34785 (arg1)->FitInside();
34786 wxPyEndAllowThreads(__tstate);
34787 if (PyErr_Occurred()) SWIG_fail;
34788 }
34789 resultobj = SWIG_Py_Void();
34790 return resultobj;
34791 fail:
34792 return NULL;
34793 }
34794
34795
34796 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34797 PyObject *resultobj = 0;
34798 wxWindow *arg1 = (wxWindow *) 0 ;
34799 int arg2 ;
34800 int arg3 ;
34801 int arg4 = (int) -1 ;
34802 int arg5 = (int) -1 ;
34803 int arg6 = (int) -1 ;
34804 int arg7 = (int) -1 ;
34805 void *argp1 = 0 ;
34806 int res1 = 0 ;
34807 int val2 ;
34808 int ecode2 = 0 ;
34809 int val3 ;
34810 int ecode3 = 0 ;
34811 int val4 ;
34812 int ecode4 = 0 ;
34813 int val5 ;
34814 int ecode5 = 0 ;
34815 int val6 ;
34816 int ecode6 = 0 ;
34817 int val7 ;
34818 int ecode7 = 0 ;
34819 PyObject * obj0 = 0 ;
34820 PyObject * obj1 = 0 ;
34821 PyObject * obj2 = 0 ;
34822 PyObject * obj3 = 0 ;
34823 PyObject * obj4 = 0 ;
34824 PyObject * obj5 = 0 ;
34825 PyObject * obj6 = 0 ;
34826 char * kwnames[] = {
34827 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34828 };
34829
34830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34832 if (!SWIG_IsOK(res1)) {
34833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34834 }
34835 arg1 = reinterpret_cast< wxWindow * >(argp1);
34836 ecode2 = SWIG_AsVal_int(obj1, &val2);
34837 if (!SWIG_IsOK(ecode2)) {
34838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34839 }
34840 arg2 = static_cast< int >(val2);
34841 ecode3 = SWIG_AsVal_int(obj2, &val3);
34842 if (!SWIG_IsOK(ecode3)) {
34843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34844 }
34845 arg3 = static_cast< int >(val3);
34846 if (obj3) {
34847 ecode4 = SWIG_AsVal_int(obj3, &val4);
34848 if (!SWIG_IsOK(ecode4)) {
34849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34850 }
34851 arg4 = static_cast< int >(val4);
34852 }
34853 if (obj4) {
34854 ecode5 = SWIG_AsVal_int(obj4, &val5);
34855 if (!SWIG_IsOK(ecode5)) {
34856 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34857 }
34858 arg5 = static_cast< int >(val5);
34859 }
34860 if (obj5) {
34861 ecode6 = SWIG_AsVal_int(obj5, &val6);
34862 if (!SWIG_IsOK(ecode6)) {
34863 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34864 }
34865 arg6 = static_cast< int >(val6);
34866 }
34867 if (obj6) {
34868 ecode7 = SWIG_AsVal_int(obj6, &val7);
34869 if (!SWIG_IsOK(ecode7)) {
34870 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34871 }
34872 arg7 = static_cast< int >(val7);
34873 }
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 resultobj = SWIG_Py_Void();
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj = 0;
34889 wxWindow *arg1 = (wxWindow *) 0 ;
34890 wxSize *arg2 = 0 ;
34891 wxSize const &arg3_defvalue = wxDefaultSize ;
34892 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34893 wxSize const &arg4_defvalue = wxDefaultSize ;
34894 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 wxSize temp2 ;
34898 wxSize temp3 ;
34899 wxSize temp4 ;
34900 PyObject * obj0 = 0 ;
34901 PyObject * obj1 = 0 ;
34902 PyObject * obj2 = 0 ;
34903 PyObject * obj3 = 0 ;
34904 char * kwnames[] = {
34905 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34906 };
34907
34908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34910 if (!SWIG_IsOK(res1)) {
34911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34912 }
34913 arg1 = reinterpret_cast< wxWindow * >(argp1);
34914 {
34915 arg2 = &temp2;
34916 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34917 }
34918 if (obj2) {
34919 {
34920 arg3 = &temp3;
34921 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34922 }
34923 }
34924 if (obj3) {
34925 {
34926 arg4 = &temp4;
34927 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34928 }
34929 }
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 resultobj = SWIG_Py_Void();
34937 return resultobj;
34938 fail:
34939 return NULL;
34940 }
34941
34942
34943 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34944 PyObject *resultobj = 0;
34945 wxWindow *arg1 = (wxWindow *) 0 ;
34946 int arg2 ;
34947 int arg3 ;
34948 int arg4 = (int) -1 ;
34949 int arg5 = (int) -1 ;
34950 void *argp1 = 0 ;
34951 int res1 = 0 ;
34952 int val2 ;
34953 int ecode2 = 0 ;
34954 int val3 ;
34955 int ecode3 = 0 ;
34956 int val4 ;
34957 int ecode4 = 0 ;
34958 int val5 ;
34959 int ecode5 = 0 ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 PyObject * obj2 = 0 ;
34963 PyObject * obj3 = 0 ;
34964 PyObject * obj4 = 0 ;
34965 char * kwnames[] = {
34966 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34967 };
34968
34969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34971 if (!SWIG_IsOK(res1)) {
34972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34973 }
34974 arg1 = reinterpret_cast< wxWindow * >(argp1);
34975 ecode2 = SWIG_AsVal_int(obj1, &val2);
34976 if (!SWIG_IsOK(ecode2)) {
34977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34978 }
34979 arg2 = static_cast< int >(val2);
34980 ecode3 = SWIG_AsVal_int(obj2, &val3);
34981 if (!SWIG_IsOK(ecode3)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34983 }
34984 arg3 = static_cast< int >(val3);
34985 if (obj3) {
34986 ecode4 = SWIG_AsVal_int(obj3, &val4);
34987 if (!SWIG_IsOK(ecode4)) {
34988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34989 }
34990 arg4 = static_cast< int >(val4);
34991 }
34992 if (obj4) {
34993 ecode5 = SWIG_AsVal_int(obj4, &val5);
34994 if (!SWIG_IsOK(ecode5)) {
34995 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34996 }
34997 arg5 = static_cast< int >(val5);
34998 }
34999 {
35000 PyThreadState* __tstate = wxPyBeginAllowThreads();
35001 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35002 wxPyEndAllowThreads(__tstate);
35003 if (PyErr_Occurred()) SWIG_fail;
35004 }
35005 resultobj = SWIG_Py_Void();
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35013 PyObject *resultobj = 0;
35014 wxWindow *arg1 = (wxWindow *) 0 ;
35015 wxSize *arg2 = 0 ;
35016 wxSize const &arg3_defvalue = wxDefaultSize ;
35017 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 wxSize temp2 ;
35021 wxSize temp3 ;
35022 PyObject * obj0 = 0 ;
35023 PyObject * obj1 = 0 ;
35024 PyObject * obj2 = 0 ;
35025 char * kwnames[] = {
35026 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35027 };
35028
35029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35031 if (!SWIG_IsOK(res1)) {
35032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35033 }
35034 arg1 = reinterpret_cast< wxWindow * >(argp1);
35035 {
35036 arg2 = &temp2;
35037 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35038 }
35039 if (obj2) {
35040 {
35041 arg3 = &temp3;
35042 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35043 }
35044 }
35045 {
35046 PyThreadState* __tstate = wxPyBeginAllowThreads();
35047 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35048 wxPyEndAllowThreads(__tstate);
35049 if (PyErr_Occurred()) SWIG_fail;
35050 }
35051 resultobj = SWIG_Py_Void();
35052 return resultobj;
35053 fail:
35054 return NULL;
35055 }
35056
35057
35058 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35059 PyObject *resultobj = 0;
35060 wxWindow *arg1 = (wxWindow *) 0 ;
35061 wxSize result;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 PyObject *swig_obj[1] ;
35065
35066 if (!args) SWIG_fail;
35067 swig_obj[0] = args;
35068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35069 if (!SWIG_IsOK(res1)) {
35070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35071 }
35072 arg1 = reinterpret_cast< wxWindow * >(argp1);
35073 {
35074 PyThreadState* __tstate = wxPyBeginAllowThreads();
35075 result = ((wxWindow const *)arg1)->GetMaxSize();
35076 wxPyEndAllowThreads(__tstate);
35077 if (PyErr_Occurred()) SWIG_fail;
35078 }
35079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35080 return resultobj;
35081 fail:
35082 return NULL;
35083 }
35084
35085
35086 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35087 PyObject *resultobj = 0;
35088 wxWindow *arg1 = (wxWindow *) 0 ;
35089 wxSize result;
35090 void *argp1 = 0 ;
35091 int res1 = 0 ;
35092 PyObject *swig_obj[1] ;
35093
35094 if (!args) SWIG_fail;
35095 swig_obj[0] = args;
35096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = ((wxWindow const *)arg1)->GetMinSize();
35104 wxPyEndAllowThreads(__tstate);
35105 if (PyErr_Occurred()) SWIG_fail;
35106 }
35107 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj = 0;
35116 wxWindow *arg1 = (wxWindow *) 0 ;
35117 wxSize *arg2 = 0 ;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 wxSize temp2 ;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 char * kwnames[] = {
35124 (char *) "self",(char *) "minSize", NULL
35125 };
35126
35127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35129 if (!SWIG_IsOK(res1)) {
35130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35131 }
35132 arg1 = reinterpret_cast< wxWindow * >(argp1);
35133 {
35134 arg2 = &temp2;
35135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 (arg1)->SetMinSize((wxSize const &)*arg2);
35140 wxPyEndAllowThreads(__tstate);
35141 if (PyErr_Occurred()) SWIG_fail;
35142 }
35143 resultobj = SWIG_Py_Void();
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35151 PyObject *resultobj = 0;
35152 wxWindow *arg1 = (wxWindow *) 0 ;
35153 wxSize *arg2 = 0 ;
35154 void *argp1 = 0 ;
35155 int res1 = 0 ;
35156 wxSize temp2 ;
35157 PyObject * obj0 = 0 ;
35158 PyObject * obj1 = 0 ;
35159 char * kwnames[] = {
35160 (char *) "self",(char *) "maxSize", NULL
35161 };
35162
35163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35165 if (!SWIG_IsOK(res1)) {
35166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35167 }
35168 arg1 = reinterpret_cast< wxWindow * >(argp1);
35169 {
35170 arg2 = &temp2;
35171 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35172 }
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 (arg1)->SetMaxSize((wxSize const &)*arg2);
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 resultobj = SWIG_Py_Void();
35180 return resultobj;
35181 fail:
35182 return NULL;
35183 }
35184
35185
35186 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 int result;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 PyObject *swig_obj[1] ;
35193
35194 if (!args) SWIG_fail;
35195 swig_obj[0] = args;
35196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35197 if (!SWIG_IsOK(res1)) {
35198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35199 }
35200 arg1 = reinterpret_cast< wxWindow * >(argp1);
35201 {
35202 PyThreadState* __tstate = wxPyBeginAllowThreads();
35203 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35204 wxPyEndAllowThreads(__tstate);
35205 if (PyErr_Occurred()) SWIG_fail;
35206 }
35207 resultobj = SWIG_From_int(static_cast< int >(result));
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 int result;
35218 void *argp1 = 0 ;
35219 int res1 = 0 ;
35220 PyObject *swig_obj[1] ;
35221
35222 if (!args) SWIG_fail;
35223 swig_obj[0] = args;
35224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35225 if (!SWIG_IsOK(res1)) {
35226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_From_int(static_cast< int >(result));
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35243 PyObject *resultobj = 0;
35244 wxWindow *arg1 = (wxWindow *) 0 ;
35245 int result;
35246 void *argp1 = 0 ;
35247 int res1 = 0 ;
35248 PyObject *swig_obj[1] ;
35249
35250 if (!args) SWIG_fail;
35251 swig_obj[0] = args;
35252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35253 if (!SWIG_IsOK(res1)) {
35254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35255 }
35256 arg1 = reinterpret_cast< wxWindow * >(argp1);
35257 {
35258 PyThreadState* __tstate = wxPyBeginAllowThreads();
35259 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 resultobj = SWIG_From_int(static_cast< int >(result));
35264 return resultobj;
35265 fail:
35266 return NULL;
35267 }
35268
35269
35270 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35271 PyObject *resultobj = 0;
35272 wxWindow *arg1 = (wxWindow *) 0 ;
35273 int result;
35274 void *argp1 = 0 ;
35275 int res1 = 0 ;
35276 PyObject *swig_obj[1] ;
35277
35278 if (!args) SWIG_fail;
35279 swig_obj[0] = args;
35280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35281 if (!SWIG_IsOK(res1)) {
35282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35283 }
35284 arg1 = reinterpret_cast< wxWindow * >(argp1);
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35288 wxPyEndAllowThreads(__tstate);
35289 if (PyErr_Occurred()) SWIG_fail;
35290 }
35291 resultobj = SWIG_From_int(static_cast< int >(result));
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 wxSize *arg2 = 0 ;
35302 void *argp1 = 0 ;
35303 int res1 = 0 ;
35304 wxSize temp2 ;
35305 PyObject * obj0 = 0 ;
35306 PyObject * obj1 = 0 ;
35307 char * kwnames[] = {
35308 (char *) "self",(char *) "size", NULL
35309 };
35310
35311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35313 if (!SWIG_IsOK(res1)) {
35314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35315 }
35316 arg1 = reinterpret_cast< wxWindow * >(argp1);
35317 {
35318 arg2 = &temp2;
35319 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35320 }
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 resultobj = SWIG_Py_Void();
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj = 0;
35336 wxWindow *arg1 = (wxWindow *) 0 ;
35337 int arg2 ;
35338 int arg3 ;
35339 void *argp1 = 0 ;
35340 int res1 = 0 ;
35341 int val2 ;
35342 int ecode2 = 0 ;
35343 int val3 ;
35344 int ecode3 = 0 ;
35345 PyObject * obj0 = 0 ;
35346 PyObject * obj1 = 0 ;
35347 PyObject * obj2 = 0 ;
35348 char * kwnames[] = {
35349 (char *) "self",(char *) "w",(char *) "h", NULL
35350 };
35351
35352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35354 if (!SWIG_IsOK(res1)) {
35355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35356 }
35357 arg1 = reinterpret_cast< wxWindow * >(argp1);
35358 ecode2 = SWIG_AsVal_int(obj1, &val2);
35359 if (!SWIG_IsOK(ecode2)) {
35360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35361 }
35362 arg2 = static_cast< int >(val2);
35363 ecode3 = SWIG_AsVal_int(obj2, &val3);
35364 if (!SWIG_IsOK(ecode3)) {
35365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35366 }
35367 arg3 = static_cast< int >(val3);
35368 {
35369 PyThreadState* __tstate = wxPyBeginAllowThreads();
35370 (arg1)->SetVirtualSize(arg2,arg3);
35371 wxPyEndAllowThreads(__tstate);
35372 if (PyErr_Occurred()) SWIG_fail;
35373 }
35374 resultobj = SWIG_Py_Void();
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35382 PyObject *resultobj = 0;
35383 wxWindow *arg1 = (wxWindow *) 0 ;
35384 wxSize result;
35385 void *argp1 = 0 ;
35386 int res1 = 0 ;
35387 PyObject *swig_obj[1] ;
35388
35389 if (!args) SWIG_fail;
35390 swig_obj[0] = args;
35391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35392 if (!SWIG_IsOK(res1)) {
35393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35394 }
35395 arg1 = reinterpret_cast< wxWindow * >(argp1);
35396 {
35397 PyThreadState* __tstate = wxPyBeginAllowThreads();
35398 result = ((wxWindow const *)arg1)->GetVirtualSize();
35399 wxPyEndAllowThreads(__tstate);
35400 if (PyErr_Occurred()) SWIG_fail;
35401 }
35402 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35403 return resultobj;
35404 fail:
35405 return NULL;
35406 }
35407
35408
35409 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35410 PyObject *resultobj = 0;
35411 wxWindow *arg1 = (wxWindow *) 0 ;
35412 int *arg2 = (int *) 0 ;
35413 int *arg3 = (int *) 0 ;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 int temp2 ;
35417 int res2 = SWIG_TMPOBJ ;
35418 int temp3 ;
35419 int res3 = SWIG_TMPOBJ ;
35420 PyObject *swig_obj[1] ;
35421
35422 arg2 = &temp2;
35423 arg3 = &temp3;
35424 if (!args) SWIG_fail;
35425 swig_obj[0] = args;
35426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35427 if (!SWIG_IsOK(res1)) {
35428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35429 }
35430 arg1 = reinterpret_cast< wxWindow * >(argp1);
35431 {
35432 PyThreadState* __tstate = wxPyBeginAllowThreads();
35433 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35434 wxPyEndAllowThreads(__tstate);
35435 if (PyErr_Occurred()) SWIG_fail;
35436 }
35437 resultobj = SWIG_Py_Void();
35438 if (SWIG_IsTmpObj(res2)) {
35439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35440 } else {
35441 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35443 }
35444 if (SWIG_IsTmpObj(res3)) {
35445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35446 } else {
35447 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35449 }
35450 return resultobj;
35451 fail:
35452 return NULL;
35453 }
35454
35455
35456 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35457 PyObject *resultobj = 0;
35458 wxWindow *arg1 = (wxWindow *) 0 ;
35459 wxSize result;
35460 void *argp1 = 0 ;
35461 int res1 = 0 ;
35462 PyObject *swig_obj[1] ;
35463
35464 if (!args) SWIG_fail;
35465 swig_obj[0] = args;
35466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35467 if (!SWIG_IsOK(res1)) {
35468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35469 }
35470 arg1 = reinterpret_cast< wxWindow * >(argp1);
35471 {
35472 PyThreadState* __tstate = wxPyBeginAllowThreads();
35473 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35474 wxPyEndAllowThreads(__tstate);
35475 if (PyErr_Occurred()) SWIG_fail;
35476 }
35477 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35478 return resultobj;
35479 fail:
35480 return NULL;
35481 }
35482
35483
35484 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35485 PyObject *resultobj = 0;
35486 wxWindow *arg1 = (wxWindow *) 0 ;
35487 bool arg2 = (bool) true ;
35488 bool result;
35489 void *argp1 = 0 ;
35490 int res1 = 0 ;
35491 bool val2 ;
35492 int ecode2 = 0 ;
35493 PyObject * obj0 = 0 ;
35494 PyObject * obj1 = 0 ;
35495 char * kwnames[] = {
35496 (char *) "self",(char *) "show", NULL
35497 };
35498
35499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35503 }
35504 arg1 = reinterpret_cast< wxWindow * >(argp1);
35505 if (obj1) {
35506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35507 if (!SWIG_IsOK(ecode2)) {
35508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35509 }
35510 arg2 = static_cast< bool >(val2);
35511 }
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 result = (bool)(arg1)->Show(arg2);
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 {
35519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35520 }
35521 return resultobj;
35522 fail:
35523 return NULL;
35524 }
35525
35526
35527 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35528 PyObject *resultobj = 0;
35529 wxWindow *arg1 = (wxWindow *) 0 ;
35530 bool result;
35531 void *argp1 = 0 ;
35532 int res1 = 0 ;
35533 PyObject *swig_obj[1] ;
35534
35535 if (!args) SWIG_fail;
35536 swig_obj[0] = args;
35537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35538 if (!SWIG_IsOK(res1)) {
35539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35540 }
35541 arg1 = reinterpret_cast< wxWindow * >(argp1);
35542 {
35543 PyThreadState* __tstate = wxPyBeginAllowThreads();
35544 result = (bool)(arg1)->Hide();
35545 wxPyEndAllowThreads(__tstate);
35546 if (PyErr_Occurred()) SWIG_fail;
35547 }
35548 {
35549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35550 }
35551 return resultobj;
35552 fail:
35553 return NULL;
35554 }
35555
35556
35557 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35558 PyObject *resultobj = 0;
35559 wxWindow *arg1 = (wxWindow *) 0 ;
35560 bool arg2 = (bool) true ;
35561 bool result;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 bool val2 ;
35565 int ecode2 = 0 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "enable", NULL
35570 };
35571
35572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 if (obj1) {
35579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35580 if (!SWIG_IsOK(ecode2)) {
35581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35582 }
35583 arg2 = static_cast< bool >(val2);
35584 }
35585 {
35586 PyThreadState* __tstate = wxPyBeginAllowThreads();
35587 result = (bool)(arg1)->Enable(arg2);
35588 wxPyEndAllowThreads(__tstate);
35589 if (PyErr_Occurred()) SWIG_fail;
35590 }
35591 {
35592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35593 }
35594 return resultobj;
35595 fail:
35596 return NULL;
35597 }
35598
35599
35600 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35601 PyObject *resultobj = 0;
35602 wxWindow *arg1 = (wxWindow *) 0 ;
35603 bool result;
35604 void *argp1 = 0 ;
35605 int res1 = 0 ;
35606 PyObject *swig_obj[1] ;
35607
35608 if (!args) SWIG_fail;
35609 swig_obj[0] = args;
35610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35611 if (!SWIG_IsOK(res1)) {
35612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35613 }
35614 arg1 = reinterpret_cast< wxWindow * >(argp1);
35615 {
35616 PyThreadState* __tstate = wxPyBeginAllowThreads();
35617 result = (bool)(arg1)->Disable();
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 {
35622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35623 }
35624 return resultobj;
35625 fail:
35626 return NULL;
35627 }
35628
35629
35630 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35631 PyObject *resultobj = 0;
35632 wxWindow *arg1 = (wxWindow *) 0 ;
35633 bool result;
35634 void *argp1 = 0 ;
35635 int res1 = 0 ;
35636 PyObject *swig_obj[1] ;
35637
35638 if (!args) SWIG_fail;
35639 swig_obj[0] = args;
35640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35641 if (!SWIG_IsOK(res1)) {
35642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35643 }
35644 arg1 = reinterpret_cast< wxWindow * >(argp1);
35645 {
35646 PyThreadState* __tstate = wxPyBeginAllowThreads();
35647 result = (bool)((wxWindow const *)arg1)->IsShown();
35648 wxPyEndAllowThreads(__tstate);
35649 if (PyErr_Occurred()) SWIG_fail;
35650 }
35651 {
35652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35653 }
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35661 PyObject *resultobj = 0;
35662 wxWindow *arg1 = (wxWindow *) 0 ;
35663 bool result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35673 }
35674 arg1 = reinterpret_cast< wxWindow * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35691 PyObject *resultobj = 0;
35692 wxWindow *arg1 = (wxWindow *) 0 ;
35693 bool result;
35694 void *argp1 = 0 ;
35695 int res1 = 0 ;
35696 PyObject *swig_obj[1] ;
35697
35698 if (!args) SWIG_fail;
35699 swig_obj[0] = args;
35700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 {
35706 PyThreadState* __tstate = wxPyBeginAllowThreads();
35707 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35708 wxPyEndAllowThreads(__tstate);
35709 if (PyErr_Occurred()) SWIG_fail;
35710 }
35711 {
35712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35713 }
35714 return resultobj;
35715 fail:
35716 return NULL;
35717 }
35718
35719
35720 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35721 PyObject *resultobj = 0;
35722 wxWindow *arg1 = (wxWindow *) 0 ;
35723 long arg2 ;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 long val2 ;
35727 int ecode2 = 0 ;
35728 PyObject * obj0 = 0 ;
35729 PyObject * obj1 = 0 ;
35730 char * kwnames[] = {
35731 (char *) "self",(char *) "style", NULL
35732 };
35733
35734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35736 if (!SWIG_IsOK(res1)) {
35737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35738 }
35739 arg1 = reinterpret_cast< wxWindow * >(argp1);
35740 ecode2 = SWIG_AsVal_long(obj1, &val2);
35741 if (!SWIG_IsOK(ecode2)) {
35742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35743 }
35744 arg2 = static_cast< long >(val2);
35745 {
35746 PyThreadState* __tstate = wxPyBeginAllowThreads();
35747 (arg1)->SetWindowStyleFlag(arg2);
35748 wxPyEndAllowThreads(__tstate);
35749 if (PyErr_Occurred()) SWIG_fail;
35750 }
35751 resultobj = SWIG_Py_Void();
35752 return resultobj;
35753 fail:
35754 return NULL;
35755 }
35756
35757
35758 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35759 PyObject *resultobj = 0;
35760 wxWindow *arg1 = (wxWindow *) 0 ;
35761 long result;
35762 void *argp1 = 0 ;
35763 int res1 = 0 ;
35764 PyObject *swig_obj[1] ;
35765
35766 if (!args) SWIG_fail;
35767 swig_obj[0] = args;
35768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 resultobj = SWIG_From_long(static_cast< long >(result));
35780 return resultobj;
35781 fail:
35782 return NULL;
35783 }
35784
35785
35786 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35787 PyObject *resultobj = 0;
35788 wxWindow *arg1 = (wxWindow *) 0 ;
35789 int arg2 ;
35790 bool result;
35791 void *argp1 = 0 ;
35792 int res1 = 0 ;
35793 int val2 ;
35794 int ecode2 = 0 ;
35795 PyObject * obj0 = 0 ;
35796 PyObject * obj1 = 0 ;
35797 char * kwnames[] = {
35798 (char *) "self",(char *) "flag", NULL
35799 };
35800
35801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35803 if (!SWIG_IsOK(res1)) {
35804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35805 }
35806 arg1 = reinterpret_cast< wxWindow * >(argp1);
35807 ecode2 = SWIG_AsVal_int(obj1, &val2);
35808 if (!SWIG_IsOK(ecode2)) {
35809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35810 }
35811 arg2 = static_cast< int >(val2);
35812 {
35813 PyThreadState* __tstate = wxPyBeginAllowThreads();
35814 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 {
35819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35820 }
35821 return resultobj;
35822 fail:
35823 return NULL;
35824 }
35825
35826
35827 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35828 PyObject *resultobj = 0;
35829 wxWindow *arg1 = (wxWindow *) 0 ;
35830 bool result;
35831 void *argp1 = 0 ;
35832 int res1 = 0 ;
35833 PyObject *swig_obj[1] ;
35834
35835 if (!args) SWIG_fail;
35836 swig_obj[0] = args;
35837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35838 if (!SWIG_IsOK(res1)) {
35839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35840 }
35841 arg1 = reinterpret_cast< wxWindow * >(argp1);
35842 {
35843 PyThreadState* __tstate = wxPyBeginAllowThreads();
35844 result = (bool)((wxWindow const *)arg1)->IsRetained();
35845 wxPyEndAllowThreads(__tstate);
35846 if (PyErr_Occurred()) SWIG_fail;
35847 }
35848 {
35849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35850 }
35851 return resultobj;
35852 fail:
35853 return NULL;
35854 }
35855
35856
35857 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35858 PyObject *resultobj = 0;
35859 wxWindow *arg1 = (wxWindow *) 0 ;
35860 long arg2 ;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 long val2 ;
35864 int ecode2 = 0 ;
35865 PyObject * obj0 = 0 ;
35866 PyObject * obj1 = 0 ;
35867 char * kwnames[] = {
35868 (char *) "self",(char *) "exStyle", NULL
35869 };
35870
35871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35873 if (!SWIG_IsOK(res1)) {
35874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35875 }
35876 arg1 = reinterpret_cast< wxWindow * >(argp1);
35877 ecode2 = SWIG_AsVal_long(obj1, &val2);
35878 if (!SWIG_IsOK(ecode2)) {
35879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35880 }
35881 arg2 = static_cast< long >(val2);
35882 {
35883 PyThreadState* __tstate = wxPyBeginAllowThreads();
35884 (arg1)->SetExtraStyle(arg2);
35885 wxPyEndAllowThreads(__tstate);
35886 if (PyErr_Occurred()) SWIG_fail;
35887 }
35888 resultobj = SWIG_Py_Void();
35889 return resultobj;
35890 fail:
35891 return NULL;
35892 }
35893
35894
35895 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35896 PyObject *resultobj = 0;
35897 wxWindow *arg1 = (wxWindow *) 0 ;
35898 long result;
35899 void *argp1 = 0 ;
35900 int res1 = 0 ;
35901 PyObject *swig_obj[1] ;
35902
35903 if (!args) SWIG_fail;
35904 swig_obj[0] = args;
35905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35906 if (!SWIG_IsOK(res1)) {
35907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35908 }
35909 arg1 = reinterpret_cast< wxWindow * >(argp1);
35910 {
35911 PyThreadState* __tstate = wxPyBeginAllowThreads();
35912 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 resultobj = SWIG_From_long(static_cast< long >(result));
35917 return resultobj;
35918 fail:
35919 return NULL;
35920 }
35921
35922
35923 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35924 PyObject *resultobj = 0;
35925 wxWindow *arg1 = (wxWindow *) 0 ;
35926 bool arg2 = (bool) true ;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 bool val2 ;
35930 int ecode2 = 0 ;
35931 PyObject * obj0 = 0 ;
35932 PyObject * obj1 = 0 ;
35933 char * kwnames[] = {
35934 (char *) "self",(char *) "modal", NULL
35935 };
35936
35937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35939 if (!SWIG_IsOK(res1)) {
35940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35941 }
35942 arg1 = reinterpret_cast< wxWindow * >(argp1);
35943 if (obj1) {
35944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35945 if (!SWIG_IsOK(ecode2)) {
35946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35947 }
35948 arg2 = static_cast< bool >(val2);
35949 }
35950 {
35951 PyThreadState* __tstate = wxPyBeginAllowThreads();
35952 (arg1)->MakeModal(arg2);
35953 wxPyEndAllowThreads(__tstate);
35954 if (PyErr_Occurred()) SWIG_fail;
35955 }
35956 resultobj = SWIG_Py_Void();
35957 return resultobj;
35958 fail:
35959 return NULL;
35960 }
35961
35962
35963 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35964 PyObject *resultobj = 0;
35965 wxWindow *arg1 = (wxWindow *) 0 ;
35966 bool arg2 ;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 bool val2 ;
35970 int ecode2 = 0 ;
35971 PyObject * obj0 = 0 ;
35972 PyObject * obj1 = 0 ;
35973 char * kwnames[] = {
35974 (char *) "self",(char *) "enableTheme", NULL
35975 };
35976
35977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35979 if (!SWIG_IsOK(res1)) {
35980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35981 }
35982 arg1 = reinterpret_cast< wxWindow * >(argp1);
35983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35984 if (!SWIG_IsOK(ecode2)) {
35985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35986 }
35987 arg2 = static_cast< bool >(val2);
35988 {
35989 PyThreadState* __tstate = wxPyBeginAllowThreads();
35990 (arg1)->SetThemeEnabled(arg2);
35991 wxPyEndAllowThreads(__tstate);
35992 if (PyErr_Occurred()) SWIG_fail;
35993 }
35994 resultobj = SWIG_Py_Void();
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36002 PyObject *resultobj = 0;
36003 wxWindow *arg1 = (wxWindow *) 0 ;
36004 bool result;
36005 void *argp1 = 0 ;
36006 int res1 = 0 ;
36007 PyObject *swig_obj[1] ;
36008
36009 if (!args) SWIG_fail;
36010 swig_obj[0] = args;
36011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36014 }
36015 arg1 = reinterpret_cast< wxWindow * >(argp1);
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 {
36023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36024 }
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 void *argp1 = 0 ;
36035 int res1 = 0 ;
36036 PyObject *swig_obj[1] ;
36037
36038 if (!args) SWIG_fail;
36039 swig_obj[0] = args;
36040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36041 if (!SWIG_IsOK(res1)) {
36042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36043 }
36044 arg1 = reinterpret_cast< wxWindow * >(argp1);
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 (arg1)->SetFocus();
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 resultobj = SWIG_Py_Void();
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36059 PyObject *resultobj = 0;
36060 wxWindow *arg1 = (wxWindow *) 0 ;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 PyObject *swig_obj[1] ;
36064
36065 if (!args) SWIG_fail;
36066 swig_obj[0] = args;
36067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36070 }
36071 arg1 = reinterpret_cast< wxWindow * >(argp1);
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 (arg1)->SetFocusFromKbd();
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 resultobj = SWIG_Py_Void();
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36086 PyObject *resultobj = 0;
36087 wxWindow *result = 0 ;
36088
36089 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36090 {
36091 if (!wxPyCheckForApp()) SWIG_fail;
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 result = (wxWindow *)wxWindow::FindFocus();
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 {
36098 resultobj = wxPyMake_wxObject(result, 0);
36099 }
36100 return resultobj;
36101 fail:
36102 return NULL;
36103 }
36104
36105
36106 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36107 PyObject *resultobj = 0;
36108 wxWindow *arg1 = (wxWindow *) 0 ;
36109 bool result;
36110 void *argp1 = 0 ;
36111 int res1 = 0 ;
36112 PyObject *swig_obj[1] ;
36113
36114 if (!args) SWIG_fail;
36115 swig_obj[0] = args;
36116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36117 if (!SWIG_IsOK(res1)) {
36118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36119 }
36120 arg1 = reinterpret_cast< wxWindow * >(argp1);
36121 {
36122 PyThreadState* __tstate = wxPyBeginAllowThreads();
36123 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36124 wxPyEndAllowThreads(__tstate);
36125 if (PyErr_Occurred()) SWIG_fail;
36126 }
36127 {
36128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36129 }
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxWindow *arg1 = (wxWindow *) 0 ;
36139 bool result;
36140 void *argp1 = 0 ;
36141 int res1 = 0 ;
36142 PyObject *swig_obj[1] ;
36143
36144 if (!args) SWIG_fail;
36145 swig_obj[0] = args;
36146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxWindow * >(argp1);
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 {
36158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36159 }
36160 return resultobj;
36161 fail:
36162 return NULL;
36163 }
36164
36165
36166 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36167 PyObject *resultobj = 0;
36168 wxWindow *arg1 = (wxWindow *) 0 ;
36169 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36170 bool result;
36171 void *argp1 = 0 ;
36172 int res1 = 0 ;
36173 int val2 ;
36174 int ecode2 = 0 ;
36175 PyObject * obj0 = 0 ;
36176 PyObject * obj1 = 0 ;
36177 char * kwnames[] = {
36178 (char *) "self",(char *) "flags", NULL
36179 };
36180
36181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36183 if (!SWIG_IsOK(res1)) {
36184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36185 }
36186 arg1 = reinterpret_cast< wxWindow * >(argp1);
36187 if (obj1) {
36188 ecode2 = SWIG_AsVal_int(obj1, &val2);
36189 if (!SWIG_IsOK(ecode2)) {
36190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36191 }
36192 arg2 = static_cast< int >(val2);
36193 }
36194 {
36195 PyThreadState* __tstate = wxPyBeginAllowThreads();
36196 result = (bool)(arg1)->Navigate(arg2);
36197 wxPyEndAllowThreads(__tstate);
36198 if (PyErr_Occurred()) SWIG_fail;
36199 }
36200 {
36201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36202 }
36203 return resultobj;
36204 fail:
36205 return NULL;
36206 }
36207
36208
36209 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36210 PyObject *resultobj = 0;
36211 wxWindow *arg1 = (wxWindow *) 0 ;
36212 wxWindow *arg2 = (wxWindow *) 0 ;
36213 void *argp1 = 0 ;
36214 int res1 = 0 ;
36215 void *argp2 = 0 ;
36216 int res2 = 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "win", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36230 if (!SWIG_IsOK(res2)) {
36231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36232 }
36233 arg2 = reinterpret_cast< wxWindow * >(argp2);
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 (arg1)->MoveAfterInTabOrder(arg2);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_Py_Void();
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 wxWindow *arg2 = (wxWindow *) 0 ;
36251 void *argp1 = 0 ;
36252 int res1 = 0 ;
36253 void *argp2 = 0 ;
36254 int res2 = 0 ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 char * kwnames[] = {
36258 (char *) "self",(char *) "win", NULL
36259 };
36260
36261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36265 }
36266 arg1 = reinterpret_cast< wxWindow * >(argp1);
36267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36268 if (!SWIG_IsOK(res2)) {
36269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36270 }
36271 arg2 = reinterpret_cast< wxWindow * >(argp2);
36272 {
36273 PyThreadState* __tstate = wxPyBeginAllowThreads();
36274 (arg1)->MoveBeforeInTabOrder(arg2);
36275 wxPyEndAllowThreads(__tstate);
36276 if (PyErr_Occurred()) SWIG_fail;
36277 }
36278 resultobj = SWIG_Py_Void();
36279 return resultobj;
36280 fail:
36281 return NULL;
36282 }
36283
36284
36285 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36286 PyObject *resultobj = 0;
36287 wxWindow *arg1 = (wxWindow *) 0 ;
36288 PyObject *result = 0 ;
36289 void *argp1 = 0 ;
36290 int res1 = 0 ;
36291 PyObject *swig_obj[1] ;
36292
36293 if (!args) SWIG_fail;
36294 swig_obj[0] = args;
36295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36296 if (!SWIG_IsOK(res1)) {
36297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36298 }
36299 arg1 = reinterpret_cast< wxWindow * >(argp1);
36300 {
36301 PyThreadState* __tstate = wxPyBeginAllowThreads();
36302 result = (PyObject *)wxWindow_GetChildren(arg1);
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 resultobj = result;
36307 return resultobj;
36308 fail:
36309 return NULL;
36310 }
36311
36312
36313 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36314 PyObject *resultobj = 0;
36315 wxWindow *arg1 = (wxWindow *) 0 ;
36316 wxWindow *result = 0 ;
36317 void *argp1 = 0 ;
36318 int res1 = 0 ;
36319 PyObject *swig_obj[1] ;
36320
36321 if (!args) SWIG_fail;
36322 swig_obj[0] = args;
36323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36324 if (!SWIG_IsOK(res1)) {
36325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36326 }
36327 arg1 = reinterpret_cast< wxWindow * >(argp1);
36328 {
36329 PyThreadState* __tstate = wxPyBeginAllowThreads();
36330 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36331 wxPyEndAllowThreads(__tstate);
36332 if (PyErr_Occurred()) SWIG_fail;
36333 }
36334 {
36335 resultobj = wxPyMake_wxObject(result, 0);
36336 }
36337 return resultobj;
36338 fail:
36339 return NULL;
36340 }
36341
36342
36343 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36344 PyObject *resultobj = 0;
36345 wxWindow *arg1 = (wxWindow *) 0 ;
36346 wxWindow *result = 0 ;
36347 void *argp1 = 0 ;
36348 int res1 = 0 ;
36349 PyObject *swig_obj[1] ;
36350
36351 if (!args) SWIG_fail;
36352 swig_obj[0] = args;
36353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36354 if (!SWIG_IsOK(res1)) {
36355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36356 }
36357 arg1 = reinterpret_cast< wxWindow * >(argp1);
36358 {
36359 PyThreadState* __tstate = wxPyBeginAllowThreads();
36360 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36361 wxPyEndAllowThreads(__tstate);
36362 if (PyErr_Occurred()) SWIG_fail;
36363 }
36364 {
36365 resultobj = wxPyMake_wxObject(result, 0);
36366 }
36367 return resultobj;
36368 fail:
36369 return NULL;
36370 }
36371
36372
36373 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36374 PyObject *resultobj = 0;
36375 wxWindow *arg1 = (wxWindow *) 0 ;
36376 bool result;
36377 void *argp1 = 0 ;
36378 int res1 = 0 ;
36379 PyObject *swig_obj[1] ;
36380
36381 if (!args) SWIG_fail;
36382 swig_obj[0] = args;
36383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36384 if (!SWIG_IsOK(res1)) {
36385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36386 }
36387 arg1 = reinterpret_cast< wxWindow * >(argp1);
36388 {
36389 PyThreadState* __tstate = wxPyBeginAllowThreads();
36390 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 {
36395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36396 }
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 wxWindow *arg2 = (wxWindow *) 0 ;
36407 bool result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 void *argp2 = 0 ;
36411 int res2 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "newParent", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res2)) {
36426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36427 }
36428 arg2 = reinterpret_cast< wxWindow * >(argp2);
36429 {
36430 PyThreadState* __tstate = wxPyBeginAllowThreads();
36431 result = (bool)(arg1)->Reparent(arg2);
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 {
36436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36437 }
36438 return resultobj;
36439 fail:
36440 return NULL;
36441 }
36442
36443
36444 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36445 PyObject *resultobj = 0;
36446 wxWindow *arg1 = (wxWindow *) 0 ;
36447 wxWindow *arg2 = (wxWindow *) 0 ;
36448 void *argp1 = 0 ;
36449 int res1 = 0 ;
36450 void *argp2 = 0 ;
36451 int res2 = 0 ;
36452 PyObject * obj0 = 0 ;
36453 PyObject * obj1 = 0 ;
36454 char * kwnames[] = {
36455 (char *) "self",(char *) "child", NULL
36456 };
36457
36458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36460 if (!SWIG_IsOK(res1)) {
36461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36462 }
36463 arg1 = reinterpret_cast< wxWindow * >(argp1);
36464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36465 if (!SWIG_IsOK(res2)) {
36466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36467 }
36468 arg2 = reinterpret_cast< wxWindow * >(argp2);
36469 {
36470 PyThreadState* __tstate = wxPyBeginAllowThreads();
36471 (arg1)->AddChild(arg2);
36472 wxPyEndAllowThreads(__tstate);
36473 if (PyErr_Occurred()) SWIG_fail;
36474 }
36475 resultobj = SWIG_Py_Void();
36476 return resultobj;
36477 fail:
36478 return NULL;
36479 }
36480
36481
36482 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj = 0;
36484 wxWindow *arg1 = (wxWindow *) 0 ;
36485 wxWindow *arg2 = (wxWindow *) 0 ;
36486 void *argp1 = 0 ;
36487 int res1 = 0 ;
36488 void *argp2 = 0 ;
36489 int res2 = 0 ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 char * kwnames[] = {
36493 (char *) "self",(char *) "child", NULL
36494 };
36495
36496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res1)) {
36499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36503 if (!SWIG_IsOK(res2)) {
36504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36505 }
36506 arg2 = reinterpret_cast< wxWindow * >(argp2);
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 (arg1)->RemoveChild(arg2);
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = SWIG_Py_Void();
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj = 0;
36522 wxWindow *arg1 = (wxWindow *) 0 ;
36523 bool arg2 ;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 bool val2 ;
36527 int ecode2 = 0 ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "on", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",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_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36541 if (!SWIG_IsOK(ecode2)) {
36542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36543 }
36544 arg2 = static_cast< bool >(val2);
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 wxWindow_SetDoubleBuffered(arg1,arg2);
36548 wxPyEndAllowThreads(__tstate);
36549 if (PyErr_Occurred()) SWIG_fail;
36550 }
36551 resultobj = SWIG_Py_Void();
36552 return resultobj;
36553 fail:
36554 return NULL;
36555 }
36556
36557
36558 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36559 PyObject *resultobj = 0;
36560 wxWindow *arg1 = (wxWindow *) 0 ;
36561 long arg2 ;
36562 wxWindow *result = 0 ;
36563 void *argp1 = 0 ;
36564 int res1 = 0 ;
36565 long val2 ;
36566 int ecode2 = 0 ;
36567 PyObject * obj0 = 0 ;
36568 PyObject * obj1 = 0 ;
36569 char * kwnames[] = {
36570 (char *) "self",(char *) "winid", NULL
36571 };
36572
36573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 ecode2 = SWIG_AsVal_long(obj1, &val2);
36580 if (!SWIG_IsOK(ecode2)) {
36581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36582 }
36583 arg2 = static_cast< long >(val2);
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 result = (wxWindow *)(arg1)->FindWindow(arg2);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 {
36591 resultobj = wxPyMake_wxObject(result, 0);
36592 }
36593 return resultobj;
36594 fail:
36595 return NULL;
36596 }
36597
36598
36599 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36600 PyObject *resultobj = 0;
36601 wxWindow *arg1 = (wxWindow *) 0 ;
36602 wxString *arg2 = 0 ;
36603 wxWindow *result = 0 ;
36604 void *argp1 = 0 ;
36605 int res1 = 0 ;
36606 bool temp2 = false ;
36607 PyObject * obj0 = 0 ;
36608 PyObject * obj1 = 0 ;
36609 char * kwnames[] = {
36610 (char *) "self",(char *) "name", NULL
36611 };
36612
36613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36615 if (!SWIG_IsOK(res1)) {
36616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36617 }
36618 arg1 = reinterpret_cast< wxWindow * >(argp1);
36619 {
36620 arg2 = wxString_in_helper(obj1);
36621 if (arg2 == NULL) SWIG_fail;
36622 temp2 = true;
36623 }
36624 {
36625 PyThreadState* __tstate = wxPyBeginAllowThreads();
36626 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36627 wxPyEndAllowThreads(__tstate);
36628 if (PyErr_Occurred()) SWIG_fail;
36629 }
36630 {
36631 resultobj = wxPyMake_wxObject(result, 0);
36632 }
36633 {
36634 if (temp2)
36635 delete arg2;
36636 }
36637 return resultobj;
36638 fail:
36639 {
36640 if (temp2)
36641 delete arg2;
36642 }
36643 return NULL;
36644 }
36645
36646
36647 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36648 PyObject *resultobj = 0;
36649 wxWindow *arg1 = (wxWindow *) 0 ;
36650 wxEvtHandler *result = 0 ;
36651 void *argp1 = 0 ;
36652 int res1 = 0 ;
36653 PyObject *swig_obj[1] ;
36654
36655 if (!args) SWIG_fail;
36656 swig_obj[0] = args;
36657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36658 if (!SWIG_IsOK(res1)) {
36659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36660 }
36661 arg1 = reinterpret_cast< wxWindow * >(argp1);
36662 {
36663 PyThreadState* __tstate = wxPyBeginAllowThreads();
36664 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36665 wxPyEndAllowThreads(__tstate);
36666 if (PyErr_Occurred()) SWIG_fail;
36667 }
36668 {
36669 resultobj = wxPyMake_wxObject(result, 0);
36670 }
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36678 PyObject *resultobj = 0;
36679 wxWindow *arg1 = (wxWindow *) 0 ;
36680 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36681 void *argp1 = 0 ;
36682 int res1 = 0 ;
36683 void *argp2 = 0 ;
36684 int res2 = 0 ;
36685 PyObject * obj0 = 0 ;
36686 PyObject * obj1 = 0 ;
36687 char * kwnames[] = {
36688 (char *) "self",(char *) "handler", NULL
36689 };
36690
36691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36698 if (!SWIG_IsOK(res2)) {
36699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36700 }
36701 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 (arg1)->SetEventHandler(arg2);
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_Py_Void();
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj = 0;
36717 wxWindow *arg1 = (wxWindow *) 0 ;
36718 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 void *argp2 = 0 ;
36722 int res2 = 0 ;
36723 PyObject * obj0 = 0 ;
36724 PyObject * obj1 = 0 ;
36725 char * kwnames[] = {
36726 (char *) "self",(char *) "handler", NULL
36727 };
36728
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36736 if (!SWIG_IsOK(res2)) {
36737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36738 }
36739 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 (arg1)->PushEventHandler(arg2);
36743 wxPyEndAllowThreads(__tstate);
36744 if (PyErr_Occurred()) SWIG_fail;
36745 }
36746 resultobj = SWIG_Py_Void();
36747 return resultobj;
36748 fail:
36749 return NULL;
36750 }
36751
36752
36753 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36754 PyObject *resultobj = 0;
36755 wxWindow *arg1 = (wxWindow *) 0 ;
36756 bool arg2 = (bool) false ;
36757 wxEvtHandler *result = 0 ;
36758 void *argp1 = 0 ;
36759 int res1 = 0 ;
36760 bool val2 ;
36761 int ecode2 = 0 ;
36762 PyObject * obj0 = 0 ;
36763 PyObject * obj1 = 0 ;
36764 char * kwnames[] = {
36765 (char *) "self",(char *) "deleteHandler", NULL
36766 };
36767
36768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36770 if (!SWIG_IsOK(res1)) {
36771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36772 }
36773 arg1 = reinterpret_cast< wxWindow * >(argp1);
36774 if (obj1) {
36775 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36776 if (!SWIG_IsOK(ecode2)) {
36777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36778 }
36779 arg2 = static_cast< bool >(val2);
36780 }
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 resultobj = wxPyMake_wxObject(result, 0);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj = 0;
36798 wxWindow *arg1 = (wxWindow *) 0 ;
36799 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36800 bool result;
36801 void *argp1 = 0 ;
36802 int res1 = 0 ;
36803 void *argp2 = 0 ;
36804 int res2 = 0 ;
36805 PyObject * obj0 = 0 ;
36806 PyObject * obj1 = 0 ;
36807 char * kwnames[] = {
36808 (char *) "self",(char *) "handler", NULL
36809 };
36810
36811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36813 if (!SWIG_IsOK(res1)) {
36814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36815 }
36816 arg1 = reinterpret_cast< wxWindow * >(argp1);
36817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36818 if (!SWIG_IsOK(res2)) {
36819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36820 }
36821 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36822 {
36823 PyThreadState* __tstate = wxPyBeginAllowThreads();
36824 result = (bool)(arg1)->RemoveEventHandler(arg2);
36825 wxPyEndAllowThreads(__tstate);
36826 if (PyErr_Occurred()) SWIG_fail;
36827 }
36828 {
36829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36830 }
36831 return resultobj;
36832 fail:
36833 return NULL;
36834 }
36835
36836
36837 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36838 PyObject *resultobj = 0;
36839 wxWindow *arg1 = (wxWindow *) 0 ;
36840 wxValidator *arg2 = 0 ;
36841 void *argp1 = 0 ;
36842 int res1 = 0 ;
36843 void *argp2 = 0 ;
36844 int res2 = 0 ;
36845 PyObject * obj0 = 0 ;
36846 PyObject * obj1 = 0 ;
36847 char * kwnames[] = {
36848 (char *) "self",(char *) "validator", NULL
36849 };
36850
36851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36853 if (!SWIG_IsOK(res1)) {
36854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36855 }
36856 arg1 = reinterpret_cast< wxWindow * >(argp1);
36857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36858 if (!SWIG_IsOK(res2)) {
36859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36860 }
36861 if (!argp2) {
36862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36863 }
36864 arg2 = reinterpret_cast< wxValidator * >(argp2);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 (arg1)->SetValidator((wxValidator const &)*arg2);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36879 PyObject *resultobj = 0;
36880 wxWindow *arg1 = (wxWindow *) 0 ;
36881 wxValidator *result = 0 ;
36882 void *argp1 = 0 ;
36883 int res1 = 0 ;
36884 PyObject *swig_obj[1] ;
36885
36886 if (!args) SWIG_fail;
36887 swig_obj[0] = args;
36888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36889 if (!SWIG_IsOK(res1)) {
36890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36891 }
36892 arg1 = reinterpret_cast< wxWindow * >(argp1);
36893 {
36894 PyThreadState* __tstate = wxPyBeginAllowThreads();
36895 result = (wxValidator *)(arg1)->GetValidator();
36896 wxPyEndAllowThreads(__tstate);
36897 if (PyErr_Occurred()) SWIG_fail;
36898 }
36899 {
36900 resultobj = wxPyMake_wxObject(result, (bool)0);
36901 }
36902 return resultobj;
36903 fail:
36904 return NULL;
36905 }
36906
36907
36908 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36909 PyObject *resultobj = 0;
36910 wxWindow *arg1 = (wxWindow *) 0 ;
36911 bool result;
36912 void *argp1 = 0 ;
36913 int res1 = 0 ;
36914 PyObject *swig_obj[1] ;
36915
36916 if (!args) SWIG_fail;
36917 swig_obj[0] = args;
36918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36919 if (!SWIG_IsOK(res1)) {
36920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36921 }
36922 arg1 = reinterpret_cast< wxWindow * >(argp1);
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 result = (bool)(arg1)->Validate();
36926 wxPyEndAllowThreads(__tstate);
36927 if (PyErr_Occurred()) SWIG_fail;
36928 }
36929 {
36930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36931 }
36932 return resultobj;
36933 fail:
36934 return NULL;
36935 }
36936
36937
36938 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36939 PyObject *resultobj = 0;
36940 wxWindow *arg1 = (wxWindow *) 0 ;
36941 bool result;
36942 void *argp1 = 0 ;
36943 int res1 = 0 ;
36944 PyObject *swig_obj[1] ;
36945
36946 if (!args) SWIG_fail;
36947 swig_obj[0] = args;
36948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36949 if (!SWIG_IsOK(res1)) {
36950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36951 }
36952 arg1 = reinterpret_cast< wxWindow * >(argp1);
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 result = (bool)(arg1)->TransferDataToWindow();
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36961 }
36962 return resultobj;
36963 fail:
36964 return NULL;
36965 }
36966
36967
36968 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36969 PyObject *resultobj = 0;
36970 wxWindow *arg1 = (wxWindow *) 0 ;
36971 bool result;
36972 void *argp1 = 0 ;
36973 int res1 = 0 ;
36974 PyObject *swig_obj[1] ;
36975
36976 if (!args) SWIG_fail;
36977 swig_obj[0] = args;
36978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36979 if (!SWIG_IsOK(res1)) {
36980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36981 }
36982 arg1 = reinterpret_cast< wxWindow * >(argp1);
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 result = (bool)(arg1)->TransferDataFromWindow();
36986 wxPyEndAllowThreads(__tstate);
36987 if (PyErr_Occurred()) SWIG_fail;
36988 }
36989 {
36990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36991 }
36992 return resultobj;
36993 fail:
36994 return NULL;
36995 }
36996
36997
36998 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36999 PyObject *resultobj = 0;
37000 wxWindow *arg1 = (wxWindow *) 0 ;
37001 void *argp1 = 0 ;
37002 int res1 = 0 ;
37003 PyObject *swig_obj[1] ;
37004
37005 if (!args) SWIG_fail;
37006 swig_obj[0] = args;
37007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37008 if (!SWIG_IsOK(res1)) {
37009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37010 }
37011 arg1 = reinterpret_cast< wxWindow * >(argp1);
37012 {
37013 PyThreadState* __tstate = wxPyBeginAllowThreads();
37014 (arg1)->InitDialog();
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 resultobj = SWIG_Py_Void();
37019 return resultobj;
37020 fail:
37021 return NULL;
37022 }
37023
37024
37025 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37026 PyObject *resultobj = 0;
37027 wxWindow *arg1 = (wxWindow *) 0 ;
37028 wxAcceleratorTable *arg2 = 0 ;
37029 void *argp1 = 0 ;
37030 int res1 = 0 ;
37031 void *argp2 = 0 ;
37032 int res2 = 0 ;
37033 PyObject * obj0 = 0 ;
37034 PyObject * obj1 = 0 ;
37035 char * kwnames[] = {
37036 (char *) "self",(char *) "accel", NULL
37037 };
37038
37039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37041 if (!SWIG_IsOK(res1)) {
37042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37043 }
37044 arg1 = reinterpret_cast< wxWindow * >(argp1);
37045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37046 if (!SWIG_IsOK(res2)) {
37047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37048 }
37049 if (!argp2) {
37050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37051 }
37052 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37053 {
37054 PyThreadState* __tstate = wxPyBeginAllowThreads();
37055 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37056 wxPyEndAllowThreads(__tstate);
37057 if (PyErr_Occurred()) SWIG_fail;
37058 }
37059 resultobj = SWIG_Py_Void();
37060 return resultobj;
37061 fail:
37062 return NULL;
37063 }
37064
37065
37066 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37067 PyObject *resultobj = 0;
37068 wxWindow *arg1 = (wxWindow *) 0 ;
37069 wxAcceleratorTable *result = 0 ;
37070 void *argp1 = 0 ;
37071 int res1 = 0 ;
37072 PyObject *swig_obj[1] ;
37073
37074 if (!args) SWIG_fail;
37075 swig_obj[0] = args;
37076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37077 if (!SWIG_IsOK(res1)) {
37078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37079 }
37080 arg1 = reinterpret_cast< wxWindow * >(argp1);
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37084 wxPyEndAllowThreads(__tstate);
37085 if (PyErr_Occurred()) SWIG_fail;
37086 }
37087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj = 0;
37096 wxWindow *arg1 = (wxWindow *) 0 ;
37097 int arg2 ;
37098 int arg3 ;
37099 int arg4 ;
37100 bool result;
37101 void *argp1 = 0 ;
37102 int res1 = 0 ;
37103 int val2 ;
37104 int ecode2 = 0 ;
37105 int val3 ;
37106 int ecode3 = 0 ;
37107 int val4 ;
37108 int ecode4 = 0 ;
37109 PyObject * obj0 = 0 ;
37110 PyObject * obj1 = 0 ;
37111 PyObject * obj2 = 0 ;
37112 PyObject * obj3 = 0 ;
37113 char * kwnames[] = {
37114 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37115 };
37116
37117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37119 if (!SWIG_IsOK(res1)) {
37120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37121 }
37122 arg1 = reinterpret_cast< wxWindow * >(argp1);
37123 ecode2 = SWIG_AsVal_int(obj1, &val2);
37124 if (!SWIG_IsOK(ecode2)) {
37125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37126 }
37127 arg2 = static_cast< int >(val2);
37128 ecode3 = SWIG_AsVal_int(obj2, &val3);
37129 if (!SWIG_IsOK(ecode3)) {
37130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37131 }
37132 arg3 = static_cast< int >(val3);
37133 ecode4 = SWIG_AsVal_int(obj3, &val4);
37134 if (!SWIG_IsOK(ecode4)) {
37135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37136 }
37137 arg4 = static_cast< int >(val4);
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 {
37145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37146 }
37147 return resultobj;
37148 fail:
37149 return NULL;
37150 }
37151
37152
37153 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37154 PyObject *resultobj = 0;
37155 wxWindow *arg1 = (wxWindow *) 0 ;
37156 int arg2 ;
37157 bool result;
37158 void *argp1 = 0 ;
37159 int res1 = 0 ;
37160 int val2 ;
37161 int ecode2 = 0 ;
37162 PyObject * obj0 = 0 ;
37163 PyObject * obj1 = 0 ;
37164 char * kwnames[] = {
37165 (char *) "self",(char *) "hotkeyId", NULL
37166 };
37167
37168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37170 if (!SWIG_IsOK(res1)) {
37171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37172 }
37173 arg1 = reinterpret_cast< wxWindow * >(argp1);
37174 ecode2 = SWIG_AsVal_int(obj1, &val2);
37175 if (!SWIG_IsOK(ecode2)) {
37176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37177 }
37178 arg2 = static_cast< int >(val2);
37179 {
37180 PyThreadState* __tstate = wxPyBeginAllowThreads();
37181 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37182 wxPyEndAllowThreads(__tstate);
37183 if (PyErr_Occurred()) SWIG_fail;
37184 }
37185 {
37186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37187 }
37188 return resultobj;
37189 fail:
37190 return NULL;
37191 }
37192
37193
37194 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37195 PyObject *resultobj = 0;
37196 wxWindow *arg1 = (wxWindow *) 0 ;
37197 wxPoint *arg2 = 0 ;
37198 wxPoint result;
37199 void *argp1 = 0 ;
37200 int res1 = 0 ;
37201 wxPoint temp2 ;
37202 PyObject * obj0 = 0 ;
37203 PyObject * obj1 = 0 ;
37204 char * kwnames[] = {
37205 (char *) "self",(char *) "pt", NULL
37206 };
37207
37208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37210 if (!SWIG_IsOK(res1)) {
37211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37212 }
37213 arg1 = reinterpret_cast< wxWindow * >(argp1);
37214 {
37215 arg2 = &temp2;
37216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37217 }
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37232 PyObject *resultobj = 0;
37233 wxWindow *arg1 = (wxWindow *) 0 ;
37234 wxSize *arg2 = 0 ;
37235 wxSize result;
37236 void *argp1 = 0 ;
37237 int res1 = 0 ;
37238 wxSize temp2 ;
37239 PyObject * obj0 = 0 ;
37240 PyObject * obj1 = 0 ;
37241 char * kwnames[] = {
37242 (char *) "self",(char *) "sz", NULL
37243 };
37244
37245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37247 if (!SWIG_IsOK(res1)) {
37248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37249 }
37250 arg1 = reinterpret_cast< wxWindow * >(argp1);
37251 {
37252 arg2 = &temp2;
37253 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37254 }
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37262 return resultobj;
37263 fail:
37264 return NULL;
37265 }
37266
37267
37268 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37269 PyObject *resultobj = 0;
37270 wxWindow *arg1 = (wxWindow *) 0 ;
37271 wxPoint *arg2 = 0 ;
37272 wxPoint result;
37273 void *argp1 = 0 ;
37274 int res1 = 0 ;
37275 wxPoint temp2 ;
37276 PyObject * obj0 = 0 ;
37277 PyObject * obj1 = 0 ;
37278 char * kwnames[] = {
37279 (char *) "self",(char *) "pt", NULL
37280 };
37281
37282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37284 if (!SWIG_IsOK(res1)) {
37285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37286 }
37287 arg1 = reinterpret_cast< wxWindow * >(argp1);
37288 {
37289 arg2 = &temp2;
37290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37291 }
37292 {
37293 PyThreadState* __tstate = wxPyBeginAllowThreads();
37294 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37295 wxPyEndAllowThreads(__tstate);
37296 if (PyErr_Occurred()) SWIG_fail;
37297 }
37298 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37299 return resultobj;
37300 fail:
37301 return NULL;
37302 }
37303
37304
37305 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37306 PyObject *resultobj = 0;
37307 wxWindow *arg1 = (wxWindow *) 0 ;
37308 wxSize *arg2 = 0 ;
37309 wxSize result;
37310 void *argp1 = 0 ;
37311 int res1 = 0 ;
37312 wxSize temp2 ;
37313 PyObject * obj0 = 0 ;
37314 PyObject * obj1 = 0 ;
37315 char * kwnames[] = {
37316 (char *) "self",(char *) "sz", NULL
37317 };
37318
37319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37321 if (!SWIG_IsOK(res1)) {
37322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37323 }
37324 arg1 = reinterpret_cast< wxWindow * >(argp1);
37325 {
37326 arg2 = &temp2;
37327 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37328 }
37329 {
37330 PyThreadState* __tstate = wxPyBeginAllowThreads();
37331 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37332 wxPyEndAllowThreads(__tstate);
37333 if (PyErr_Occurred()) SWIG_fail;
37334 }
37335 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37336 return resultobj;
37337 fail:
37338 return NULL;
37339 }
37340
37341
37342 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37343 PyObject *resultobj = 0;
37344 wxWindow *arg1 = (wxWindow *) 0 ;
37345 wxPoint *arg2 = 0 ;
37346 wxPoint result;
37347 void *argp1 = 0 ;
37348 int res1 = 0 ;
37349 wxPoint temp2 ;
37350 PyObject * obj0 = 0 ;
37351 PyObject * obj1 = 0 ;
37352 char * kwnames[] = {
37353 (char *) "self",(char *) "pt", NULL
37354 };
37355
37356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37358 if (!SWIG_IsOK(res1)) {
37359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37360 }
37361 arg1 = reinterpret_cast< wxWindow * >(argp1);
37362 {
37363 arg2 = &temp2;
37364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37365 }
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37369 wxPyEndAllowThreads(__tstate);
37370 if (PyErr_Occurred()) SWIG_fail;
37371 }
37372 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37373 return resultobj;
37374 fail:
37375 return NULL;
37376 }
37377
37378
37379 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37380 PyObject *resultobj = 0;
37381 wxWindow *arg1 = (wxWindow *) 0 ;
37382 wxSize *arg2 = 0 ;
37383 wxSize result;
37384 void *argp1 = 0 ;
37385 int res1 = 0 ;
37386 wxSize temp2 ;
37387 PyObject * obj0 = 0 ;
37388 PyObject * obj1 = 0 ;
37389 char * kwnames[] = {
37390 (char *) "self",(char *) "sz", NULL
37391 };
37392
37393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37395 if (!SWIG_IsOK(res1)) {
37396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37397 }
37398 arg1 = reinterpret_cast< wxWindow * >(argp1);
37399 {
37400 arg2 = &temp2;
37401 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37402 }
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37410 return resultobj;
37411 fail:
37412 return NULL;
37413 }
37414
37415
37416 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37417 PyObject *resultobj = 0;
37418 wxWindow *arg1 = (wxWindow *) 0 ;
37419 int arg2 ;
37420 int arg3 ;
37421 void *argp1 = 0 ;
37422 int res1 = 0 ;
37423 int val2 ;
37424 int ecode2 = 0 ;
37425 int val3 ;
37426 int ecode3 = 0 ;
37427 PyObject * obj0 = 0 ;
37428 PyObject * obj1 = 0 ;
37429 PyObject * obj2 = 0 ;
37430 char * kwnames[] = {
37431 (char *) "self",(char *) "x",(char *) "y", NULL
37432 };
37433
37434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37436 if (!SWIG_IsOK(res1)) {
37437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37438 }
37439 arg1 = reinterpret_cast< wxWindow * >(argp1);
37440 ecode2 = SWIG_AsVal_int(obj1, &val2);
37441 if (!SWIG_IsOK(ecode2)) {
37442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37443 }
37444 arg2 = static_cast< int >(val2);
37445 ecode3 = SWIG_AsVal_int(obj2, &val3);
37446 if (!SWIG_IsOK(ecode3)) {
37447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37448 }
37449 arg3 = static_cast< int >(val3);
37450 {
37451 PyThreadState* __tstate = wxPyBeginAllowThreads();
37452 (arg1)->WarpPointer(arg2,arg3);
37453 wxPyEndAllowThreads(__tstate);
37454 if (PyErr_Occurred()) SWIG_fail;
37455 }
37456 resultobj = SWIG_Py_Void();
37457 return resultobj;
37458 fail:
37459 return NULL;
37460 }
37461
37462
37463 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37464 PyObject *resultobj = 0;
37465 wxWindow *arg1 = (wxWindow *) 0 ;
37466 void *argp1 = 0 ;
37467 int res1 = 0 ;
37468 PyObject *swig_obj[1] ;
37469
37470 if (!args) SWIG_fail;
37471 swig_obj[0] = args;
37472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37473 if (!SWIG_IsOK(res1)) {
37474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37475 }
37476 arg1 = reinterpret_cast< wxWindow * >(argp1);
37477 {
37478 PyThreadState* __tstate = wxPyBeginAllowThreads();
37479 (arg1)->CaptureMouse();
37480 wxPyEndAllowThreads(__tstate);
37481 if (PyErr_Occurred()) SWIG_fail;
37482 }
37483 resultobj = SWIG_Py_Void();
37484 return resultobj;
37485 fail:
37486 return NULL;
37487 }
37488
37489
37490 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37491 PyObject *resultobj = 0;
37492 wxWindow *arg1 = (wxWindow *) 0 ;
37493 void *argp1 = 0 ;
37494 int res1 = 0 ;
37495 PyObject *swig_obj[1] ;
37496
37497 if (!args) SWIG_fail;
37498 swig_obj[0] = args;
37499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37500 if (!SWIG_IsOK(res1)) {
37501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37502 }
37503 arg1 = reinterpret_cast< wxWindow * >(argp1);
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 (arg1)->ReleaseMouse();
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 resultobj = SWIG_Py_Void();
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37518 PyObject *resultobj = 0;
37519 wxWindow *result = 0 ;
37520
37521 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37522 {
37523 if (!wxPyCheckForApp()) SWIG_fail;
37524 PyThreadState* __tstate = wxPyBeginAllowThreads();
37525 result = (wxWindow *)wxWindow::GetCapture();
37526 wxPyEndAllowThreads(__tstate);
37527 if (PyErr_Occurred()) SWIG_fail;
37528 }
37529 {
37530 resultobj = wxPyMake_wxObject(result, 0);
37531 }
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37539 PyObject *resultobj = 0;
37540 wxWindow *arg1 = (wxWindow *) 0 ;
37541 bool result;
37542 void *argp1 = 0 ;
37543 int res1 = 0 ;
37544 PyObject *swig_obj[1] ;
37545
37546 if (!args) SWIG_fail;
37547 swig_obj[0] = args;
37548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37549 if (!SWIG_IsOK(res1)) {
37550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37551 }
37552 arg1 = reinterpret_cast< wxWindow * >(argp1);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (bool)((wxWindow const *)arg1)->HasCapture();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 bool arg2 = (bool) true ;
37572 wxRect *arg3 = (wxRect *) NULL ;
37573 void *argp1 = 0 ;
37574 int res1 = 0 ;
37575 bool val2 ;
37576 int ecode2 = 0 ;
37577 void *argp3 = 0 ;
37578 int res3 = 0 ;
37579 PyObject * obj0 = 0 ;
37580 PyObject * obj1 = 0 ;
37581 PyObject * obj2 = 0 ;
37582 char * kwnames[] = {
37583 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37584 };
37585
37586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37588 if (!SWIG_IsOK(res1)) {
37589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37590 }
37591 arg1 = reinterpret_cast< wxWindow * >(argp1);
37592 if (obj1) {
37593 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37594 if (!SWIG_IsOK(ecode2)) {
37595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37596 }
37597 arg2 = static_cast< bool >(val2);
37598 }
37599 if (obj2) {
37600 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37601 if (!SWIG_IsOK(res3)) {
37602 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37603 }
37604 arg3 = reinterpret_cast< wxRect * >(argp3);
37605 }
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 resultobj = SWIG_Py_Void();
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37620 PyObject *resultobj = 0;
37621 wxWindow *arg1 = (wxWindow *) 0 ;
37622 wxRect *arg2 = 0 ;
37623 bool arg3 = (bool) true ;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 wxRect temp2 ;
37627 bool val3 ;
37628 int ecode3 = 0 ;
37629 PyObject * obj0 = 0 ;
37630 PyObject * obj1 = 0 ;
37631 PyObject * obj2 = 0 ;
37632 char * kwnames[] = {
37633 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37634 };
37635
37636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37638 if (!SWIG_IsOK(res1)) {
37639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37640 }
37641 arg1 = reinterpret_cast< wxWindow * >(argp1);
37642 {
37643 arg2 = &temp2;
37644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37645 }
37646 if (obj2) {
37647 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37648 if (!SWIG_IsOK(ecode3)) {
37649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37650 }
37651 arg3 = static_cast< bool >(val3);
37652 }
37653 {
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 resultobj = SWIG_Py_Void();
37660 return resultobj;
37661 fail:
37662 return NULL;
37663 }
37664
37665
37666 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37667 PyObject *resultobj = 0;
37668 wxWindow *arg1 = (wxWindow *) 0 ;
37669 void *argp1 = 0 ;
37670 int res1 = 0 ;
37671 PyObject *swig_obj[1] ;
37672
37673 if (!args) SWIG_fail;
37674 swig_obj[0] = args;
37675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37676 if (!SWIG_IsOK(res1)) {
37677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37678 }
37679 arg1 = reinterpret_cast< wxWindow * >(argp1);
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 (arg1)->Update();
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 resultobj = SWIG_Py_Void();
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37694 PyObject *resultobj = 0;
37695 wxWindow *arg1 = (wxWindow *) 0 ;
37696 void *argp1 = 0 ;
37697 int res1 = 0 ;
37698 PyObject *swig_obj[1] ;
37699
37700 if (!args) SWIG_fail;
37701 swig_obj[0] = args;
37702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37703 if (!SWIG_IsOK(res1)) {
37704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37705 }
37706 arg1 = reinterpret_cast< wxWindow * >(argp1);
37707 {
37708 PyThreadState* __tstate = wxPyBeginAllowThreads();
37709 (arg1)->ClearBackground();
37710 wxPyEndAllowThreads(__tstate);
37711 if (PyErr_Occurred()) SWIG_fail;
37712 }
37713 resultobj = SWIG_Py_Void();
37714 return resultobj;
37715 fail:
37716 return NULL;
37717 }
37718
37719
37720 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37721 PyObject *resultobj = 0;
37722 wxWindow *arg1 = (wxWindow *) 0 ;
37723 void *argp1 = 0 ;
37724 int res1 = 0 ;
37725 PyObject *swig_obj[1] ;
37726
37727 if (!args) SWIG_fail;
37728 swig_obj[0] = args;
37729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37730 if (!SWIG_IsOK(res1)) {
37731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37732 }
37733 arg1 = reinterpret_cast< wxWindow * >(argp1);
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 (arg1)->Freeze();
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 resultobj = SWIG_Py_Void();
37741 return resultobj;
37742 fail:
37743 return NULL;
37744 }
37745
37746
37747 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37748 PyObject *resultobj = 0;
37749 wxWindow *arg1 = (wxWindow *) 0 ;
37750 bool result;
37751 void *argp1 = 0 ;
37752 int res1 = 0 ;
37753 PyObject *swig_obj[1] ;
37754
37755 if (!args) SWIG_fail;
37756 swig_obj[0] = args;
37757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37758 if (!SWIG_IsOK(res1)) {
37759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37760 }
37761 arg1 = reinterpret_cast< wxWindow * >(argp1);
37762 {
37763 PyThreadState* __tstate = wxPyBeginAllowThreads();
37764 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37765 wxPyEndAllowThreads(__tstate);
37766 if (PyErr_Occurred()) SWIG_fail;
37767 }
37768 {
37769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37770 }
37771 return resultobj;
37772 fail:
37773 return NULL;
37774 }
37775
37776
37777 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37778 PyObject *resultobj = 0;
37779 wxWindow *arg1 = (wxWindow *) 0 ;
37780 void *argp1 = 0 ;
37781 int res1 = 0 ;
37782 PyObject *swig_obj[1] ;
37783
37784 if (!args) SWIG_fail;
37785 swig_obj[0] = args;
37786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37787 if (!SWIG_IsOK(res1)) {
37788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37789 }
37790 arg1 = reinterpret_cast< wxWindow * >(argp1);
37791 {
37792 PyThreadState* __tstate = wxPyBeginAllowThreads();
37793 (arg1)->Thaw();
37794 wxPyEndAllowThreads(__tstate);
37795 if (PyErr_Occurred()) SWIG_fail;
37796 }
37797 resultobj = SWIG_Py_Void();
37798 return resultobj;
37799 fail:
37800 return NULL;
37801 }
37802
37803
37804 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37805 PyObject *resultobj = 0;
37806 wxWindow *arg1 = (wxWindow *) 0 ;
37807 wxDC *arg2 = 0 ;
37808 void *argp1 = 0 ;
37809 int res1 = 0 ;
37810 void *argp2 = 0 ;
37811 int res2 = 0 ;
37812 PyObject * obj0 = 0 ;
37813 PyObject * obj1 = 0 ;
37814 char * kwnames[] = {
37815 (char *) "self",(char *) "dc", NULL
37816 };
37817
37818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37820 if (!SWIG_IsOK(res1)) {
37821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37822 }
37823 arg1 = reinterpret_cast< wxWindow * >(argp1);
37824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37825 if (!SWIG_IsOK(res2)) {
37826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37827 }
37828 if (!argp2) {
37829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37830 }
37831 arg2 = reinterpret_cast< wxDC * >(argp2);
37832 {
37833 PyThreadState* __tstate = wxPyBeginAllowThreads();
37834 (arg1)->PrepareDC(*arg2);
37835 wxPyEndAllowThreads(__tstate);
37836 if (PyErr_Occurred()) SWIG_fail;
37837 }
37838 resultobj = SWIG_Py_Void();
37839 return resultobj;
37840 fail:
37841 return NULL;
37842 }
37843
37844
37845 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37846 PyObject *resultobj = 0;
37847 wxWindow *arg1 = (wxWindow *) 0 ;
37848 bool result;
37849 void *argp1 = 0 ;
37850 int res1 = 0 ;
37851 PyObject *swig_obj[1] ;
37852
37853 if (!args) SWIG_fail;
37854 swig_obj[0] = args;
37855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37856 if (!SWIG_IsOK(res1)) {
37857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37858 }
37859 arg1 = reinterpret_cast< wxWindow * >(argp1);
37860 {
37861 PyThreadState* __tstate = wxPyBeginAllowThreads();
37862 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37863 wxPyEndAllowThreads(__tstate);
37864 if (PyErr_Occurred()) SWIG_fail;
37865 }
37866 {
37867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37868 }
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 PyObject *resultobj = 0;
37877 wxWindow *arg1 = (wxWindow *) 0 ;
37878 wxRegion *result = 0 ;
37879 void *argp1 = 0 ;
37880 int res1 = 0 ;
37881 PyObject *swig_obj[1] ;
37882
37883 if (!args) SWIG_fail;
37884 swig_obj[0] = args;
37885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37886 if (!SWIG_IsOK(res1)) {
37887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37888 }
37889 arg1 = reinterpret_cast< wxWindow * >(argp1);
37890 {
37891 PyThreadState* __tstate = wxPyBeginAllowThreads();
37892 {
37893 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37894 result = (wxRegion *) &_result_ref;
37895 }
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37900 return resultobj;
37901 fail:
37902 return NULL;
37903 }
37904
37905
37906 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37907 PyObject *resultobj = 0;
37908 wxWindow *arg1 = (wxWindow *) 0 ;
37909 wxRect result;
37910 void *argp1 = 0 ;
37911 int res1 = 0 ;
37912 PyObject *swig_obj[1] ;
37913
37914 if (!args) SWIG_fail;
37915 swig_obj[0] = args;
37916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37919 }
37920 arg1 = reinterpret_cast< wxWindow * >(argp1);
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37928 return resultobj;
37929 fail:
37930 return NULL;
37931 }
37932
37933
37934 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37935 PyObject *resultobj = 0;
37936 wxWindow *arg1 = (wxWindow *) 0 ;
37937 int arg2 ;
37938 int arg3 ;
37939 int arg4 = (int) 1 ;
37940 int arg5 = (int) 1 ;
37941 bool result;
37942 void *argp1 = 0 ;
37943 int res1 = 0 ;
37944 int val2 ;
37945 int ecode2 = 0 ;
37946 int val3 ;
37947 int ecode3 = 0 ;
37948 int val4 ;
37949 int ecode4 = 0 ;
37950 int val5 ;
37951 int ecode5 = 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 PyObject * obj2 = 0 ;
37955 PyObject * obj3 = 0 ;
37956 PyObject * obj4 = 0 ;
37957 char * kwnames[] = {
37958 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37959 };
37960
37961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37963 if (!SWIG_IsOK(res1)) {
37964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37965 }
37966 arg1 = reinterpret_cast< wxWindow * >(argp1);
37967 ecode2 = SWIG_AsVal_int(obj1, &val2);
37968 if (!SWIG_IsOK(ecode2)) {
37969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37970 }
37971 arg2 = static_cast< int >(val2);
37972 ecode3 = SWIG_AsVal_int(obj2, &val3);
37973 if (!SWIG_IsOK(ecode3)) {
37974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37975 }
37976 arg3 = static_cast< int >(val3);
37977 if (obj3) {
37978 ecode4 = SWIG_AsVal_int(obj3, &val4);
37979 if (!SWIG_IsOK(ecode4)) {
37980 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37981 }
37982 arg4 = static_cast< int >(val4);
37983 }
37984 if (obj4) {
37985 ecode5 = SWIG_AsVal_int(obj4, &val5);
37986 if (!SWIG_IsOK(ecode5)) {
37987 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37988 }
37989 arg5 = static_cast< int >(val5);
37990 }
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 {
37998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37999 }
38000 return resultobj;
38001 fail:
38002 return NULL;
38003 }
38004
38005
38006 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38007 PyObject *resultobj = 0;
38008 wxWindow *arg1 = (wxWindow *) 0 ;
38009 wxPoint *arg2 = 0 ;
38010 bool result;
38011 void *argp1 = 0 ;
38012 int res1 = 0 ;
38013 wxPoint temp2 ;
38014 PyObject * obj0 = 0 ;
38015 PyObject * obj1 = 0 ;
38016 char * kwnames[] = {
38017 (char *) "self",(char *) "pt", NULL
38018 };
38019
38020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38022 if (!SWIG_IsOK(res1)) {
38023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38024 }
38025 arg1 = reinterpret_cast< wxWindow * >(argp1);
38026 {
38027 arg2 = &temp2;
38028 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38029 }
38030 {
38031 PyThreadState* __tstate = wxPyBeginAllowThreads();
38032 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
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_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj = 0;
38047 wxWindow *arg1 = (wxWindow *) 0 ;
38048 wxRect *arg2 = 0 ;
38049 bool result;
38050 void *argp1 = 0 ;
38051 int res1 = 0 ;
38052 wxRect temp2 ;
38053 PyObject * obj0 = 0 ;
38054 PyObject * obj1 = 0 ;
38055 char * kwnames[] = {
38056 (char *) "self",(char *) "rect", NULL
38057 };
38058
38059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 {
38066 arg2 = &temp2;
38067 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38068 }
38069 {
38070 PyThreadState* __tstate = wxPyBeginAllowThreads();
38071 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38072 wxPyEndAllowThreads(__tstate);
38073 if (PyErr_Occurred()) SWIG_fail;
38074 }
38075 {
38076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38077 }
38078 return resultobj;
38079 fail:
38080 return NULL;
38081 }
38082
38083
38084 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38085 PyObject *resultobj = 0;
38086 wxWindow *arg1 = (wxWindow *) 0 ;
38087 SwigValueWrapper<wxVisualAttributes > result;
38088 void *argp1 = 0 ;
38089 int res1 = 0 ;
38090 PyObject *swig_obj[1] ;
38091
38092 if (!args) SWIG_fail;
38093 swig_obj[0] = args;
38094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38095 if (!SWIG_IsOK(res1)) {
38096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38097 }
38098 arg1 = reinterpret_cast< wxWindow * >(argp1);
38099 {
38100 PyThreadState* __tstate = wxPyBeginAllowThreads();
38101 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38102 wxPyEndAllowThreads(__tstate);
38103 if (PyErr_Occurred()) SWIG_fail;
38104 }
38105 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38106 return resultobj;
38107 fail:
38108 return NULL;
38109 }
38110
38111
38112 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38113 PyObject *resultobj = 0;
38114 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38115 SwigValueWrapper<wxVisualAttributes > result;
38116 int val1 ;
38117 int ecode1 = 0 ;
38118 PyObject * obj0 = 0 ;
38119 char * kwnames[] = {
38120 (char *) "variant", NULL
38121 };
38122
38123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38124 if (obj0) {
38125 ecode1 = SWIG_AsVal_int(obj0, &val1);
38126 if (!SWIG_IsOK(ecode1)) {
38127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38128 }
38129 arg1 = static_cast< wxWindowVariant >(val1);
38130 }
38131 {
38132 if (!wxPyCheckForApp()) SWIG_fail;
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = wxWindow::GetClassDefaultAttributes(arg1);
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindow *arg1 = (wxWindow *) 0 ;
38148 wxColour *arg2 = 0 ;
38149 bool result;
38150 void *argp1 = 0 ;
38151 int res1 = 0 ;
38152 wxColour temp2 ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 char * kwnames[] = {
38156 (char *) "self",(char *) "colour", NULL
38157 };
38158
38159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38163 }
38164 arg1 = reinterpret_cast< wxWindow * >(argp1);
38165 {
38166 arg2 = &temp2;
38167 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38168 }
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38172 wxPyEndAllowThreads(__tstate);
38173 if (PyErr_Occurred()) SWIG_fail;
38174 }
38175 {
38176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38177 }
38178 return resultobj;
38179 fail:
38180 return NULL;
38181 }
38182
38183
38184 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38185 PyObject *resultobj = 0;
38186 wxWindow *arg1 = (wxWindow *) 0 ;
38187 wxColour *arg2 = 0 ;
38188 void *argp1 = 0 ;
38189 int res1 = 0 ;
38190 wxColour temp2 ;
38191 PyObject * obj0 = 0 ;
38192 PyObject * obj1 = 0 ;
38193 char * kwnames[] = {
38194 (char *) "self",(char *) "colour", NULL
38195 };
38196
38197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38199 if (!SWIG_IsOK(res1)) {
38200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38201 }
38202 arg1 = reinterpret_cast< wxWindow * >(argp1);
38203 {
38204 arg2 = &temp2;
38205 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38206 }
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 resultobj = SWIG_Py_Void();
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38221 PyObject *resultobj = 0;
38222 wxWindow *arg1 = (wxWindow *) 0 ;
38223 wxColour *arg2 = 0 ;
38224 bool result;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 wxColour temp2 ;
38228 PyObject * obj0 = 0 ;
38229 PyObject * obj1 = 0 ;
38230 char * kwnames[] = {
38231 (char *) "self",(char *) "colour", NULL
38232 };
38233
38234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38236 if (!SWIG_IsOK(res1)) {
38237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38238 }
38239 arg1 = reinterpret_cast< wxWindow * >(argp1);
38240 {
38241 arg2 = &temp2;
38242 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38243 }
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 {
38251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38252 }
38253 return resultobj;
38254 fail:
38255 return NULL;
38256 }
38257
38258
38259 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38260 PyObject *resultobj = 0;
38261 wxWindow *arg1 = (wxWindow *) 0 ;
38262 wxColour *arg2 = 0 ;
38263 void *argp1 = 0 ;
38264 int res1 = 0 ;
38265 wxColour temp2 ;
38266 PyObject * obj0 = 0 ;
38267 PyObject * obj1 = 0 ;
38268 char * kwnames[] = {
38269 (char *) "self",(char *) "colour", NULL
38270 };
38271
38272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",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_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38276 }
38277 arg1 = reinterpret_cast< wxWindow * >(argp1);
38278 {
38279 arg2 = &temp2;
38280 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38281 }
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38285 wxPyEndAllowThreads(__tstate);
38286 if (PyErr_Occurred()) SWIG_fail;
38287 }
38288 resultobj = SWIG_Py_Void();
38289 return resultobj;
38290 fail:
38291 return NULL;
38292 }
38293
38294
38295 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38296 PyObject *resultobj = 0;
38297 wxWindow *arg1 = (wxWindow *) 0 ;
38298 wxColour result;
38299 void *argp1 = 0 ;
38300 int res1 = 0 ;
38301 PyObject *swig_obj[1] ;
38302
38303 if (!args) SWIG_fail;
38304 swig_obj[0] = args;
38305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38306 if (!SWIG_IsOK(res1)) {
38307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38308 }
38309 arg1 = reinterpret_cast< wxWindow * >(argp1);
38310 {
38311 PyThreadState* __tstate = wxPyBeginAllowThreads();
38312 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38317 return resultobj;
38318 fail:
38319 return NULL;
38320 }
38321
38322
38323 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38324 PyObject *resultobj = 0;
38325 wxWindow *arg1 = (wxWindow *) 0 ;
38326 wxColour result;
38327 void *argp1 = 0 ;
38328 int res1 = 0 ;
38329 PyObject *swig_obj[1] ;
38330
38331 if (!args) SWIG_fail;
38332 swig_obj[0] = args;
38333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38334 if (!SWIG_IsOK(res1)) {
38335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38336 }
38337 arg1 = reinterpret_cast< wxWindow * >(argp1);
38338 {
38339 PyThreadState* __tstate = wxPyBeginAllowThreads();
38340 result = ((wxWindow const *)arg1)->GetForegroundColour();
38341 wxPyEndAllowThreads(__tstate);
38342 if (PyErr_Occurred()) SWIG_fail;
38343 }
38344 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38345 return resultobj;
38346 fail:
38347 return NULL;
38348 }
38349
38350
38351 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38352 PyObject *resultobj = 0;
38353 wxWindow *arg1 = (wxWindow *) 0 ;
38354 bool result;
38355 void *argp1 = 0 ;
38356 int res1 = 0 ;
38357 PyObject *swig_obj[1] ;
38358
38359 if (!args) SWIG_fail;
38360 swig_obj[0] = args;
38361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38362 if (!SWIG_IsOK(res1)) {
38363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38364 }
38365 arg1 = reinterpret_cast< wxWindow * >(argp1);
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38369 wxPyEndAllowThreads(__tstate);
38370 if (PyErr_Occurred()) SWIG_fail;
38371 }
38372 {
38373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38374 }
38375 return resultobj;
38376 fail:
38377 return NULL;
38378 }
38379
38380
38381 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38382 PyObject *resultobj = 0;
38383 wxWindow *arg1 = (wxWindow *) 0 ;
38384 bool result;
38385 void *argp1 = 0 ;
38386 int res1 = 0 ;
38387 PyObject *swig_obj[1] ;
38388
38389 if (!args) SWIG_fail;
38390 swig_obj[0] = args;
38391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38392 if (!SWIG_IsOK(res1)) {
38393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38394 }
38395 arg1 = reinterpret_cast< wxWindow * >(argp1);
38396 {
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 {
38403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38404 }
38405 return resultobj;
38406 fail:
38407 return NULL;
38408 }
38409
38410
38411 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38412 PyObject *resultobj = 0;
38413 wxWindow *arg1 = (wxWindow *) 0 ;
38414 wxBackgroundStyle arg2 ;
38415 bool result;
38416 void *argp1 = 0 ;
38417 int res1 = 0 ;
38418 int val2 ;
38419 int ecode2 = 0 ;
38420 PyObject * obj0 = 0 ;
38421 PyObject * obj1 = 0 ;
38422 char * kwnames[] = {
38423 (char *) "self",(char *) "style", NULL
38424 };
38425
38426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38428 if (!SWIG_IsOK(res1)) {
38429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38430 }
38431 arg1 = reinterpret_cast< wxWindow * >(argp1);
38432 ecode2 = SWIG_AsVal_int(obj1, &val2);
38433 if (!SWIG_IsOK(ecode2)) {
38434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38435 }
38436 arg2 = static_cast< wxBackgroundStyle >(val2);
38437 {
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38440 wxPyEndAllowThreads(__tstate);
38441 if (PyErr_Occurred()) SWIG_fail;
38442 }
38443 {
38444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38445 }
38446 return resultobj;
38447 fail:
38448 return NULL;
38449 }
38450
38451
38452 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38453 PyObject *resultobj = 0;
38454 wxWindow *arg1 = (wxWindow *) 0 ;
38455 wxBackgroundStyle result;
38456 void *argp1 = 0 ;
38457 int res1 = 0 ;
38458 PyObject *swig_obj[1] ;
38459
38460 if (!args) SWIG_fail;
38461 swig_obj[0] = args;
38462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38463 if (!SWIG_IsOK(res1)) {
38464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38465 }
38466 arg1 = reinterpret_cast< wxWindow * >(argp1);
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38470 wxPyEndAllowThreads(__tstate);
38471 if (PyErr_Occurred()) SWIG_fail;
38472 }
38473 resultobj = SWIG_From_int(static_cast< int >(result));
38474 return resultobj;
38475 fail:
38476 return NULL;
38477 }
38478
38479
38480 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38481 PyObject *resultobj = 0;
38482 wxWindow *arg1 = (wxWindow *) 0 ;
38483 bool result;
38484 void *argp1 = 0 ;
38485 int res1 = 0 ;
38486 PyObject *swig_obj[1] ;
38487
38488 if (!args) SWIG_fail;
38489 swig_obj[0] = args;
38490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38491 if (!SWIG_IsOK(res1)) {
38492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38493 }
38494 arg1 = reinterpret_cast< wxWindow * >(argp1);
38495 {
38496 PyThreadState* __tstate = wxPyBeginAllowThreads();
38497 result = (bool)(arg1)->HasTransparentBackground();
38498 wxPyEndAllowThreads(__tstate);
38499 if (PyErr_Occurred()) SWIG_fail;
38500 }
38501 {
38502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38503 }
38504 return resultobj;
38505 fail:
38506 return NULL;
38507 }
38508
38509
38510 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj = 0;
38512 wxWindow *arg1 = (wxWindow *) 0 ;
38513 wxCursor *arg2 = 0 ;
38514 bool result;
38515 void *argp1 = 0 ;
38516 int res1 = 0 ;
38517 void *argp2 = 0 ;
38518 int res2 = 0 ;
38519 PyObject * obj0 = 0 ;
38520 PyObject * obj1 = 0 ;
38521 char * kwnames[] = {
38522 (char *) "self",(char *) "cursor", NULL
38523 };
38524
38525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38527 if (!SWIG_IsOK(res1)) {
38528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38529 }
38530 arg1 = reinterpret_cast< wxWindow * >(argp1);
38531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38532 if (!SWIG_IsOK(res2)) {
38533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38534 }
38535 if (!argp2) {
38536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38537 }
38538 arg2 = reinterpret_cast< wxCursor * >(argp2);
38539 {
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38542 wxPyEndAllowThreads(__tstate);
38543 if (PyErr_Occurred()) SWIG_fail;
38544 }
38545 {
38546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38547 }
38548 return resultobj;
38549 fail:
38550 return NULL;
38551 }
38552
38553
38554 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38555 PyObject *resultobj = 0;
38556 wxWindow *arg1 = (wxWindow *) 0 ;
38557 wxCursor result;
38558 void *argp1 = 0 ;
38559 int res1 = 0 ;
38560 PyObject *swig_obj[1] ;
38561
38562 if (!args) SWIG_fail;
38563 swig_obj[0] = args;
38564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38565 if (!SWIG_IsOK(res1)) {
38566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38567 }
38568 arg1 = reinterpret_cast< wxWindow * >(argp1);
38569 {
38570 PyThreadState* __tstate = wxPyBeginAllowThreads();
38571 result = (arg1)->GetCursor();
38572 wxPyEndAllowThreads(__tstate);
38573 if (PyErr_Occurred()) SWIG_fail;
38574 }
38575 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38576 return resultobj;
38577 fail:
38578 return NULL;
38579 }
38580
38581
38582 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38583 PyObject *resultobj = 0;
38584 wxWindow *arg1 = (wxWindow *) 0 ;
38585 wxFont *arg2 = 0 ;
38586 bool result;
38587 void *argp1 = 0 ;
38588 int res1 = 0 ;
38589 void *argp2 = 0 ;
38590 int res2 = 0 ;
38591 PyObject * obj0 = 0 ;
38592 PyObject * obj1 = 0 ;
38593 char * kwnames[] = {
38594 (char *) "self",(char *) "font", NULL
38595 };
38596
38597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38599 if (!SWIG_IsOK(res1)) {
38600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38601 }
38602 arg1 = reinterpret_cast< wxWindow * >(argp1);
38603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38604 if (!SWIG_IsOK(res2)) {
38605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38606 }
38607 if (!argp2) {
38608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38609 }
38610 arg2 = reinterpret_cast< wxFont * >(argp2);
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38619 }
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38627 PyObject *resultobj = 0;
38628 wxWindow *arg1 = (wxWindow *) 0 ;
38629 wxFont *arg2 = 0 ;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 void *argp2 = 0 ;
38633 int res2 = 0 ;
38634 PyObject * obj0 = 0 ;
38635 PyObject * obj1 = 0 ;
38636 char * kwnames[] = {
38637 (char *) "self",(char *) "font", NULL
38638 };
38639
38640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38642 if (!SWIG_IsOK(res1)) {
38643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38644 }
38645 arg1 = reinterpret_cast< wxWindow * >(argp1);
38646 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38647 if (!SWIG_IsOK(res2)) {
38648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38649 }
38650 if (!argp2) {
38651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38652 }
38653 arg2 = reinterpret_cast< wxFont * >(argp2);
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 (arg1)->SetOwnFont((wxFont const &)*arg2);
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 resultobj = SWIG_Py_Void();
38661 return resultobj;
38662 fail:
38663 return NULL;
38664 }
38665
38666
38667 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38668 PyObject *resultobj = 0;
38669 wxWindow *arg1 = (wxWindow *) 0 ;
38670 wxFont result;
38671 void *argp1 = 0 ;
38672 int res1 = 0 ;
38673 PyObject *swig_obj[1] ;
38674
38675 if (!args) SWIG_fail;
38676 swig_obj[0] = args;
38677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38678 if (!SWIG_IsOK(res1)) {
38679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38680 }
38681 arg1 = reinterpret_cast< wxWindow * >(argp1);
38682 {
38683 PyThreadState* __tstate = wxPyBeginAllowThreads();
38684 result = (arg1)->GetFont();
38685 wxPyEndAllowThreads(__tstate);
38686 if (PyErr_Occurred()) SWIG_fail;
38687 }
38688 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38689 return resultobj;
38690 fail:
38691 return NULL;
38692 }
38693
38694
38695 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38696 PyObject *resultobj = 0;
38697 wxWindow *arg1 = (wxWindow *) 0 ;
38698 wxCaret *arg2 = (wxCaret *) 0 ;
38699 void *argp1 = 0 ;
38700 int res1 = 0 ;
38701 int res2 = 0 ;
38702 PyObject * obj0 = 0 ;
38703 PyObject * obj1 = 0 ;
38704 char * kwnames[] = {
38705 (char *) "self",(char *) "caret", NULL
38706 };
38707
38708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38710 if (!SWIG_IsOK(res1)) {
38711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38712 }
38713 arg1 = reinterpret_cast< wxWindow * >(argp1);
38714 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38715 if (!SWIG_IsOK(res2)) {
38716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38717 }
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 (arg1)->SetCaret(arg2);
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 resultobj = SWIG_Py_Void();
38725 return resultobj;
38726 fail:
38727 return NULL;
38728 }
38729
38730
38731 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38732 PyObject *resultobj = 0;
38733 wxWindow *arg1 = (wxWindow *) 0 ;
38734 wxCaret *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 PyObject *swig_obj[1] ;
38738
38739 if (!args) SWIG_fail;
38740 swig_obj[0] = args;
38741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38742 if (!SWIG_IsOK(res1)) {
38743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38744 }
38745 arg1 = reinterpret_cast< wxWindow * >(argp1);
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38760 PyObject *resultobj = 0;
38761 wxWindow *arg1 = (wxWindow *) 0 ;
38762 int result;
38763 void *argp1 = 0 ;
38764 int res1 = 0 ;
38765 PyObject *swig_obj[1] ;
38766
38767 if (!args) SWIG_fail;
38768 swig_obj[0] = args;
38769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38770 if (!SWIG_IsOK(res1)) {
38771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38772 }
38773 arg1 = reinterpret_cast< wxWindow * >(argp1);
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38777 wxPyEndAllowThreads(__tstate);
38778 if (PyErr_Occurred()) SWIG_fail;
38779 }
38780 resultobj = SWIG_From_int(static_cast< int >(result));
38781 return resultobj;
38782 fail:
38783 return NULL;
38784 }
38785
38786
38787 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38788 PyObject *resultobj = 0;
38789 wxWindow *arg1 = (wxWindow *) 0 ;
38790 int result;
38791 void *argp1 = 0 ;
38792 int res1 = 0 ;
38793 PyObject *swig_obj[1] ;
38794
38795 if (!args) SWIG_fail;
38796 swig_obj[0] = args;
38797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38798 if (!SWIG_IsOK(res1)) {
38799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38800 }
38801 arg1 = reinterpret_cast< wxWindow * >(argp1);
38802 {
38803 PyThreadState* __tstate = wxPyBeginAllowThreads();
38804 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 resultobj = SWIG_From_int(static_cast< int >(result));
38809 return resultobj;
38810 fail:
38811 return NULL;
38812 }
38813
38814
38815 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj = 0;
38817 wxWindow *arg1 = (wxWindow *) 0 ;
38818 wxString *arg2 = 0 ;
38819 int *arg3 = (int *) 0 ;
38820 int *arg4 = (int *) 0 ;
38821 void *argp1 = 0 ;
38822 int res1 = 0 ;
38823 bool temp2 = false ;
38824 int temp3 ;
38825 int res3 = SWIG_TMPOBJ ;
38826 int temp4 ;
38827 int res4 = SWIG_TMPOBJ ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 char * kwnames[] = {
38831 (char *) "self",(char *) "string", NULL
38832 };
38833
38834 arg3 = &temp3;
38835 arg4 = &temp4;
38836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38838 if (!SWIG_IsOK(res1)) {
38839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38840 }
38841 arg1 = reinterpret_cast< wxWindow * >(argp1);
38842 {
38843 arg2 = wxString_in_helper(obj1);
38844 if (arg2 == NULL) SWIG_fail;
38845 temp2 = true;
38846 }
38847 {
38848 PyThreadState* __tstate = wxPyBeginAllowThreads();
38849 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 resultobj = SWIG_Py_Void();
38854 if (SWIG_IsTmpObj(res3)) {
38855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38856 } else {
38857 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38859 }
38860 if (SWIG_IsTmpObj(res4)) {
38861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38862 } else {
38863 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38865 }
38866 {
38867 if (temp2)
38868 delete arg2;
38869 }
38870 return resultobj;
38871 fail:
38872 {
38873 if (temp2)
38874 delete arg2;
38875 }
38876 return NULL;
38877 }
38878
38879
38880 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38881 PyObject *resultobj = 0;
38882 wxWindow *arg1 = (wxWindow *) 0 ;
38883 wxString *arg2 = 0 ;
38884 int *arg3 = (int *) 0 ;
38885 int *arg4 = (int *) 0 ;
38886 int *arg5 = (int *) 0 ;
38887 int *arg6 = (int *) 0 ;
38888 wxFont *arg7 = (wxFont *) NULL ;
38889 void *argp1 = 0 ;
38890 int res1 = 0 ;
38891 bool temp2 = false ;
38892 int temp3 ;
38893 int res3 = SWIG_TMPOBJ ;
38894 int temp4 ;
38895 int res4 = SWIG_TMPOBJ ;
38896 int temp5 ;
38897 int res5 = SWIG_TMPOBJ ;
38898 int temp6 ;
38899 int res6 = SWIG_TMPOBJ ;
38900 void *argp7 = 0 ;
38901 int res7 = 0 ;
38902 PyObject * obj0 = 0 ;
38903 PyObject * obj1 = 0 ;
38904 PyObject * obj2 = 0 ;
38905 char * kwnames[] = {
38906 (char *) "self",(char *) "string",(char *) "font", NULL
38907 };
38908
38909 arg3 = &temp3;
38910 arg4 = &temp4;
38911 arg5 = &temp5;
38912 arg6 = &temp6;
38913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38915 if (!SWIG_IsOK(res1)) {
38916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38917 }
38918 arg1 = reinterpret_cast< wxWindow * >(argp1);
38919 {
38920 arg2 = wxString_in_helper(obj1);
38921 if (arg2 == NULL) SWIG_fail;
38922 temp2 = true;
38923 }
38924 if (obj2) {
38925 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38926 if (!SWIG_IsOK(res7)) {
38927 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38928 }
38929 arg7 = reinterpret_cast< wxFont * >(argp7);
38930 }
38931 {
38932 PyThreadState* __tstate = wxPyBeginAllowThreads();
38933 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38934 wxPyEndAllowThreads(__tstate);
38935 if (PyErr_Occurred()) SWIG_fail;
38936 }
38937 resultobj = SWIG_Py_Void();
38938 if (SWIG_IsTmpObj(res3)) {
38939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38940 } else {
38941 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38943 }
38944 if (SWIG_IsTmpObj(res4)) {
38945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38946 } else {
38947 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38949 }
38950 if (SWIG_IsTmpObj(res5)) {
38951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38952 } else {
38953 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38955 }
38956 if (SWIG_IsTmpObj(res6)) {
38957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38958 } else {
38959 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38961 }
38962 {
38963 if (temp2)
38964 delete arg2;
38965 }
38966 return resultobj;
38967 fail:
38968 {
38969 if (temp2)
38970 delete arg2;
38971 }
38972 return NULL;
38973 }
38974
38975
38976 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38977 PyObject *resultobj = 0;
38978 wxWindow *arg1 = (wxWindow *) 0 ;
38979 int *arg2 = (int *) 0 ;
38980 int *arg3 = (int *) 0 ;
38981 void *argp1 = 0 ;
38982 int res1 = 0 ;
38983 int temp2 ;
38984 int res2 = 0 ;
38985 int temp3 ;
38986 int res3 = 0 ;
38987 PyObject * obj0 = 0 ;
38988 PyObject * obj1 = 0 ;
38989 PyObject * obj2 = 0 ;
38990 char * kwnames[] = {
38991 (char *) "self",(char *) "x",(char *) "y", NULL
38992 };
38993
38994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38996 if (!SWIG_IsOK(res1)) {
38997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38998 }
38999 arg1 = reinterpret_cast< wxWindow * >(argp1);
39000 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39001 int val;
39002 int ecode = SWIG_AsVal_int(obj1, &val);
39003 if (!SWIG_IsOK(ecode)) {
39004 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39005 }
39006 temp2 = static_cast< int >(val);
39007 arg2 = &temp2;
39008 res2 = SWIG_AddTmpMask(ecode);
39009 }
39010 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39011 int val;
39012 int ecode = SWIG_AsVal_int(obj2, &val);
39013 if (!SWIG_IsOK(ecode)) {
39014 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39015 }
39016 temp3 = static_cast< int >(val);
39017 arg3 = &temp3;
39018 res3 = SWIG_AddTmpMask(ecode);
39019 }
39020 {
39021 PyThreadState* __tstate = wxPyBeginAllowThreads();
39022 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39023 wxPyEndAllowThreads(__tstate);
39024 if (PyErr_Occurred()) SWIG_fail;
39025 }
39026 resultobj = SWIG_Py_Void();
39027 if (SWIG_IsTmpObj(res2)) {
39028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39029 } else {
39030 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39032 }
39033 if (SWIG_IsTmpObj(res3)) {
39034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39035 } else {
39036 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39037 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39038 }
39039 return resultobj;
39040 fail:
39041 return NULL;
39042 }
39043
39044
39045 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39046 PyObject *resultobj = 0;
39047 wxWindow *arg1 = (wxWindow *) 0 ;
39048 int *arg2 = (int *) 0 ;
39049 int *arg3 = (int *) 0 ;
39050 void *argp1 = 0 ;
39051 int res1 = 0 ;
39052 int temp2 ;
39053 int res2 = 0 ;
39054 int temp3 ;
39055 int res3 = 0 ;
39056 PyObject * obj0 = 0 ;
39057 PyObject * obj1 = 0 ;
39058 PyObject * obj2 = 0 ;
39059 char * kwnames[] = {
39060 (char *) "self",(char *) "x",(char *) "y", NULL
39061 };
39062
39063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39065 if (!SWIG_IsOK(res1)) {
39066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39067 }
39068 arg1 = reinterpret_cast< wxWindow * >(argp1);
39069 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39070 int val;
39071 int ecode = SWIG_AsVal_int(obj1, &val);
39072 if (!SWIG_IsOK(ecode)) {
39073 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39074 }
39075 temp2 = static_cast< int >(val);
39076 arg2 = &temp2;
39077 res2 = SWIG_AddTmpMask(ecode);
39078 }
39079 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39080 int val;
39081 int ecode = SWIG_AsVal_int(obj2, &val);
39082 if (!SWIG_IsOK(ecode)) {
39083 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39084 }
39085 temp3 = static_cast< int >(val);
39086 arg3 = &temp3;
39087 res3 = SWIG_AddTmpMask(ecode);
39088 }
39089 {
39090 PyThreadState* __tstate = wxPyBeginAllowThreads();
39091 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39092 wxPyEndAllowThreads(__tstate);
39093 if (PyErr_Occurred()) SWIG_fail;
39094 }
39095 resultobj = SWIG_Py_Void();
39096 if (SWIG_IsTmpObj(res2)) {
39097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39098 } else {
39099 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39100 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39101 }
39102 if (SWIG_IsTmpObj(res3)) {
39103 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39104 } else {
39105 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39106 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39107 }
39108 return resultobj;
39109 fail:
39110 return NULL;
39111 }
39112
39113
39114 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39115 PyObject *resultobj = 0;
39116 wxWindow *arg1 = (wxWindow *) 0 ;
39117 wxPoint *arg2 = 0 ;
39118 wxPoint result;
39119 void *argp1 = 0 ;
39120 int res1 = 0 ;
39121 wxPoint temp2 ;
39122 PyObject * obj0 = 0 ;
39123 PyObject * obj1 = 0 ;
39124 char * kwnames[] = {
39125 (char *) "self",(char *) "pt", NULL
39126 };
39127
39128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39130 if (!SWIG_IsOK(res1)) {
39131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39132 }
39133 arg1 = reinterpret_cast< wxWindow * >(argp1);
39134 {
39135 arg2 = &temp2;
39136 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39137 }
39138 {
39139 PyThreadState* __tstate = wxPyBeginAllowThreads();
39140 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39141 wxPyEndAllowThreads(__tstate);
39142 if (PyErr_Occurred()) SWIG_fail;
39143 }
39144 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39152 PyObject *resultobj = 0;
39153 wxWindow *arg1 = (wxWindow *) 0 ;
39154 wxPoint *arg2 = 0 ;
39155 wxPoint result;
39156 void *argp1 = 0 ;
39157 int res1 = 0 ;
39158 wxPoint temp2 ;
39159 PyObject * obj0 = 0 ;
39160 PyObject * obj1 = 0 ;
39161 char * kwnames[] = {
39162 (char *) "self",(char *) "pt", NULL
39163 };
39164
39165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39167 if (!SWIG_IsOK(res1)) {
39168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39169 }
39170 arg1 = reinterpret_cast< wxWindow * >(argp1);
39171 {
39172 arg2 = &temp2;
39173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39174 }
39175 {
39176 PyThreadState* __tstate = wxPyBeginAllowThreads();
39177 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39178 wxPyEndAllowThreads(__tstate);
39179 if (PyErr_Occurred()) SWIG_fail;
39180 }
39181 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39189 PyObject *resultobj = 0;
39190 wxWindow *arg1 = (wxWindow *) 0 ;
39191 int arg2 ;
39192 int arg3 ;
39193 wxHitTest result;
39194 void *argp1 = 0 ;
39195 int res1 = 0 ;
39196 int val2 ;
39197 int ecode2 = 0 ;
39198 int val3 ;
39199 int ecode3 = 0 ;
39200 PyObject * obj0 = 0 ;
39201 PyObject * obj1 = 0 ;
39202 PyObject * obj2 = 0 ;
39203 char * kwnames[] = {
39204 (char *) "self",(char *) "x",(char *) "y", NULL
39205 };
39206
39207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39209 if (!SWIG_IsOK(res1)) {
39210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39211 }
39212 arg1 = reinterpret_cast< wxWindow * >(argp1);
39213 ecode2 = SWIG_AsVal_int(obj1, &val2);
39214 if (!SWIG_IsOK(ecode2)) {
39215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39216 }
39217 arg2 = static_cast< int >(val2);
39218 ecode3 = SWIG_AsVal_int(obj2, &val3);
39219 if (!SWIG_IsOK(ecode3)) {
39220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39221 }
39222 arg3 = static_cast< int >(val3);
39223 {
39224 PyThreadState* __tstate = wxPyBeginAllowThreads();
39225 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39226 wxPyEndAllowThreads(__tstate);
39227 if (PyErr_Occurred()) SWIG_fail;
39228 }
39229 resultobj = SWIG_From_int(static_cast< int >(result));
39230 return resultobj;
39231 fail:
39232 return NULL;
39233 }
39234
39235
39236 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39237 PyObject *resultobj = 0;
39238 wxWindow *arg1 = (wxWindow *) 0 ;
39239 wxPoint *arg2 = 0 ;
39240 wxHitTest result;
39241 void *argp1 = 0 ;
39242 int res1 = 0 ;
39243 wxPoint temp2 ;
39244 PyObject * obj0 = 0 ;
39245 PyObject * obj1 = 0 ;
39246 char * kwnames[] = {
39247 (char *) "self",(char *) "pt", NULL
39248 };
39249
39250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39252 if (!SWIG_IsOK(res1)) {
39253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39254 }
39255 arg1 = reinterpret_cast< wxWindow * >(argp1);
39256 {
39257 arg2 = &temp2;
39258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39259 }
39260 {
39261 PyThreadState* __tstate = wxPyBeginAllowThreads();
39262 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39263 wxPyEndAllowThreads(__tstate);
39264 if (PyErr_Occurred()) SWIG_fail;
39265 }
39266 resultobj = SWIG_From_int(static_cast< int >(result));
39267 return resultobj;
39268 fail:
39269 return NULL;
39270 }
39271
39272
39273 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39274 PyObject *resultobj = 0;
39275 wxWindow *arg1 = (wxWindow *) 0 ;
39276 long arg2 ;
39277 wxBorder result;
39278 void *argp1 = 0 ;
39279 int res1 = 0 ;
39280 long val2 ;
39281 int ecode2 = 0 ;
39282
39283 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39285 if (!SWIG_IsOK(res1)) {
39286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39287 }
39288 arg1 = reinterpret_cast< wxWindow * >(argp1);
39289 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39290 if (!SWIG_IsOK(ecode2)) {
39291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39292 }
39293 arg2 = static_cast< long >(val2);
39294 {
39295 PyThreadState* __tstate = wxPyBeginAllowThreads();
39296 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39297 wxPyEndAllowThreads(__tstate);
39298 if (PyErr_Occurred()) SWIG_fail;
39299 }
39300 resultobj = SWIG_From_int(static_cast< int >(result));
39301 return resultobj;
39302 fail:
39303 return NULL;
39304 }
39305
39306
39307 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39308 PyObject *resultobj = 0;
39309 wxWindow *arg1 = (wxWindow *) 0 ;
39310 wxBorder result;
39311 void *argp1 = 0 ;
39312 int res1 = 0 ;
39313
39314 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39316 if (!SWIG_IsOK(res1)) {
39317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39318 }
39319 arg1 = reinterpret_cast< wxWindow * >(argp1);
39320 {
39321 PyThreadState* __tstate = wxPyBeginAllowThreads();
39322 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39323 wxPyEndAllowThreads(__tstate);
39324 if (PyErr_Occurred()) SWIG_fail;
39325 }
39326 resultobj = SWIG_From_int(static_cast< int >(result));
39327 return resultobj;
39328 fail:
39329 return NULL;
39330 }
39331
39332
39333 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39334 int argc;
39335 PyObject *argv[3];
39336
39337 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39338 --argc;
39339 if (argc == 1) {
39340 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39341 }
39342 if (argc == 2) {
39343 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39344 }
39345
39346 fail:
39347 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39348 return NULL;
39349 }
39350
39351
39352 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39353 PyObject *resultobj = 0;
39354 wxWindow *arg1 = (wxWindow *) 0 ;
39355 long arg2 = (long) wxUPDATE_UI_NONE ;
39356 void *argp1 = 0 ;
39357 int res1 = 0 ;
39358 long val2 ;
39359 int ecode2 = 0 ;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 char * kwnames[] = {
39363 (char *) "self",(char *) "flags", NULL
39364 };
39365
39366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39370 }
39371 arg1 = reinterpret_cast< wxWindow * >(argp1);
39372 if (obj1) {
39373 ecode2 = SWIG_AsVal_long(obj1, &val2);
39374 if (!SWIG_IsOK(ecode2)) {
39375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39376 }
39377 arg2 = static_cast< long >(val2);
39378 }
39379 {
39380 PyThreadState* __tstate = wxPyBeginAllowThreads();
39381 (arg1)->UpdateWindowUI(arg2);
39382 wxPyEndAllowThreads(__tstate);
39383 if (PyErr_Occurred()) SWIG_fail;
39384 }
39385 resultobj = SWIG_Py_Void();
39386 return resultobj;
39387 fail:
39388 return NULL;
39389 }
39390
39391
39392 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39393 PyObject *resultobj = 0;
39394 wxWindow *arg1 = (wxWindow *) 0 ;
39395 wxMenu *arg2 = (wxMenu *) 0 ;
39396 int arg3 = (int) -1 ;
39397 int arg4 = (int) -1 ;
39398 bool result;
39399 void *argp1 = 0 ;
39400 int res1 = 0 ;
39401 void *argp2 = 0 ;
39402 int res2 = 0 ;
39403 int val3 ;
39404 int ecode3 = 0 ;
39405 int val4 ;
39406 int ecode4 = 0 ;
39407 PyObject * obj0 = 0 ;
39408 PyObject * obj1 = 0 ;
39409 PyObject * obj2 = 0 ;
39410 PyObject * obj3 = 0 ;
39411 char * kwnames[] = {
39412 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39413 };
39414
39415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39417 if (!SWIG_IsOK(res1)) {
39418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39419 }
39420 arg1 = reinterpret_cast< wxWindow * >(argp1);
39421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39422 if (!SWIG_IsOK(res2)) {
39423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39424 }
39425 arg2 = reinterpret_cast< wxMenu * >(argp2);
39426 if (obj2) {
39427 ecode3 = SWIG_AsVal_int(obj2, &val3);
39428 if (!SWIG_IsOK(ecode3)) {
39429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39430 }
39431 arg3 = static_cast< int >(val3);
39432 }
39433 if (obj3) {
39434 ecode4 = SWIG_AsVal_int(obj3, &val4);
39435 if (!SWIG_IsOK(ecode4)) {
39436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39437 }
39438 arg4 = static_cast< int >(val4);
39439 }
39440 {
39441 PyThreadState* __tstate = wxPyBeginAllowThreads();
39442 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39443 wxPyEndAllowThreads(__tstate);
39444 if (PyErr_Occurred()) SWIG_fail;
39445 }
39446 {
39447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39448 }
39449 return resultobj;
39450 fail:
39451 return NULL;
39452 }
39453
39454
39455 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39456 PyObject *resultobj = 0;
39457 wxWindow *arg1 = (wxWindow *) 0 ;
39458 wxMenu *arg2 = (wxMenu *) 0 ;
39459 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39460 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39461 bool result;
39462 void *argp1 = 0 ;
39463 int res1 = 0 ;
39464 void *argp2 = 0 ;
39465 int res2 = 0 ;
39466 wxPoint temp3 ;
39467 PyObject * obj0 = 0 ;
39468 PyObject * obj1 = 0 ;
39469 PyObject * obj2 = 0 ;
39470 char * kwnames[] = {
39471 (char *) "self",(char *) "menu",(char *) "pos", NULL
39472 };
39473
39474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39476 if (!SWIG_IsOK(res1)) {
39477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39478 }
39479 arg1 = reinterpret_cast< wxWindow * >(argp1);
39480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39481 if (!SWIG_IsOK(res2)) {
39482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39483 }
39484 arg2 = reinterpret_cast< wxMenu * >(argp2);
39485 if (obj2) {
39486 {
39487 arg3 = &temp3;
39488 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39489 }
39490 }
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39494 wxPyEndAllowThreads(__tstate);
39495 if (PyErr_Occurred()) SWIG_fail;
39496 }
39497 {
39498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39499 }
39500 return resultobj;
39501 fail:
39502 return NULL;
39503 }
39504
39505
39506 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39507 PyObject *resultobj = 0;
39508 wxWindow *arg1 = (wxWindow *) 0 ;
39509 bool result;
39510 void *argp1 = 0 ;
39511 int res1 = 0 ;
39512 PyObject *swig_obj[1] ;
39513
39514 if (!args) SWIG_fail;
39515 swig_obj[0] = args;
39516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39517 if (!SWIG_IsOK(res1)) {
39518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39519 }
39520 arg1 = reinterpret_cast< wxWindow * >(argp1);
39521 {
39522 PyThreadState* __tstate = wxPyBeginAllowThreads();
39523 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39524 wxPyEndAllowThreads(__tstate);
39525 if (PyErr_Occurred()) SWIG_fail;
39526 }
39527 {
39528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39529 }
39530 return resultobj;
39531 fail:
39532 return NULL;
39533 }
39534
39535
39536 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39537 PyObject *resultobj = 0;
39538 wxWindow *arg1 = (wxWindow *) 0 ;
39539 long result;
39540 void *argp1 = 0 ;
39541 int res1 = 0 ;
39542 PyObject *swig_obj[1] ;
39543
39544 if (!args) SWIG_fail;
39545 swig_obj[0] = args;
39546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39547 if (!SWIG_IsOK(res1)) {
39548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39549 }
39550 arg1 = reinterpret_cast< wxWindow * >(argp1);
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (long)wxWindow_GetHandle(arg1);
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 resultobj = SWIG_From_long(static_cast< long >(result));
39558 return resultobj;
39559 fail:
39560 return NULL;
39561 }
39562
39563
39564 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39565 PyObject *resultobj = 0;
39566 wxWindow *arg1 = (wxWindow *) 0 ;
39567 long arg2 ;
39568 void *argp1 = 0 ;
39569 int res1 = 0 ;
39570 long val2 ;
39571 int ecode2 = 0 ;
39572 PyObject * obj0 = 0 ;
39573 PyObject * obj1 = 0 ;
39574 char * kwnames[] = {
39575 (char *) "self",(char *) "handle", NULL
39576 };
39577
39578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39580 if (!SWIG_IsOK(res1)) {
39581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39582 }
39583 arg1 = reinterpret_cast< wxWindow * >(argp1);
39584 ecode2 = SWIG_AsVal_long(obj1, &val2);
39585 if (!SWIG_IsOK(ecode2)) {
39586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39587 }
39588 arg2 = static_cast< long >(val2);
39589 {
39590 PyThreadState* __tstate = wxPyBeginAllowThreads();
39591 wxWindow_AssociateHandle(arg1,arg2);
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 resultobj = SWIG_Py_Void();
39596 return resultobj;
39597 fail:
39598 return NULL;
39599 }
39600
39601
39602 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39603 PyObject *resultobj = 0;
39604 wxWindow *arg1 = (wxWindow *) 0 ;
39605 void *argp1 = 0 ;
39606 int res1 = 0 ;
39607 PyObject *swig_obj[1] ;
39608
39609 if (!args) SWIG_fail;
39610 swig_obj[0] = args;
39611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39612 if (!SWIG_IsOK(res1)) {
39613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39614 }
39615 arg1 = reinterpret_cast< wxWindow * >(argp1);
39616 {
39617 PyThreadState* __tstate = wxPyBeginAllowThreads();
39618 (arg1)->DissociateHandle();
39619 wxPyEndAllowThreads(__tstate);
39620 if (PyErr_Occurred()) SWIG_fail;
39621 }
39622 resultobj = SWIG_Py_Void();
39623 return resultobj;
39624 fail:
39625 return NULL;
39626 }
39627
39628
39629 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39630 PyObject *resultobj = 0;
39631 wxWindow *arg1 = (wxWindow *) 0 ;
39632 wxPaintEvent *arg2 = 0 ;
39633 void *argp1 = 0 ;
39634 int res1 = 0 ;
39635 void *argp2 = 0 ;
39636 int res2 = 0 ;
39637 PyObject * obj0 = 0 ;
39638 PyObject * obj1 = 0 ;
39639 char * kwnames[] = {
39640 (char *) "self",(char *) "event", NULL
39641 };
39642
39643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39645 if (!SWIG_IsOK(res1)) {
39646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39647 }
39648 arg1 = reinterpret_cast< wxWindow * >(argp1);
39649 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39650 if (!SWIG_IsOK(res2)) {
39651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39652 }
39653 if (!argp2) {
39654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39655 }
39656 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39657 {
39658 PyThreadState* __tstate = wxPyBeginAllowThreads();
39659 (arg1)->OnPaint(*arg2);
39660 wxPyEndAllowThreads(__tstate);
39661 if (PyErr_Occurred()) SWIG_fail;
39662 }
39663 resultobj = SWIG_Py_Void();
39664 return resultobj;
39665 fail:
39666 return NULL;
39667 }
39668
39669
39670 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39671 PyObject *resultobj = 0;
39672 wxWindow *arg1 = (wxWindow *) 0 ;
39673 int arg2 ;
39674 bool result;
39675 void *argp1 = 0 ;
39676 int res1 = 0 ;
39677 int val2 ;
39678 int ecode2 = 0 ;
39679 PyObject * obj0 = 0 ;
39680 PyObject * obj1 = 0 ;
39681 char * kwnames[] = {
39682 (char *) "self",(char *) "orient", NULL
39683 };
39684
39685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39687 if (!SWIG_IsOK(res1)) {
39688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39689 }
39690 arg1 = reinterpret_cast< wxWindow * >(argp1);
39691 ecode2 = SWIG_AsVal_int(obj1, &val2);
39692 if (!SWIG_IsOK(ecode2)) {
39693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39694 }
39695 arg2 = static_cast< int >(val2);
39696 {
39697 PyThreadState* __tstate = wxPyBeginAllowThreads();
39698 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39699 wxPyEndAllowThreads(__tstate);
39700 if (PyErr_Occurred()) SWIG_fail;
39701 }
39702 {
39703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39704 }
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj = 0;
39713 wxWindow *arg1 = (wxWindow *) 0 ;
39714 int arg2 ;
39715 int arg3 ;
39716 int arg4 ;
39717 int arg5 ;
39718 bool arg6 = (bool) true ;
39719 void *argp1 = 0 ;
39720 int res1 = 0 ;
39721 int val2 ;
39722 int ecode2 = 0 ;
39723 int val3 ;
39724 int ecode3 = 0 ;
39725 int val4 ;
39726 int ecode4 = 0 ;
39727 int val5 ;
39728 int ecode5 = 0 ;
39729 bool val6 ;
39730 int ecode6 = 0 ;
39731 PyObject * obj0 = 0 ;
39732 PyObject * obj1 = 0 ;
39733 PyObject * obj2 = 0 ;
39734 PyObject * obj3 = 0 ;
39735 PyObject * obj4 = 0 ;
39736 PyObject * obj5 = 0 ;
39737 char * kwnames[] = {
39738 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39739 };
39740
39741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39743 if (!SWIG_IsOK(res1)) {
39744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39745 }
39746 arg1 = reinterpret_cast< wxWindow * >(argp1);
39747 ecode2 = SWIG_AsVal_int(obj1, &val2);
39748 if (!SWIG_IsOK(ecode2)) {
39749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39750 }
39751 arg2 = static_cast< int >(val2);
39752 ecode3 = SWIG_AsVal_int(obj2, &val3);
39753 if (!SWIG_IsOK(ecode3)) {
39754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39755 }
39756 arg3 = static_cast< int >(val3);
39757 ecode4 = SWIG_AsVal_int(obj3, &val4);
39758 if (!SWIG_IsOK(ecode4)) {
39759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39760 }
39761 arg4 = static_cast< int >(val4);
39762 ecode5 = SWIG_AsVal_int(obj4, &val5);
39763 if (!SWIG_IsOK(ecode5)) {
39764 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39765 }
39766 arg5 = static_cast< int >(val5);
39767 if (obj5) {
39768 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39769 if (!SWIG_IsOK(ecode6)) {
39770 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39771 }
39772 arg6 = static_cast< bool >(val6);
39773 }
39774 {
39775 PyThreadState* __tstate = wxPyBeginAllowThreads();
39776 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39777 wxPyEndAllowThreads(__tstate);
39778 if (PyErr_Occurred()) SWIG_fail;
39779 }
39780 resultobj = SWIG_Py_Void();
39781 return resultobj;
39782 fail:
39783 return NULL;
39784 }
39785
39786
39787 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39788 PyObject *resultobj = 0;
39789 wxWindow *arg1 = (wxWindow *) 0 ;
39790 int arg2 ;
39791 int arg3 ;
39792 bool arg4 = (bool) true ;
39793 void *argp1 = 0 ;
39794 int res1 = 0 ;
39795 int val2 ;
39796 int ecode2 = 0 ;
39797 int val3 ;
39798 int ecode3 = 0 ;
39799 bool val4 ;
39800 int ecode4 = 0 ;
39801 PyObject * obj0 = 0 ;
39802 PyObject * obj1 = 0 ;
39803 PyObject * obj2 = 0 ;
39804 PyObject * obj3 = 0 ;
39805 char * kwnames[] = {
39806 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39807 };
39808
39809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39811 if (!SWIG_IsOK(res1)) {
39812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39813 }
39814 arg1 = reinterpret_cast< wxWindow * >(argp1);
39815 ecode2 = SWIG_AsVal_int(obj1, &val2);
39816 if (!SWIG_IsOK(ecode2)) {
39817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39818 }
39819 arg2 = static_cast< int >(val2);
39820 ecode3 = SWIG_AsVal_int(obj2, &val3);
39821 if (!SWIG_IsOK(ecode3)) {
39822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39823 }
39824 arg3 = static_cast< int >(val3);
39825 if (obj3) {
39826 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39827 if (!SWIG_IsOK(ecode4)) {
39828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39829 }
39830 arg4 = static_cast< bool >(val4);
39831 }
39832 {
39833 PyThreadState* __tstate = wxPyBeginAllowThreads();
39834 (arg1)->SetScrollPos(arg2,arg3,arg4);
39835 wxPyEndAllowThreads(__tstate);
39836 if (PyErr_Occurred()) SWIG_fail;
39837 }
39838 resultobj = SWIG_Py_Void();
39839 return resultobj;
39840 fail:
39841 return NULL;
39842 }
39843
39844
39845 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39846 PyObject *resultobj = 0;
39847 wxWindow *arg1 = (wxWindow *) 0 ;
39848 int arg2 ;
39849 int result;
39850 void *argp1 = 0 ;
39851 int res1 = 0 ;
39852 int val2 ;
39853 int ecode2 = 0 ;
39854 PyObject * obj0 = 0 ;
39855 PyObject * obj1 = 0 ;
39856 char * kwnames[] = {
39857 (char *) "self",(char *) "orientation", NULL
39858 };
39859
39860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39862 if (!SWIG_IsOK(res1)) {
39863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39864 }
39865 arg1 = reinterpret_cast< wxWindow * >(argp1);
39866 ecode2 = SWIG_AsVal_int(obj1, &val2);
39867 if (!SWIG_IsOK(ecode2)) {
39868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39869 }
39870 arg2 = static_cast< int >(val2);
39871 {
39872 PyThreadState* __tstate = wxPyBeginAllowThreads();
39873 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39874 wxPyEndAllowThreads(__tstate);
39875 if (PyErr_Occurred()) SWIG_fail;
39876 }
39877 resultobj = SWIG_From_int(static_cast< int >(result));
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj = 0;
39886 wxWindow *arg1 = (wxWindow *) 0 ;
39887 int arg2 ;
39888 int result;
39889 void *argp1 = 0 ;
39890 int res1 = 0 ;
39891 int val2 ;
39892 int ecode2 = 0 ;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 char * kwnames[] = {
39896 (char *) "self",(char *) "orientation", NULL
39897 };
39898
39899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39901 if (!SWIG_IsOK(res1)) {
39902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39903 }
39904 arg1 = reinterpret_cast< wxWindow * >(argp1);
39905 ecode2 = SWIG_AsVal_int(obj1, &val2);
39906 if (!SWIG_IsOK(ecode2)) {
39907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39908 }
39909 arg2 = static_cast< int >(val2);
39910 {
39911 PyThreadState* __tstate = wxPyBeginAllowThreads();
39912 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 resultobj = SWIG_From_int(static_cast< int >(result));
39917 return resultobj;
39918 fail:
39919 return NULL;
39920 }
39921
39922
39923 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39924 PyObject *resultobj = 0;
39925 wxWindow *arg1 = (wxWindow *) 0 ;
39926 int arg2 ;
39927 int result;
39928 void *argp1 = 0 ;
39929 int res1 = 0 ;
39930 int val2 ;
39931 int ecode2 = 0 ;
39932 PyObject * obj0 = 0 ;
39933 PyObject * obj1 = 0 ;
39934 char * kwnames[] = {
39935 (char *) "self",(char *) "orientation", NULL
39936 };
39937
39938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39940 if (!SWIG_IsOK(res1)) {
39941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39942 }
39943 arg1 = reinterpret_cast< wxWindow * >(argp1);
39944 ecode2 = SWIG_AsVal_int(obj1, &val2);
39945 if (!SWIG_IsOK(ecode2)) {
39946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39947 }
39948 arg2 = static_cast< int >(val2);
39949 {
39950 PyThreadState* __tstate = wxPyBeginAllowThreads();
39951 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39952 wxPyEndAllowThreads(__tstate);
39953 if (PyErr_Occurred()) SWIG_fail;
39954 }
39955 resultobj = SWIG_From_int(static_cast< int >(result));
39956 return resultobj;
39957 fail:
39958 return NULL;
39959 }
39960
39961
39962 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39963 PyObject *resultobj = 0;
39964 wxWindow *arg1 = (wxWindow *) 0 ;
39965 int arg2 ;
39966 int arg3 ;
39967 wxRect *arg4 = (wxRect *) NULL ;
39968 void *argp1 = 0 ;
39969 int res1 = 0 ;
39970 int val2 ;
39971 int ecode2 = 0 ;
39972 int val3 ;
39973 int ecode3 = 0 ;
39974 void *argp4 = 0 ;
39975 int res4 = 0 ;
39976 PyObject * obj0 = 0 ;
39977 PyObject * obj1 = 0 ;
39978 PyObject * obj2 = 0 ;
39979 PyObject * obj3 = 0 ;
39980 char * kwnames[] = {
39981 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39982 };
39983
39984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39986 if (!SWIG_IsOK(res1)) {
39987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39988 }
39989 arg1 = reinterpret_cast< wxWindow * >(argp1);
39990 ecode2 = SWIG_AsVal_int(obj1, &val2);
39991 if (!SWIG_IsOK(ecode2)) {
39992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39993 }
39994 arg2 = static_cast< int >(val2);
39995 ecode3 = SWIG_AsVal_int(obj2, &val3);
39996 if (!SWIG_IsOK(ecode3)) {
39997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39998 }
39999 arg3 = static_cast< int >(val3);
40000 if (obj3) {
40001 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40002 if (!SWIG_IsOK(res4)) {
40003 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40004 }
40005 arg4 = reinterpret_cast< wxRect * >(argp4);
40006 }
40007 {
40008 PyThreadState* __tstate = wxPyBeginAllowThreads();
40009 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40010 wxPyEndAllowThreads(__tstate);
40011 if (PyErr_Occurred()) SWIG_fail;
40012 }
40013 resultobj = SWIG_Py_Void();
40014 return resultobj;
40015 fail:
40016 return NULL;
40017 }
40018
40019
40020 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40021 PyObject *resultobj = 0;
40022 wxWindow *arg1 = (wxWindow *) 0 ;
40023 int arg2 ;
40024 bool result;
40025 void *argp1 = 0 ;
40026 int res1 = 0 ;
40027 int val2 ;
40028 int ecode2 = 0 ;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char * kwnames[] = {
40032 (char *) "self",(char *) "lines", NULL
40033 };
40034
40035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40037 if (!SWIG_IsOK(res1)) {
40038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40039 }
40040 arg1 = reinterpret_cast< wxWindow * >(argp1);
40041 ecode2 = SWIG_AsVal_int(obj1, &val2);
40042 if (!SWIG_IsOK(ecode2)) {
40043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40044 }
40045 arg2 = static_cast< int >(val2);
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (bool)(arg1)->ScrollLines(arg2);
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 {
40053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40054 }
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40062 PyObject *resultobj = 0;
40063 wxWindow *arg1 = (wxWindow *) 0 ;
40064 int arg2 ;
40065 bool result;
40066 void *argp1 = 0 ;
40067 int res1 = 0 ;
40068 int val2 ;
40069 int ecode2 = 0 ;
40070 PyObject * obj0 = 0 ;
40071 PyObject * obj1 = 0 ;
40072 char * kwnames[] = {
40073 (char *) "self",(char *) "pages", NULL
40074 };
40075
40076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40078 if (!SWIG_IsOK(res1)) {
40079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40080 }
40081 arg1 = reinterpret_cast< wxWindow * >(argp1);
40082 ecode2 = SWIG_AsVal_int(obj1, &val2);
40083 if (!SWIG_IsOK(ecode2)) {
40084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40085 }
40086 arg2 = static_cast< int >(val2);
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 result = (bool)(arg1)->ScrollPages(arg2);
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 {
40094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40095 }
40096 return resultobj;
40097 fail:
40098 return NULL;
40099 }
40100
40101
40102 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40103 PyObject *resultobj = 0;
40104 wxWindow *arg1 = (wxWindow *) 0 ;
40105 bool result;
40106 void *argp1 = 0 ;
40107 int res1 = 0 ;
40108 PyObject *swig_obj[1] ;
40109
40110 if (!args) SWIG_fail;
40111 swig_obj[0] = args;
40112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40113 if (!SWIG_IsOK(res1)) {
40114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40115 }
40116 arg1 = reinterpret_cast< wxWindow * >(argp1);
40117 {
40118 PyThreadState* __tstate = wxPyBeginAllowThreads();
40119 result = (bool)(arg1)->LineUp();
40120 wxPyEndAllowThreads(__tstate);
40121 if (PyErr_Occurred()) SWIG_fail;
40122 }
40123 {
40124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40125 }
40126 return resultobj;
40127 fail:
40128 return NULL;
40129 }
40130
40131
40132 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40133 PyObject *resultobj = 0;
40134 wxWindow *arg1 = (wxWindow *) 0 ;
40135 bool result;
40136 void *argp1 = 0 ;
40137 int res1 = 0 ;
40138 PyObject *swig_obj[1] ;
40139
40140 if (!args) SWIG_fail;
40141 swig_obj[0] = args;
40142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40143 if (!SWIG_IsOK(res1)) {
40144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40145 }
40146 arg1 = reinterpret_cast< wxWindow * >(argp1);
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 result = (bool)(arg1)->LineDown();
40150 wxPyEndAllowThreads(__tstate);
40151 if (PyErr_Occurred()) SWIG_fail;
40152 }
40153 {
40154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40155 }
40156 return resultobj;
40157 fail:
40158 return NULL;
40159 }
40160
40161
40162 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40163 PyObject *resultobj = 0;
40164 wxWindow *arg1 = (wxWindow *) 0 ;
40165 bool result;
40166 void *argp1 = 0 ;
40167 int res1 = 0 ;
40168 PyObject *swig_obj[1] ;
40169
40170 if (!args) SWIG_fail;
40171 swig_obj[0] = args;
40172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40173 if (!SWIG_IsOK(res1)) {
40174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40175 }
40176 arg1 = reinterpret_cast< wxWindow * >(argp1);
40177 {
40178 PyThreadState* __tstate = wxPyBeginAllowThreads();
40179 result = (bool)(arg1)->PageUp();
40180 wxPyEndAllowThreads(__tstate);
40181 if (PyErr_Occurred()) SWIG_fail;
40182 }
40183 {
40184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40185 }
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40193 PyObject *resultobj = 0;
40194 wxWindow *arg1 = (wxWindow *) 0 ;
40195 bool result;
40196 void *argp1 = 0 ;
40197 int res1 = 0 ;
40198 PyObject *swig_obj[1] ;
40199
40200 if (!args) SWIG_fail;
40201 swig_obj[0] = args;
40202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40203 if (!SWIG_IsOK(res1)) {
40204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40205 }
40206 arg1 = reinterpret_cast< wxWindow * >(argp1);
40207 {
40208 PyThreadState* __tstate = wxPyBeginAllowThreads();
40209 result = (bool)(arg1)->PageDown();
40210 wxPyEndAllowThreads(__tstate);
40211 if (PyErr_Occurred()) SWIG_fail;
40212 }
40213 {
40214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40215 }
40216 return resultobj;
40217 fail:
40218 return NULL;
40219 }
40220
40221
40222 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40223 PyObject *resultobj = 0;
40224 wxWindow *arg1 = (wxWindow *) 0 ;
40225 wxString *arg2 = 0 ;
40226 void *argp1 = 0 ;
40227 int res1 = 0 ;
40228 bool temp2 = false ;
40229 PyObject * obj0 = 0 ;
40230 PyObject * obj1 = 0 ;
40231 char * kwnames[] = {
40232 (char *) "self",(char *) "text", NULL
40233 };
40234
40235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40237 if (!SWIG_IsOK(res1)) {
40238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40239 }
40240 arg1 = reinterpret_cast< wxWindow * >(argp1);
40241 {
40242 arg2 = wxString_in_helper(obj1);
40243 if (arg2 == NULL) SWIG_fail;
40244 temp2 = true;
40245 }
40246 {
40247 PyThreadState* __tstate = wxPyBeginAllowThreads();
40248 (arg1)->SetHelpText((wxString const &)*arg2);
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 resultobj = SWIG_Py_Void();
40253 {
40254 if (temp2)
40255 delete arg2;
40256 }
40257 return resultobj;
40258 fail:
40259 {
40260 if (temp2)
40261 delete arg2;
40262 }
40263 return NULL;
40264 }
40265
40266
40267 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40268 PyObject *resultobj = 0;
40269 wxWindow *arg1 = (wxWindow *) 0 ;
40270 wxString *arg2 = 0 ;
40271 void *argp1 = 0 ;
40272 int res1 = 0 ;
40273 bool temp2 = false ;
40274 PyObject * obj0 = 0 ;
40275 PyObject * obj1 = 0 ;
40276 char * kwnames[] = {
40277 (char *) "self",(char *) "text", NULL
40278 };
40279
40280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40282 if (!SWIG_IsOK(res1)) {
40283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40284 }
40285 arg1 = reinterpret_cast< wxWindow * >(argp1);
40286 {
40287 arg2 = wxString_in_helper(obj1);
40288 if (arg2 == NULL) SWIG_fail;
40289 temp2 = true;
40290 }
40291 {
40292 PyThreadState* __tstate = wxPyBeginAllowThreads();
40293 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40294 wxPyEndAllowThreads(__tstate);
40295 if (PyErr_Occurred()) SWIG_fail;
40296 }
40297 resultobj = SWIG_Py_Void();
40298 {
40299 if (temp2)
40300 delete arg2;
40301 }
40302 return resultobj;
40303 fail:
40304 {
40305 if (temp2)
40306 delete arg2;
40307 }
40308 return NULL;
40309 }
40310
40311
40312 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40313 PyObject *resultobj = 0;
40314 wxWindow *arg1 = (wxWindow *) 0 ;
40315 wxPoint *arg2 = 0 ;
40316 wxHelpEvent::Origin arg3 ;
40317 wxString result;
40318 void *argp1 = 0 ;
40319 int res1 = 0 ;
40320 wxPoint temp2 ;
40321 void *argp3 ;
40322 int res3 = 0 ;
40323 PyObject * obj0 = 0 ;
40324 PyObject * obj1 = 0 ;
40325 PyObject * obj2 = 0 ;
40326 char * kwnames[] = {
40327 (char *) "self",(char *) "pt",(char *) "origin", NULL
40328 };
40329
40330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40332 if (!SWIG_IsOK(res1)) {
40333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40334 }
40335 arg1 = reinterpret_cast< wxWindow * >(argp1);
40336 {
40337 arg2 = &temp2;
40338 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40339 }
40340 {
40341 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40342 if (!SWIG_IsOK(res3)) {
40343 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40344 }
40345 if (!argp3) {
40346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40347 } else {
40348 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40349 arg3 = *temp;
40350 if (SWIG_IsNewObj(res3)) delete temp;
40351 }
40352 }
40353 {
40354 PyThreadState* __tstate = wxPyBeginAllowThreads();
40355 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40356 wxPyEndAllowThreads(__tstate);
40357 if (PyErr_Occurred()) SWIG_fail;
40358 }
40359 {
40360 #if wxUSE_UNICODE
40361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40362 #else
40363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40364 #endif
40365 }
40366 return resultobj;
40367 fail:
40368 return NULL;
40369 }
40370
40371
40372 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40373 PyObject *resultobj = 0;
40374 wxWindow *arg1 = (wxWindow *) 0 ;
40375 wxString result;
40376 void *argp1 = 0 ;
40377 int res1 = 0 ;
40378 PyObject *swig_obj[1] ;
40379
40380 if (!args) SWIG_fail;
40381 swig_obj[0] = args;
40382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40383 if (!SWIG_IsOK(res1)) {
40384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40385 }
40386 arg1 = reinterpret_cast< wxWindow * >(argp1);
40387 {
40388 PyThreadState* __tstate = wxPyBeginAllowThreads();
40389 result = ((wxWindow const *)arg1)->GetHelpText();
40390 wxPyEndAllowThreads(__tstate);
40391 if (PyErr_Occurred()) SWIG_fail;
40392 }
40393 {
40394 #if wxUSE_UNICODE
40395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40396 #else
40397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40398 #endif
40399 }
40400 return resultobj;
40401 fail:
40402 return NULL;
40403 }
40404
40405
40406 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40407 PyObject *resultobj = 0;
40408 wxWindow *arg1 = (wxWindow *) 0 ;
40409 wxString *arg2 = 0 ;
40410 void *argp1 = 0 ;
40411 int res1 = 0 ;
40412 bool temp2 = false ;
40413 PyObject * obj0 = 0 ;
40414 PyObject * obj1 = 0 ;
40415 char * kwnames[] = {
40416 (char *) "self",(char *) "tip", NULL
40417 };
40418
40419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40421 if (!SWIG_IsOK(res1)) {
40422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40423 }
40424 arg1 = reinterpret_cast< wxWindow * >(argp1);
40425 {
40426 arg2 = wxString_in_helper(obj1);
40427 if (arg2 == NULL) SWIG_fail;
40428 temp2 = true;
40429 }
40430 {
40431 PyThreadState* __tstate = wxPyBeginAllowThreads();
40432 (arg1)->SetToolTip((wxString const &)*arg2);
40433 wxPyEndAllowThreads(__tstate);
40434 if (PyErr_Occurred()) SWIG_fail;
40435 }
40436 resultobj = SWIG_Py_Void();
40437 {
40438 if (temp2)
40439 delete arg2;
40440 }
40441 return resultobj;
40442 fail:
40443 {
40444 if (temp2)
40445 delete arg2;
40446 }
40447 return NULL;
40448 }
40449
40450
40451 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40452 PyObject *resultobj = 0;
40453 wxWindow *arg1 = (wxWindow *) 0 ;
40454 wxToolTip *arg2 = (wxToolTip *) 0 ;
40455 void *argp1 = 0 ;
40456 int res1 = 0 ;
40457 int res2 = 0 ;
40458 PyObject * obj0 = 0 ;
40459 PyObject * obj1 = 0 ;
40460 char * kwnames[] = {
40461 (char *) "self",(char *) "tip", NULL
40462 };
40463
40464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40466 if (!SWIG_IsOK(res1)) {
40467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40468 }
40469 arg1 = reinterpret_cast< wxWindow * >(argp1);
40470 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40471 if (!SWIG_IsOK(res2)) {
40472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40473 }
40474 {
40475 PyThreadState* __tstate = wxPyBeginAllowThreads();
40476 (arg1)->SetToolTip(arg2);
40477 wxPyEndAllowThreads(__tstate);
40478 if (PyErr_Occurred()) SWIG_fail;
40479 }
40480 resultobj = SWIG_Py_Void();
40481 return resultobj;
40482 fail:
40483 return NULL;
40484 }
40485
40486
40487 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40488 PyObject *resultobj = 0;
40489 wxWindow *arg1 = (wxWindow *) 0 ;
40490 wxToolTip *result = 0 ;
40491 void *argp1 = 0 ;
40492 int res1 = 0 ;
40493 PyObject *swig_obj[1] ;
40494
40495 if (!args) SWIG_fail;
40496 swig_obj[0] = args;
40497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40498 if (!SWIG_IsOK(res1)) {
40499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40500 }
40501 arg1 = reinterpret_cast< wxWindow * >(argp1);
40502 {
40503 PyThreadState* __tstate = wxPyBeginAllowThreads();
40504 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40505 wxPyEndAllowThreads(__tstate);
40506 if (PyErr_Occurred()) SWIG_fail;
40507 }
40508 {
40509 resultobj = wxPyMake_wxObject(result, (bool)0);
40510 }
40511 return resultobj;
40512 fail:
40513 return NULL;
40514 }
40515
40516
40517 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40518 PyObject *resultobj = 0;
40519 wxWindow *arg1 = (wxWindow *) 0 ;
40520 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40521 void *argp1 = 0 ;
40522 int res1 = 0 ;
40523 int res2 = 0 ;
40524 PyObject * obj0 = 0 ;
40525 PyObject * obj1 = 0 ;
40526 char * kwnames[] = {
40527 (char *) "self",(char *) "dropTarget", NULL
40528 };
40529
40530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40532 if (!SWIG_IsOK(res1)) {
40533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40534 }
40535 arg1 = reinterpret_cast< wxWindow * >(argp1);
40536 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40537 if (!SWIG_IsOK(res2)) {
40538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40539 }
40540 {
40541 PyThreadState* __tstate = wxPyBeginAllowThreads();
40542 (arg1)->SetDropTarget(arg2);
40543 wxPyEndAllowThreads(__tstate);
40544 if (PyErr_Occurred()) SWIG_fail;
40545 }
40546 resultobj = SWIG_Py_Void();
40547 return resultobj;
40548 fail:
40549 return NULL;
40550 }
40551
40552
40553 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40554 PyObject *resultobj = 0;
40555 wxWindow *arg1 = (wxWindow *) 0 ;
40556 wxPyDropTarget *result = 0 ;
40557 void *argp1 = 0 ;
40558 int res1 = 0 ;
40559 PyObject *swig_obj[1] ;
40560
40561 if (!args) SWIG_fail;
40562 swig_obj[0] = args;
40563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40564 if (!SWIG_IsOK(res1)) {
40565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40566 }
40567 arg1 = reinterpret_cast< wxWindow * >(argp1);
40568 {
40569 PyThreadState* __tstate = wxPyBeginAllowThreads();
40570 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40571 wxPyEndAllowThreads(__tstate);
40572 if (PyErr_Occurred()) SWIG_fail;
40573 }
40574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40575 return resultobj;
40576 fail:
40577 return NULL;
40578 }
40579
40580
40581 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40582 PyObject *resultobj = 0;
40583 wxWindow *arg1 = (wxWindow *) 0 ;
40584 bool arg2 ;
40585 void *argp1 = 0 ;
40586 int res1 = 0 ;
40587 bool val2 ;
40588 int ecode2 = 0 ;
40589 PyObject * obj0 = 0 ;
40590 PyObject * obj1 = 0 ;
40591 char * kwnames[] = {
40592 (char *) "self",(char *) "accept", NULL
40593 };
40594
40595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40597 if (!SWIG_IsOK(res1)) {
40598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40599 }
40600 arg1 = reinterpret_cast< wxWindow * >(argp1);
40601 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40602 if (!SWIG_IsOK(ecode2)) {
40603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40604 }
40605 arg2 = static_cast< bool >(val2);
40606 {
40607 PyThreadState* __tstate = wxPyBeginAllowThreads();
40608 (arg1)->DragAcceptFiles(arg2);
40609 wxPyEndAllowThreads(__tstate);
40610 if (PyErr_Occurred()) SWIG_fail;
40611 }
40612 resultobj = SWIG_Py_Void();
40613 return resultobj;
40614 fail:
40615 return NULL;
40616 }
40617
40618
40619 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40620 PyObject *resultobj = 0;
40621 wxWindow *arg1 = (wxWindow *) 0 ;
40622 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40623 void *argp1 = 0 ;
40624 int res1 = 0 ;
40625 int res2 = 0 ;
40626 PyObject * obj0 = 0 ;
40627 PyObject * obj1 = 0 ;
40628 char * kwnames[] = {
40629 (char *) "self",(char *) "constraints", NULL
40630 };
40631
40632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40634 if (!SWIG_IsOK(res1)) {
40635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40636 }
40637 arg1 = reinterpret_cast< wxWindow * >(argp1);
40638 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40639 if (!SWIG_IsOK(res2)) {
40640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40641 }
40642 {
40643 PyThreadState* __tstate = wxPyBeginAllowThreads();
40644 (arg1)->SetConstraints(arg2);
40645 wxPyEndAllowThreads(__tstate);
40646 if (PyErr_Occurred()) SWIG_fail;
40647 }
40648 resultobj = SWIG_Py_Void();
40649 return resultobj;
40650 fail:
40651 return NULL;
40652 }
40653
40654
40655 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40656 PyObject *resultobj = 0;
40657 wxWindow *arg1 = (wxWindow *) 0 ;
40658 wxLayoutConstraints *result = 0 ;
40659 void *argp1 = 0 ;
40660 int res1 = 0 ;
40661 PyObject *swig_obj[1] ;
40662
40663 if (!args) SWIG_fail;
40664 swig_obj[0] = args;
40665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40666 if (!SWIG_IsOK(res1)) {
40667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40668 }
40669 arg1 = reinterpret_cast< wxWindow * >(argp1);
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40673 wxPyEndAllowThreads(__tstate);
40674 if (PyErr_Occurred()) SWIG_fail;
40675 }
40676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40677 return resultobj;
40678 fail:
40679 return NULL;
40680 }
40681
40682
40683 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40684 PyObject *resultobj = 0;
40685 wxWindow *arg1 = (wxWindow *) 0 ;
40686 bool arg2 ;
40687 void *argp1 = 0 ;
40688 int res1 = 0 ;
40689 bool val2 ;
40690 int ecode2 = 0 ;
40691 PyObject * obj0 = 0 ;
40692 PyObject * obj1 = 0 ;
40693 char * kwnames[] = {
40694 (char *) "self",(char *) "autoLayout", NULL
40695 };
40696
40697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40699 if (!SWIG_IsOK(res1)) {
40700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40701 }
40702 arg1 = reinterpret_cast< wxWindow * >(argp1);
40703 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40704 if (!SWIG_IsOK(ecode2)) {
40705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40706 }
40707 arg2 = static_cast< bool >(val2);
40708 {
40709 PyThreadState* __tstate = wxPyBeginAllowThreads();
40710 (arg1)->SetAutoLayout(arg2);
40711 wxPyEndAllowThreads(__tstate);
40712 if (PyErr_Occurred()) SWIG_fail;
40713 }
40714 resultobj = SWIG_Py_Void();
40715 return resultobj;
40716 fail:
40717 return NULL;
40718 }
40719
40720
40721 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40722 PyObject *resultobj = 0;
40723 wxWindow *arg1 = (wxWindow *) 0 ;
40724 bool result;
40725 void *argp1 = 0 ;
40726 int res1 = 0 ;
40727 PyObject *swig_obj[1] ;
40728
40729 if (!args) SWIG_fail;
40730 swig_obj[0] = args;
40731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40732 if (!SWIG_IsOK(res1)) {
40733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40734 }
40735 arg1 = reinterpret_cast< wxWindow * >(argp1);
40736 {
40737 PyThreadState* __tstate = wxPyBeginAllowThreads();
40738 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40739 wxPyEndAllowThreads(__tstate);
40740 if (PyErr_Occurred()) SWIG_fail;
40741 }
40742 {
40743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40744 }
40745 return resultobj;
40746 fail:
40747 return NULL;
40748 }
40749
40750
40751 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40752 PyObject *resultobj = 0;
40753 wxWindow *arg1 = (wxWindow *) 0 ;
40754 bool result;
40755 void *argp1 = 0 ;
40756 int res1 = 0 ;
40757 PyObject *swig_obj[1] ;
40758
40759 if (!args) SWIG_fail;
40760 swig_obj[0] = args;
40761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40762 if (!SWIG_IsOK(res1)) {
40763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40764 }
40765 arg1 = reinterpret_cast< wxWindow * >(argp1);
40766 {
40767 PyThreadState* __tstate = wxPyBeginAllowThreads();
40768 result = (bool)(arg1)->Layout();
40769 wxPyEndAllowThreads(__tstate);
40770 if (PyErr_Occurred()) SWIG_fail;
40771 }
40772 {
40773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40774 }
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40782 PyObject *resultobj = 0;
40783 wxWindow *arg1 = (wxWindow *) 0 ;
40784 wxSizer *arg2 = (wxSizer *) 0 ;
40785 bool arg3 = (bool) true ;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 int res2 = 0 ;
40789 bool val3 ;
40790 int ecode3 = 0 ;
40791 PyObject * obj0 = 0 ;
40792 PyObject * obj1 = 0 ;
40793 PyObject * obj2 = 0 ;
40794 char * kwnames[] = {
40795 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40796 };
40797
40798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40800 if (!SWIG_IsOK(res1)) {
40801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40802 }
40803 arg1 = reinterpret_cast< wxWindow * >(argp1);
40804 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40805 if (!SWIG_IsOK(res2)) {
40806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40807 }
40808 if (obj2) {
40809 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40810 if (!SWIG_IsOK(ecode3)) {
40811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40812 }
40813 arg3 = static_cast< bool >(val3);
40814 }
40815 {
40816 PyThreadState* __tstate = wxPyBeginAllowThreads();
40817 (arg1)->SetSizer(arg2,arg3);
40818 wxPyEndAllowThreads(__tstate);
40819 if (PyErr_Occurred()) SWIG_fail;
40820 }
40821 resultobj = SWIG_Py_Void();
40822 return resultobj;
40823 fail:
40824 return NULL;
40825 }
40826
40827
40828 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40829 PyObject *resultobj = 0;
40830 wxWindow *arg1 = (wxWindow *) 0 ;
40831 wxSizer *arg2 = (wxSizer *) 0 ;
40832 bool arg3 = (bool) true ;
40833 void *argp1 = 0 ;
40834 int res1 = 0 ;
40835 int res2 = 0 ;
40836 bool val3 ;
40837 int ecode3 = 0 ;
40838 PyObject * obj0 = 0 ;
40839 PyObject * obj1 = 0 ;
40840 PyObject * obj2 = 0 ;
40841 char * kwnames[] = {
40842 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40843 };
40844
40845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40847 if (!SWIG_IsOK(res1)) {
40848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40849 }
40850 arg1 = reinterpret_cast< wxWindow * >(argp1);
40851 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40852 if (!SWIG_IsOK(res2)) {
40853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40854 }
40855 if (obj2) {
40856 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40857 if (!SWIG_IsOK(ecode3)) {
40858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40859 }
40860 arg3 = static_cast< bool >(val3);
40861 }
40862 {
40863 PyThreadState* __tstate = wxPyBeginAllowThreads();
40864 (arg1)->SetSizerAndFit(arg2,arg3);
40865 wxPyEndAllowThreads(__tstate);
40866 if (PyErr_Occurred()) SWIG_fail;
40867 }
40868 resultobj = SWIG_Py_Void();
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40876 PyObject *resultobj = 0;
40877 wxWindow *arg1 = (wxWindow *) 0 ;
40878 wxSizer *result = 0 ;
40879 void *argp1 = 0 ;
40880 int res1 = 0 ;
40881 PyObject *swig_obj[1] ;
40882
40883 if (!args) SWIG_fail;
40884 swig_obj[0] = args;
40885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40886 if (!SWIG_IsOK(res1)) {
40887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40888 }
40889 arg1 = reinterpret_cast< wxWindow * >(argp1);
40890 {
40891 PyThreadState* __tstate = wxPyBeginAllowThreads();
40892 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40893 wxPyEndAllowThreads(__tstate);
40894 if (PyErr_Occurred()) SWIG_fail;
40895 }
40896 {
40897 resultobj = wxPyMake_wxObject(result, (bool)0);
40898 }
40899 return resultobj;
40900 fail:
40901 return NULL;
40902 }
40903
40904
40905 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40906 PyObject *resultobj = 0;
40907 wxWindow *arg1 = (wxWindow *) 0 ;
40908 wxSizer *arg2 = (wxSizer *) 0 ;
40909 void *argp1 = 0 ;
40910 int res1 = 0 ;
40911 void *argp2 = 0 ;
40912 int res2 = 0 ;
40913 PyObject * obj0 = 0 ;
40914 PyObject * obj1 = 0 ;
40915 char * kwnames[] = {
40916 (char *) "self",(char *) "sizer", NULL
40917 };
40918
40919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40921 if (!SWIG_IsOK(res1)) {
40922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40923 }
40924 arg1 = reinterpret_cast< wxWindow * >(argp1);
40925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40926 if (!SWIG_IsOK(res2)) {
40927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40928 }
40929 arg2 = reinterpret_cast< wxSizer * >(argp2);
40930 {
40931 PyThreadState* __tstate = wxPyBeginAllowThreads();
40932 (arg1)->SetContainingSizer(arg2);
40933 wxPyEndAllowThreads(__tstate);
40934 if (PyErr_Occurred()) SWIG_fail;
40935 }
40936 resultobj = SWIG_Py_Void();
40937 return resultobj;
40938 fail:
40939 return NULL;
40940 }
40941
40942
40943 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40944 PyObject *resultobj = 0;
40945 wxWindow *arg1 = (wxWindow *) 0 ;
40946 wxSizer *result = 0 ;
40947 void *argp1 = 0 ;
40948 int res1 = 0 ;
40949 PyObject *swig_obj[1] ;
40950
40951 if (!args) SWIG_fail;
40952 swig_obj[0] = args;
40953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40954 if (!SWIG_IsOK(res1)) {
40955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40956 }
40957 arg1 = reinterpret_cast< wxWindow * >(argp1);
40958 {
40959 PyThreadState* __tstate = wxPyBeginAllowThreads();
40960 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 {
40965 resultobj = wxPyMake_wxObject(result, (bool)0);
40966 }
40967 return resultobj;
40968 fail:
40969 return NULL;
40970 }
40971
40972
40973 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40974 PyObject *resultobj = 0;
40975 wxWindow *arg1 = (wxWindow *) 0 ;
40976 void *argp1 = 0 ;
40977 int res1 = 0 ;
40978 PyObject *swig_obj[1] ;
40979
40980 if (!args) SWIG_fail;
40981 swig_obj[0] = args;
40982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40983 if (!SWIG_IsOK(res1)) {
40984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40985 }
40986 arg1 = reinterpret_cast< wxWindow * >(argp1);
40987 {
40988 PyThreadState* __tstate = wxPyBeginAllowThreads();
40989 (arg1)->InheritAttributes();
40990 wxPyEndAllowThreads(__tstate);
40991 if (PyErr_Occurred()) SWIG_fail;
40992 }
40993 resultobj = SWIG_Py_Void();
40994 return resultobj;
40995 fail:
40996 return NULL;
40997 }
40998
40999
41000 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41001 PyObject *resultobj = 0;
41002 wxWindow *arg1 = (wxWindow *) 0 ;
41003 bool result;
41004 void *argp1 = 0 ;
41005 int res1 = 0 ;
41006 PyObject *swig_obj[1] ;
41007
41008 if (!args) SWIG_fail;
41009 swig_obj[0] = args;
41010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41011 if (!SWIG_IsOK(res1)) {
41012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41013 }
41014 arg1 = reinterpret_cast< wxWindow * >(argp1);
41015 {
41016 PyThreadState* __tstate = wxPyBeginAllowThreads();
41017 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41018 wxPyEndAllowThreads(__tstate);
41019 if (PyErr_Occurred()) SWIG_fail;
41020 }
41021 {
41022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41023 }
41024 return resultobj;
41025 fail:
41026 return NULL;
41027 }
41028
41029
41030 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41031 PyObject *resultobj = 0;
41032 wxWindow *arg1 = (wxWindow *) 0 ;
41033 bool result;
41034 void *argp1 = 0 ;
41035 int res1 = 0 ;
41036 PyObject *swig_obj[1] ;
41037
41038 if (!args) SWIG_fail;
41039 swig_obj[0] = args;
41040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41041 if (!SWIG_IsOK(res1)) {
41042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41043 }
41044 arg1 = reinterpret_cast< wxWindow * >(argp1);
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = (bool)(arg1)->CanSetTransparent();
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_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41061 PyObject *resultobj = 0;
41062 wxWindow *arg1 = (wxWindow *) 0 ;
41063 byte arg2 ;
41064 bool result;
41065 void *argp1 = 0 ;
41066 int res1 = 0 ;
41067 unsigned char val2 ;
41068 int ecode2 = 0 ;
41069 PyObject * obj0 = 0 ;
41070 PyObject * obj1 = 0 ;
41071 char * kwnames[] = {
41072 (char *) "self",(char *) "alpha", NULL
41073 };
41074
41075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41077 if (!SWIG_IsOK(res1)) {
41078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41079 }
41080 arg1 = reinterpret_cast< wxWindow * >(argp1);
41081 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41082 if (!SWIG_IsOK(ecode2)) {
41083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41084 }
41085 arg2 = static_cast< byte >(val2);
41086 {
41087 PyThreadState* __tstate = wxPyBeginAllowThreads();
41088 result = (bool)(arg1)->SetTransparent(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 *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41102 PyObject *obj;
41103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41104 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41105 return SWIG_Py_Void();
41106 }
41107
41108 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41109 return SWIG_Python_InitShadowInstance(args);
41110 }
41111
41112 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41113 PyObject *resultobj = 0;
41114 long arg1 ;
41115 wxWindow *arg2 = (wxWindow *) NULL ;
41116 wxWindow *result = 0 ;
41117 long val1 ;
41118 int ecode1 = 0 ;
41119 void *argp2 = 0 ;
41120 int res2 = 0 ;
41121 PyObject * obj0 = 0 ;
41122 PyObject * obj1 = 0 ;
41123 char * kwnames[] = {
41124 (char *) "id",(char *) "parent", NULL
41125 };
41126
41127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41128 ecode1 = SWIG_AsVal_long(obj0, &val1);
41129 if (!SWIG_IsOK(ecode1)) {
41130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41131 }
41132 arg1 = static_cast< long >(val1);
41133 if (obj1) {
41134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41135 if (!SWIG_IsOK(res2)) {
41136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41137 }
41138 arg2 = reinterpret_cast< wxWindow * >(argp2);
41139 }
41140 {
41141 if (!wxPyCheckForApp()) SWIG_fail;
41142 PyThreadState* __tstate = wxPyBeginAllowThreads();
41143 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41144 wxPyEndAllowThreads(__tstate);
41145 if (PyErr_Occurred()) SWIG_fail;
41146 }
41147 {
41148 resultobj = wxPyMake_wxObject(result, 0);
41149 }
41150 return resultobj;
41151 fail:
41152 return NULL;
41153 }
41154
41155
41156 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41157 PyObject *resultobj = 0;
41158 wxString *arg1 = 0 ;
41159 wxWindow *arg2 = (wxWindow *) NULL ;
41160 wxWindow *result = 0 ;
41161 bool temp1 = false ;
41162 void *argp2 = 0 ;
41163 int res2 = 0 ;
41164 PyObject * obj0 = 0 ;
41165 PyObject * obj1 = 0 ;
41166 char * kwnames[] = {
41167 (char *) "name",(char *) "parent", NULL
41168 };
41169
41170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41171 {
41172 arg1 = wxString_in_helper(obj0);
41173 if (arg1 == NULL) SWIG_fail;
41174 temp1 = true;
41175 }
41176 if (obj1) {
41177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41178 if (!SWIG_IsOK(res2)) {
41179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41180 }
41181 arg2 = reinterpret_cast< wxWindow * >(argp2);
41182 }
41183 {
41184 if (!wxPyCheckForApp()) SWIG_fail;
41185 PyThreadState* __tstate = wxPyBeginAllowThreads();
41186 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41187 wxPyEndAllowThreads(__tstate);
41188 if (PyErr_Occurred()) SWIG_fail;
41189 }
41190 {
41191 resultobj = wxPyMake_wxObject(result, 0);
41192 }
41193 {
41194 if (temp1)
41195 delete arg1;
41196 }
41197 return resultobj;
41198 fail:
41199 {
41200 if (temp1)
41201 delete arg1;
41202 }
41203 return NULL;
41204 }
41205
41206
41207 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41208 PyObject *resultobj = 0;
41209 wxString *arg1 = 0 ;
41210 wxWindow *arg2 = (wxWindow *) NULL ;
41211 wxWindow *result = 0 ;
41212 bool temp1 = false ;
41213 void *argp2 = 0 ;
41214 int res2 = 0 ;
41215 PyObject * obj0 = 0 ;
41216 PyObject * obj1 = 0 ;
41217 char * kwnames[] = {
41218 (char *) "label",(char *) "parent", NULL
41219 };
41220
41221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41222 {
41223 arg1 = wxString_in_helper(obj0);
41224 if (arg1 == NULL) SWIG_fail;
41225 temp1 = true;
41226 }
41227 if (obj1) {
41228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41229 if (!SWIG_IsOK(res2)) {
41230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41231 }
41232 arg2 = reinterpret_cast< wxWindow * >(argp2);
41233 }
41234 {
41235 if (!wxPyCheckForApp()) SWIG_fail;
41236 PyThreadState* __tstate = wxPyBeginAllowThreads();
41237 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41238 wxPyEndAllowThreads(__tstate);
41239 if (PyErr_Occurred()) SWIG_fail;
41240 }
41241 {
41242 resultobj = wxPyMake_wxObject(result, 0);
41243 }
41244 {
41245 if (temp1)
41246 delete arg1;
41247 }
41248 return resultobj;
41249 fail:
41250 {
41251 if (temp1)
41252 delete arg1;
41253 }
41254 return NULL;
41255 }
41256
41257
41258 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41259 PyObject *resultobj = 0;
41260 wxWindow *arg1 = (wxWindow *) 0 ;
41261 unsigned long arg2 ;
41262 wxWindow *result = 0 ;
41263 void *argp1 = 0 ;
41264 int res1 = 0 ;
41265 unsigned long val2 ;
41266 int ecode2 = 0 ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 char * kwnames[] = {
41270 (char *) "parent",(char *) "_hWnd", NULL
41271 };
41272
41273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41275 if (!SWIG_IsOK(res1)) {
41276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41277 }
41278 arg1 = reinterpret_cast< wxWindow * >(argp1);
41279 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41280 if (!SWIG_IsOK(ecode2)) {
41281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41282 }
41283 arg2 = static_cast< unsigned long >(val2);
41284 {
41285 PyThreadState* __tstate = wxPyBeginAllowThreads();
41286 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 {
41291 resultobj = wxPyMake_wxObject(result, 0);
41292 }
41293 return resultobj;
41294 fail:
41295 return NULL;
41296 }
41297
41298
41299 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41300 PyObject *resultobj = 0;
41301 PyObject *result = 0 ;
41302
41303 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41304 {
41305 PyThreadState* __tstate = wxPyBeginAllowThreads();
41306 result = (PyObject *)GetTopLevelWindows();
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 resultobj = result;
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41318 PyObject *resultobj = 0;
41319 wxValidator *result = 0 ;
41320
41321 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41322 {
41323 PyThreadState* __tstate = wxPyBeginAllowThreads();
41324 result = (wxValidator *)new wxValidator();
41325 wxPyEndAllowThreads(__tstate);
41326 if (PyErr_Occurred()) SWIG_fail;
41327 }
41328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41329 return resultobj;
41330 fail:
41331 return NULL;
41332 }
41333
41334
41335 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41336 PyObject *resultobj = 0;
41337 wxValidator *arg1 = (wxValidator *) 0 ;
41338 wxValidator *result = 0 ;
41339 void *argp1 = 0 ;
41340 int res1 = 0 ;
41341 PyObject *swig_obj[1] ;
41342
41343 if (!args) SWIG_fail;
41344 swig_obj[0] = args;
41345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41346 if (!SWIG_IsOK(res1)) {
41347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41348 }
41349 arg1 = reinterpret_cast< wxValidator * >(argp1);
41350 {
41351 PyThreadState* __tstate = wxPyBeginAllowThreads();
41352 result = (wxValidator *)(arg1)->Clone();
41353 wxPyEndAllowThreads(__tstate);
41354 if (PyErr_Occurred()) SWIG_fail;
41355 }
41356 {
41357 resultobj = wxPyMake_wxObject(result, 0);
41358 }
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj = 0;
41367 wxValidator *arg1 = (wxValidator *) 0 ;
41368 wxWindow *arg2 = (wxWindow *) 0 ;
41369 bool result;
41370 void *argp1 = 0 ;
41371 int res1 = 0 ;
41372 void *argp2 = 0 ;
41373 int res2 = 0 ;
41374 PyObject * obj0 = 0 ;
41375 PyObject * obj1 = 0 ;
41376 char * kwnames[] = {
41377 (char *) "self",(char *) "parent", NULL
41378 };
41379
41380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41382 if (!SWIG_IsOK(res1)) {
41383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41384 }
41385 arg1 = reinterpret_cast< wxValidator * >(argp1);
41386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41387 if (!SWIG_IsOK(res2)) {
41388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41389 }
41390 arg2 = reinterpret_cast< wxWindow * >(argp2);
41391 {
41392 PyThreadState* __tstate = wxPyBeginAllowThreads();
41393 result = (bool)(arg1)->Validate(arg2);
41394 wxPyEndAllowThreads(__tstate);
41395 if (PyErr_Occurred()) SWIG_fail;
41396 }
41397 {
41398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41399 }
41400 return resultobj;
41401 fail:
41402 return NULL;
41403 }
41404
41405
41406 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41407 PyObject *resultobj = 0;
41408 wxValidator *arg1 = (wxValidator *) 0 ;
41409 bool result;
41410 void *argp1 = 0 ;
41411 int res1 = 0 ;
41412 PyObject *swig_obj[1] ;
41413
41414 if (!args) SWIG_fail;
41415 swig_obj[0] = args;
41416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41417 if (!SWIG_IsOK(res1)) {
41418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41419 }
41420 arg1 = reinterpret_cast< wxValidator * >(argp1);
41421 {
41422 PyThreadState* __tstate = wxPyBeginAllowThreads();
41423 result = (bool)(arg1)->TransferToWindow();
41424 wxPyEndAllowThreads(__tstate);
41425 if (PyErr_Occurred()) SWIG_fail;
41426 }
41427 {
41428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41429 }
41430 return resultobj;
41431 fail:
41432 return NULL;
41433 }
41434
41435
41436 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41437 PyObject *resultobj = 0;
41438 wxValidator *arg1 = (wxValidator *) 0 ;
41439 bool result;
41440 void *argp1 = 0 ;
41441 int res1 = 0 ;
41442 PyObject *swig_obj[1] ;
41443
41444 if (!args) SWIG_fail;
41445 swig_obj[0] = args;
41446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41447 if (!SWIG_IsOK(res1)) {
41448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41449 }
41450 arg1 = reinterpret_cast< wxValidator * >(argp1);
41451 {
41452 PyThreadState* __tstate = wxPyBeginAllowThreads();
41453 result = (bool)(arg1)->TransferFromWindow();
41454 wxPyEndAllowThreads(__tstate);
41455 if (PyErr_Occurred()) SWIG_fail;
41456 }
41457 {
41458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41459 }
41460 return resultobj;
41461 fail:
41462 return NULL;
41463 }
41464
41465
41466 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41467 PyObject *resultobj = 0;
41468 wxValidator *arg1 = (wxValidator *) 0 ;
41469 wxWindow *result = 0 ;
41470 void *argp1 = 0 ;
41471 int res1 = 0 ;
41472 PyObject *swig_obj[1] ;
41473
41474 if (!args) SWIG_fail;
41475 swig_obj[0] = args;
41476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41477 if (!SWIG_IsOK(res1)) {
41478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41479 }
41480 arg1 = reinterpret_cast< wxValidator * >(argp1);
41481 {
41482 PyThreadState* __tstate = wxPyBeginAllowThreads();
41483 result = (wxWindow *)(arg1)->GetWindow();
41484 wxPyEndAllowThreads(__tstate);
41485 if (PyErr_Occurred()) SWIG_fail;
41486 }
41487 {
41488 resultobj = wxPyMake_wxObject(result, 0);
41489 }
41490 return resultobj;
41491 fail:
41492 return NULL;
41493 }
41494
41495
41496 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41497 PyObject *resultobj = 0;
41498 wxValidator *arg1 = (wxValidator *) 0 ;
41499 wxWindow *arg2 = (wxWindow *) 0 ;
41500 void *argp1 = 0 ;
41501 int res1 = 0 ;
41502 void *argp2 = 0 ;
41503 int res2 = 0 ;
41504 PyObject * obj0 = 0 ;
41505 PyObject * obj1 = 0 ;
41506 char * kwnames[] = {
41507 (char *) "self",(char *) "window", NULL
41508 };
41509
41510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41512 if (!SWIG_IsOK(res1)) {
41513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41514 }
41515 arg1 = reinterpret_cast< wxValidator * >(argp1);
41516 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41517 if (!SWIG_IsOK(res2)) {
41518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41519 }
41520 arg2 = reinterpret_cast< wxWindow * >(argp2);
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 (arg1)->SetWindow(arg2);
41524 wxPyEndAllowThreads(__tstate);
41525 if (PyErr_Occurred()) SWIG_fail;
41526 }
41527 resultobj = SWIG_Py_Void();
41528 return resultobj;
41529 fail:
41530 return NULL;
41531 }
41532
41533
41534 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41535 PyObject *resultobj = 0;
41536 bool result;
41537
41538 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41539 {
41540 PyThreadState* __tstate = wxPyBeginAllowThreads();
41541 result = (bool)wxValidator::IsSilent();
41542 wxPyEndAllowThreads(__tstate);
41543 if (PyErr_Occurred()) SWIG_fail;
41544 }
41545 {
41546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41547 }
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41555 PyObject *resultobj = 0;
41556 int arg1 = (int) true ;
41557 int val1 ;
41558 int ecode1 = 0 ;
41559 PyObject * obj0 = 0 ;
41560 char * kwnames[] = {
41561 (char *) "doIt", NULL
41562 };
41563
41564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41565 if (obj0) {
41566 ecode1 = SWIG_AsVal_int(obj0, &val1);
41567 if (!SWIG_IsOK(ecode1)) {
41568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41569 }
41570 arg1 = static_cast< int >(val1);
41571 }
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 wxValidator::SetBellOnError(arg1);
41575 wxPyEndAllowThreads(__tstate);
41576 if (PyErr_Occurred()) SWIG_fail;
41577 }
41578 resultobj = SWIG_Py_Void();
41579 return resultobj;
41580 fail:
41581 return NULL;
41582 }
41583
41584
41585 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41586 PyObject *obj;
41587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41588 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41589 return SWIG_Py_Void();
41590 }
41591
41592 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41593 return SWIG_Python_InitShadowInstance(args);
41594 }
41595
41596 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41597 PyObject *resultobj = 0;
41598 wxPyValidator *result = 0 ;
41599
41600 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41601 {
41602 PyThreadState* __tstate = wxPyBeginAllowThreads();
41603 result = (wxPyValidator *)new wxPyValidator();
41604 wxPyEndAllowThreads(__tstate);
41605 if (PyErr_Occurred()) SWIG_fail;
41606 }
41607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj = 0;
41616 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41617 PyObject *arg2 = (PyObject *) 0 ;
41618 PyObject *arg3 = (PyObject *) 0 ;
41619 int arg4 = (int) true ;
41620 void *argp1 = 0 ;
41621 int res1 = 0 ;
41622 int val4 ;
41623 int ecode4 = 0 ;
41624 PyObject * obj0 = 0 ;
41625 PyObject * obj1 = 0 ;
41626 PyObject * obj2 = 0 ;
41627 PyObject * obj3 = 0 ;
41628 char * kwnames[] = {
41629 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41630 };
41631
41632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41634 if (!SWIG_IsOK(res1)) {
41635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41636 }
41637 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41638 arg2 = obj1;
41639 arg3 = obj2;
41640 if (obj3) {
41641 ecode4 = SWIG_AsVal_int(obj3, &val4);
41642 if (!SWIG_IsOK(ecode4)) {
41643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41644 }
41645 arg4 = static_cast< int >(val4);
41646 }
41647 {
41648 PyThreadState* __tstate = wxPyBeginAllowThreads();
41649 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41650 wxPyEndAllowThreads(__tstate);
41651 if (PyErr_Occurred()) SWIG_fail;
41652 }
41653 resultobj = SWIG_Py_Void();
41654 return resultobj;
41655 fail:
41656 return NULL;
41657 }
41658
41659
41660 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41661 PyObject *obj;
41662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41663 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41664 return SWIG_Py_Void();
41665 }
41666
41667 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41668 return SWIG_Python_InitShadowInstance(args);
41669 }
41670
41671 SWIGINTERN int DefaultValidator_set(PyObject *) {
41672 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41673 return 1;
41674 }
41675
41676
41677 SWIGINTERN PyObject *DefaultValidator_get(void) {
41678 PyObject *pyobj = 0;
41679
41680 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41681 return pyobj;
41682 }
41683
41684
41685 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41686 PyObject *resultobj = 0;
41687 wxString const &arg1_defvalue = wxPyEmptyString ;
41688 wxString *arg1 = (wxString *) &arg1_defvalue ;
41689 long arg2 = (long) 0 ;
41690 wxMenu *result = 0 ;
41691 bool temp1 = false ;
41692 long val2 ;
41693 int ecode2 = 0 ;
41694 PyObject * obj0 = 0 ;
41695 PyObject * obj1 = 0 ;
41696 char * kwnames[] = {
41697 (char *) "title",(char *) "style", NULL
41698 };
41699
41700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41701 if (obj0) {
41702 {
41703 arg1 = wxString_in_helper(obj0);
41704 if (arg1 == NULL) SWIG_fail;
41705 temp1 = true;
41706 }
41707 }
41708 if (obj1) {
41709 ecode2 = SWIG_AsVal_long(obj1, &val2);
41710 if (!SWIG_IsOK(ecode2)) {
41711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41712 }
41713 arg2 = static_cast< long >(val2);
41714 }
41715 {
41716 if (!wxPyCheckForApp()) SWIG_fail;
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41719 wxPyEndAllowThreads(__tstate);
41720 if (PyErr_Occurred()) SWIG_fail;
41721 }
41722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41723 {
41724 if (temp1)
41725 delete arg1;
41726 }
41727 return resultobj;
41728 fail:
41729 {
41730 if (temp1)
41731 delete arg1;
41732 }
41733 return NULL;
41734 }
41735
41736
41737 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41738 PyObject *resultobj = 0;
41739 wxMenu *arg1 = (wxMenu *) 0 ;
41740 int arg2 ;
41741 wxString const &arg3_defvalue = wxPyEmptyString ;
41742 wxString *arg3 = (wxString *) &arg3_defvalue ;
41743 wxString const &arg4_defvalue = wxPyEmptyString ;
41744 wxString *arg4 = (wxString *) &arg4_defvalue ;
41745 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41746 wxMenuItem *result = 0 ;
41747 void *argp1 = 0 ;
41748 int res1 = 0 ;
41749 int val2 ;
41750 int ecode2 = 0 ;
41751 bool temp3 = false ;
41752 bool temp4 = false ;
41753 int val5 ;
41754 int ecode5 = 0 ;
41755 PyObject * obj0 = 0 ;
41756 PyObject * obj1 = 0 ;
41757 PyObject * obj2 = 0 ;
41758 PyObject * obj3 = 0 ;
41759 PyObject * obj4 = 0 ;
41760 char * kwnames[] = {
41761 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41762 };
41763
41764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41766 if (!SWIG_IsOK(res1)) {
41767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41768 }
41769 arg1 = reinterpret_cast< wxMenu * >(argp1);
41770 ecode2 = SWIG_AsVal_int(obj1, &val2);
41771 if (!SWIG_IsOK(ecode2)) {
41772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41773 }
41774 arg2 = static_cast< int >(val2);
41775 if (obj2) {
41776 {
41777 arg3 = wxString_in_helper(obj2);
41778 if (arg3 == NULL) SWIG_fail;
41779 temp3 = true;
41780 }
41781 }
41782 if (obj3) {
41783 {
41784 arg4 = wxString_in_helper(obj3);
41785 if (arg4 == NULL) SWIG_fail;
41786 temp4 = true;
41787 }
41788 }
41789 if (obj4) {
41790 ecode5 = SWIG_AsVal_int(obj4, &val5);
41791 if (!SWIG_IsOK(ecode5)) {
41792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41793 }
41794 arg5 = static_cast< wxItemKind >(val5);
41795 }
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41799 wxPyEndAllowThreads(__tstate);
41800 if (PyErr_Occurred()) SWIG_fail;
41801 }
41802 {
41803 resultobj = wxPyMake_wxObject(result, (bool)0);
41804 }
41805 {
41806 if (temp3)
41807 delete arg3;
41808 }
41809 {
41810 if (temp4)
41811 delete arg4;
41812 }
41813 return resultobj;
41814 fail:
41815 {
41816 if (temp3)
41817 delete arg3;
41818 }
41819 {
41820 if (temp4)
41821 delete arg4;
41822 }
41823 return NULL;
41824 }
41825
41826
41827 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41828 PyObject *resultobj = 0;
41829 wxMenu *arg1 = (wxMenu *) 0 ;
41830 wxMenuItem *result = 0 ;
41831 void *argp1 = 0 ;
41832 int res1 = 0 ;
41833 PyObject *swig_obj[1] ;
41834
41835 if (!args) SWIG_fail;
41836 swig_obj[0] = args;
41837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41838 if (!SWIG_IsOK(res1)) {
41839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41840 }
41841 arg1 = reinterpret_cast< wxMenu * >(argp1);
41842 {
41843 PyThreadState* __tstate = wxPyBeginAllowThreads();
41844 result = (wxMenuItem *)(arg1)->AppendSeparator();
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 {
41849 resultobj = wxPyMake_wxObject(result, (bool)0);
41850 }
41851 return resultobj;
41852 fail:
41853 return NULL;
41854 }
41855
41856
41857 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41858 PyObject *resultobj = 0;
41859 wxMenu *arg1 = (wxMenu *) 0 ;
41860 int arg2 ;
41861 wxString *arg3 = 0 ;
41862 wxString const &arg4_defvalue = wxPyEmptyString ;
41863 wxString *arg4 = (wxString *) &arg4_defvalue ;
41864 wxMenuItem *result = 0 ;
41865 void *argp1 = 0 ;
41866 int res1 = 0 ;
41867 int val2 ;
41868 int ecode2 = 0 ;
41869 bool temp3 = false ;
41870 bool temp4 = false ;
41871 PyObject * obj0 = 0 ;
41872 PyObject * obj1 = 0 ;
41873 PyObject * obj2 = 0 ;
41874 PyObject * obj3 = 0 ;
41875 char * kwnames[] = {
41876 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41877 };
41878
41879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41881 if (!SWIG_IsOK(res1)) {
41882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41883 }
41884 arg1 = reinterpret_cast< wxMenu * >(argp1);
41885 ecode2 = SWIG_AsVal_int(obj1, &val2);
41886 if (!SWIG_IsOK(ecode2)) {
41887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41888 }
41889 arg2 = static_cast< int >(val2);
41890 {
41891 arg3 = wxString_in_helper(obj2);
41892 if (arg3 == NULL) SWIG_fail;
41893 temp3 = true;
41894 }
41895 if (obj3) {
41896 {
41897 arg4 = wxString_in_helper(obj3);
41898 if (arg4 == NULL) SWIG_fail;
41899 temp4 = true;
41900 }
41901 }
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41905 wxPyEndAllowThreads(__tstate);
41906 if (PyErr_Occurred()) SWIG_fail;
41907 }
41908 {
41909 resultobj = wxPyMake_wxObject(result, (bool)0);
41910 }
41911 {
41912 if (temp3)
41913 delete arg3;
41914 }
41915 {
41916 if (temp4)
41917 delete arg4;
41918 }
41919 return resultobj;
41920 fail:
41921 {
41922 if (temp3)
41923 delete arg3;
41924 }
41925 {
41926 if (temp4)
41927 delete arg4;
41928 }
41929 return NULL;
41930 }
41931
41932
41933 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj = 0;
41935 wxMenu *arg1 = (wxMenu *) 0 ;
41936 int arg2 ;
41937 wxString *arg3 = 0 ;
41938 wxString const &arg4_defvalue = wxPyEmptyString ;
41939 wxString *arg4 = (wxString *) &arg4_defvalue ;
41940 wxMenuItem *result = 0 ;
41941 void *argp1 = 0 ;
41942 int res1 = 0 ;
41943 int val2 ;
41944 int ecode2 = 0 ;
41945 bool temp3 = false ;
41946 bool temp4 = false ;
41947 PyObject * obj0 = 0 ;
41948 PyObject * obj1 = 0 ;
41949 PyObject * obj2 = 0 ;
41950 PyObject * obj3 = 0 ;
41951 char * kwnames[] = {
41952 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41953 };
41954
41955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41957 if (!SWIG_IsOK(res1)) {
41958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41959 }
41960 arg1 = reinterpret_cast< wxMenu * >(argp1);
41961 ecode2 = SWIG_AsVal_int(obj1, &val2);
41962 if (!SWIG_IsOK(ecode2)) {
41963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41964 }
41965 arg2 = static_cast< int >(val2);
41966 {
41967 arg3 = wxString_in_helper(obj2);
41968 if (arg3 == NULL) SWIG_fail;
41969 temp3 = true;
41970 }
41971 if (obj3) {
41972 {
41973 arg4 = wxString_in_helper(obj3);
41974 if (arg4 == NULL) SWIG_fail;
41975 temp4 = true;
41976 }
41977 }
41978 {
41979 PyThreadState* __tstate = wxPyBeginAllowThreads();
41980 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41981 wxPyEndAllowThreads(__tstate);
41982 if (PyErr_Occurred()) SWIG_fail;
41983 }
41984 {
41985 resultobj = wxPyMake_wxObject(result, (bool)0);
41986 }
41987 {
41988 if (temp3)
41989 delete arg3;
41990 }
41991 {
41992 if (temp4)
41993 delete arg4;
41994 }
41995 return resultobj;
41996 fail:
41997 {
41998 if (temp3)
41999 delete arg3;
42000 }
42001 {
42002 if (temp4)
42003 delete arg4;
42004 }
42005 return NULL;
42006 }
42007
42008
42009 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42010 PyObject *resultobj = 0;
42011 wxMenu *arg1 = (wxMenu *) 0 ;
42012 int arg2 ;
42013 wxString *arg3 = 0 ;
42014 wxMenu *arg4 = (wxMenu *) 0 ;
42015 wxString const &arg5_defvalue = wxPyEmptyString ;
42016 wxString *arg5 = (wxString *) &arg5_defvalue ;
42017 wxMenuItem *result = 0 ;
42018 void *argp1 = 0 ;
42019 int res1 = 0 ;
42020 int val2 ;
42021 int ecode2 = 0 ;
42022 bool temp3 = false ;
42023 void *argp4 = 0 ;
42024 int res4 = 0 ;
42025 bool temp5 = false ;
42026 PyObject * obj0 = 0 ;
42027 PyObject * obj1 = 0 ;
42028 PyObject * obj2 = 0 ;
42029 PyObject * obj3 = 0 ;
42030 PyObject * obj4 = 0 ;
42031 char * kwnames[] = {
42032 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42033 };
42034
42035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42037 if (!SWIG_IsOK(res1)) {
42038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42039 }
42040 arg1 = reinterpret_cast< wxMenu * >(argp1);
42041 ecode2 = SWIG_AsVal_int(obj1, &val2);
42042 if (!SWIG_IsOK(ecode2)) {
42043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42044 }
42045 arg2 = static_cast< int >(val2);
42046 {
42047 arg3 = wxString_in_helper(obj2);
42048 if (arg3 == NULL) SWIG_fail;
42049 temp3 = true;
42050 }
42051 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42052 if (!SWIG_IsOK(res4)) {
42053 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42054 }
42055 arg4 = reinterpret_cast< wxMenu * >(argp4);
42056 if (obj4) {
42057 {
42058 arg5 = wxString_in_helper(obj4);
42059 if (arg5 == NULL) SWIG_fail;
42060 temp5 = true;
42061 }
42062 }
42063 {
42064 PyThreadState* __tstate = wxPyBeginAllowThreads();
42065 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42066 wxPyEndAllowThreads(__tstate);
42067 if (PyErr_Occurred()) SWIG_fail;
42068 }
42069 {
42070 resultobj = wxPyMake_wxObject(result, (bool)0);
42071 }
42072 {
42073 if (temp3)
42074 delete arg3;
42075 }
42076 {
42077 if (temp5)
42078 delete arg5;
42079 }
42080 return resultobj;
42081 fail:
42082 {
42083 if (temp3)
42084 delete arg3;
42085 }
42086 {
42087 if (temp5)
42088 delete arg5;
42089 }
42090 return NULL;
42091 }
42092
42093
42094 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42095 PyObject *resultobj = 0;
42096 wxMenu *arg1 = (wxMenu *) 0 ;
42097 wxMenu *arg2 = (wxMenu *) 0 ;
42098 wxString *arg3 = 0 ;
42099 wxString const &arg4_defvalue = wxPyEmptyString ;
42100 wxString *arg4 = (wxString *) &arg4_defvalue ;
42101 wxMenuItem *result = 0 ;
42102 void *argp1 = 0 ;
42103 int res1 = 0 ;
42104 void *argp2 = 0 ;
42105 int res2 = 0 ;
42106 bool temp3 = false ;
42107 bool temp4 = false ;
42108 PyObject * obj0 = 0 ;
42109 PyObject * obj1 = 0 ;
42110 PyObject * obj2 = 0 ;
42111 PyObject * obj3 = 0 ;
42112 char * kwnames[] = {
42113 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42114 };
42115
42116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42118 if (!SWIG_IsOK(res1)) {
42119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42120 }
42121 arg1 = reinterpret_cast< wxMenu * >(argp1);
42122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42123 if (!SWIG_IsOK(res2)) {
42124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42125 }
42126 arg2 = reinterpret_cast< wxMenu * >(argp2);
42127 {
42128 arg3 = wxString_in_helper(obj2);
42129 if (arg3 == NULL) SWIG_fail;
42130 temp3 = true;
42131 }
42132 if (obj3) {
42133 {
42134 arg4 = wxString_in_helper(obj3);
42135 if (arg4 == NULL) SWIG_fail;
42136 temp4 = true;
42137 }
42138 }
42139 {
42140 PyThreadState* __tstate = wxPyBeginAllowThreads();
42141 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42142 wxPyEndAllowThreads(__tstate);
42143 if (PyErr_Occurred()) SWIG_fail;
42144 }
42145 {
42146 resultobj = wxPyMake_wxObject(result, (bool)0);
42147 }
42148 {
42149 if (temp3)
42150 delete arg3;
42151 }
42152 {
42153 if (temp4)
42154 delete arg4;
42155 }
42156 return resultobj;
42157 fail:
42158 {
42159 if (temp3)
42160 delete arg3;
42161 }
42162 {
42163 if (temp4)
42164 delete arg4;
42165 }
42166 return NULL;
42167 }
42168
42169
42170 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj = 0;
42172 wxMenu *arg1 = (wxMenu *) 0 ;
42173 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42174 wxMenuItem *result = 0 ;
42175 void *argp1 = 0 ;
42176 int res1 = 0 ;
42177 int res2 = 0 ;
42178 PyObject * obj0 = 0 ;
42179 PyObject * obj1 = 0 ;
42180 char * kwnames[] = {
42181 (char *) "self",(char *) "item", NULL
42182 };
42183
42184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42186 if (!SWIG_IsOK(res1)) {
42187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42188 }
42189 arg1 = reinterpret_cast< wxMenu * >(argp1);
42190 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42191 if (!SWIG_IsOK(res2)) {
42192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42193 }
42194 {
42195 PyThreadState* __tstate = wxPyBeginAllowThreads();
42196 result = (wxMenuItem *)(arg1)->Append(arg2);
42197 wxPyEndAllowThreads(__tstate);
42198 if (PyErr_Occurred()) SWIG_fail;
42199 }
42200 {
42201 resultobj = wxPyMake_wxObject(result, (bool)0);
42202 }
42203 return resultobj;
42204 fail:
42205 return NULL;
42206 }
42207
42208
42209 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42210 PyObject *resultobj = 0;
42211 wxMenu *arg1 = (wxMenu *) 0 ;
42212 size_t arg2 ;
42213 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42214 wxMenuItem *result = 0 ;
42215 void *argp1 = 0 ;
42216 int res1 = 0 ;
42217 size_t val2 ;
42218 int ecode2 = 0 ;
42219 int res3 = 0 ;
42220 PyObject * obj0 = 0 ;
42221 PyObject * obj1 = 0 ;
42222 PyObject * obj2 = 0 ;
42223 char * kwnames[] = {
42224 (char *) "self",(char *) "pos",(char *) "item", NULL
42225 };
42226
42227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42229 if (!SWIG_IsOK(res1)) {
42230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42231 }
42232 arg1 = reinterpret_cast< wxMenu * >(argp1);
42233 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42234 if (!SWIG_IsOK(ecode2)) {
42235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42236 }
42237 arg2 = static_cast< size_t >(val2);
42238 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42239 if (!SWIG_IsOK(res3)) {
42240 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42241 }
42242 {
42243 PyThreadState* __tstate = wxPyBeginAllowThreads();
42244 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42245 wxPyEndAllowThreads(__tstate);
42246 if (PyErr_Occurred()) SWIG_fail;
42247 }
42248 {
42249 resultobj = wxPyMake_wxObject(result, (bool)0);
42250 }
42251 return resultobj;
42252 fail:
42253 return NULL;
42254 }
42255
42256
42257 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42258 PyObject *resultobj = 0;
42259 wxMenu *arg1 = (wxMenu *) 0 ;
42260 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42261 wxMenuItem *result = 0 ;
42262 void *argp1 = 0 ;
42263 int res1 = 0 ;
42264 int res2 = 0 ;
42265 PyObject * obj0 = 0 ;
42266 PyObject * obj1 = 0 ;
42267 char * kwnames[] = {
42268 (char *) "self",(char *) "item", NULL
42269 };
42270
42271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42273 if (!SWIG_IsOK(res1)) {
42274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42275 }
42276 arg1 = reinterpret_cast< wxMenu * >(argp1);
42277 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42278 if (!SWIG_IsOK(res2)) {
42279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42280 }
42281 {
42282 PyThreadState* __tstate = wxPyBeginAllowThreads();
42283 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42284 wxPyEndAllowThreads(__tstate);
42285 if (PyErr_Occurred()) SWIG_fail;
42286 }
42287 {
42288 resultobj = wxPyMake_wxObject(result, (bool)0);
42289 }
42290 return resultobj;
42291 fail:
42292 return NULL;
42293 }
42294
42295
42296 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42297 PyObject *resultobj = 0;
42298 wxMenu *arg1 = (wxMenu *) 0 ;
42299 void *argp1 = 0 ;
42300 int res1 = 0 ;
42301 PyObject *swig_obj[1] ;
42302
42303 if (!args) SWIG_fail;
42304 swig_obj[0] = args;
42305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42306 if (!SWIG_IsOK(res1)) {
42307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42308 }
42309 arg1 = reinterpret_cast< wxMenu * >(argp1);
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 (arg1)->Break();
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 resultobj = SWIG_Py_Void();
42317 return resultobj;
42318 fail:
42319 return NULL;
42320 }
42321
42322
42323 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42324 PyObject *resultobj = 0;
42325 wxMenu *arg1 = (wxMenu *) 0 ;
42326 size_t arg2 ;
42327 int arg3 ;
42328 wxString const &arg4_defvalue = wxPyEmptyString ;
42329 wxString *arg4 = (wxString *) &arg4_defvalue ;
42330 wxString const &arg5_defvalue = wxPyEmptyString ;
42331 wxString *arg5 = (wxString *) &arg5_defvalue ;
42332 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42333 wxMenuItem *result = 0 ;
42334 void *argp1 = 0 ;
42335 int res1 = 0 ;
42336 size_t val2 ;
42337 int ecode2 = 0 ;
42338 int val3 ;
42339 int ecode3 = 0 ;
42340 bool temp4 = false ;
42341 bool temp5 = false ;
42342 int val6 ;
42343 int ecode6 = 0 ;
42344 PyObject * obj0 = 0 ;
42345 PyObject * obj1 = 0 ;
42346 PyObject * obj2 = 0 ;
42347 PyObject * obj3 = 0 ;
42348 PyObject * obj4 = 0 ;
42349 PyObject * obj5 = 0 ;
42350 char * kwnames[] = {
42351 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42352 };
42353
42354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42356 if (!SWIG_IsOK(res1)) {
42357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42358 }
42359 arg1 = reinterpret_cast< wxMenu * >(argp1);
42360 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42361 if (!SWIG_IsOK(ecode2)) {
42362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42363 }
42364 arg2 = static_cast< size_t >(val2);
42365 ecode3 = SWIG_AsVal_int(obj2, &val3);
42366 if (!SWIG_IsOK(ecode3)) {
42367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42368 }
42369 arg3 = static_cast< int >(val3);
42370 if (obj3) {
42371 {
42372 arg4 = wxString_in_helper(obj3);
42373 if (arg4 == NULL) SWIG_fail;
42374 temp4 = true;
42375 }
42376 }
42377 if (obj4) {
42378 {
42379 arg5 = wxString_in_helper(obj4);
42380 if (arg5 == NULL) SWIG_fail;
42381 temp5 = true;
42382 }
42383 }
42384 if (obj5) {
42385 ecode6 = SWIG_AsVal_int(obj5, &val6);
42386 if (!SWIG_IsOK(ecode6)) {
42387 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42388 }
42389 arg6 = static_cast< wxItemKind >(val6);
42390 }
42391 {
42392 PyThreadState* __tstate = wxPyBeginAllowThreads();
42393 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42394 wxPyEndAllowThreads(__tstate);
42395 if (PyErr_Occurred()) SWIG_fail;
42396 }
42397 {
42398 resultobj = wxPyMake_wxObject(result, (bool)0);
42399 }
42400 {
42401 if (temp4)
42402 delete arg4;
42403 }
42404 {
42405 if (temp5)
42406 delete arg5;
42407 }
42408 return resultobj;
42409 fail:
42410 {
42411 if (temp4)
42412 delete arg4;
42413 }
42414 {
42415 if (temp5)
42416 delete arg5;
42417 }
42418 return NULL;
42419 }
42420
42421
42422 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42423 PyObject *resultobj = 0;
42424 wxMenu *arg1 = (wxMenu *) 0 ;
42425 size_t arg2 ;
42426 wxMenuItem *result = 0 ;
42427 void *argp1 = 0 ;
42428 int res1 = 0 ;
42429 size_t val2 ;
42430 int ecode2 = 0 ;
42431 PyObject * obj0 = 0 ;
42432 PyObject * obj1 = 0 ;
42433 char * kwnames[] = {
42434 (char *) "self",(char *) "pos", NULL
42435 };
42436
42437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42439 if (!SWIG_IsOK(res1)) {
42440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42441 }
42442 arg1 = reinterpret_cast< wxMenu * >(argp1);
42443 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42444 if (!SWIG_IsOK(ecode2)) {
42445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42446 }
42447 arg2 = static_cast< size_t >(val2);
42448 {
42449 PyThreadState* __tstate = wxPyBeginAllowThreads();
42450 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42451 wxPyEndAllowThreads(__tstate);
42452 if (PyErr_Occurred()) SWIG_fail;
42453 }
42454 {
42455 resultobj = wxPyMake_wxObject(result, (bool)0);
42456 }
42457 return resultobj;
42458 fail:
42459 return NULL;
42460 }
42461
42462
42463 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42464 PyObject *resultobj = 0;
42465 wxMenu *arg1 = (wxMenu *) 0 ;
42466 size_t arg2 ;
42467 int arg3 ;
42468 wxString *arg4 = 0 ;
42469 wxString const &arg5_defvalue = wxPyEmptyString ;
42470 wxString *arg5 = (wxString *) &arg5_defvalue ;
42471 wxMenuItem *result = 0 ;
42472 void *argp1 = 0 ;
42473 int res1 = 0 ;
42474 size_t val2 ;
42475 int ecode2 = 0 ;
42476 int val3 ;
42477 int ecode3 = 0 ;
42478 bool temp4 = false ;
42479 bool temp5 = false ;
42480 PyObject * obj0 = 0 ;
42481 PyObject * obj1 = 0 ;
42482 PyObject * obj2 = 0 ;
42483 PyObject * obj3 = 0 ;
42484 PyObject * obj4 = 0 ;
42485 char * kwnames[] = {
42486 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42487 };
42488
42489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42491 if (!SWIG_IsOK(res1)) {
42492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42493 }
42494 arg1 = reinterpret_cast< wxMenu * >(argp1);
42495 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42496 if (!SWIG_IsOK(ecode2)) {
42497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42498 }
42499 arg2 = static_cast< size_t >(val2);
42500 ecode3 = SWIG_AsVal_int(obj2, &val3);
42501 if (!SWIG_IsOK(ecode3)) {
42502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42503 }
42504 arg3 = static_cast< int >(val3);
42505 {
42506 arg4 = wxString_in_helper(obj3);
42507 if (arg4 == NULL) SWIG_fail;
42508 temp4 = true;
42509 }
42510 if (obj4) {
42511 {
42512 arg5 = wxString_in_helper(obj4);
42513 if (arg5 == NULL) SWIG_fail;
42514 temp5 = true;
42515 }
42516 }
42517 {
42518 PyThreadState* __tstate = wxPyBeginAllowThreads();
42519 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42520 wxPyEndAllowThreads(__tstate);
42521 if (PyErr_Occurred()) SWIG_fail;
42522 }
42523 {
42524 resultobj = wxPyMake_wxObject(result, (bool)0);
42525 }
42526 {
42527 if (temp4)
42528 delete arg4;
42529 }
42530 {
42531 if (temp5)
42532 delete arg5;
42533 }
42534 return resultobj;
42535 fail:
42536 {
42537 if (temp4)
42538 delete arg4;
42539 }
42540 {
42541 if (temp5)
42542 delete arg5;
42543 }
42544 return NULL;
42545 }
42546
42547
42548 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42549 PyObject *resultobj = 0;
42550 wxMenu *arg1 = (wxMenu *) 0 ;
42551 size_t arg2 ;
42552 int arg3 ;
42553 wxString *arg4 = 0 ;
42554 wxString const &arg5_defvalue = wxPyEmptyString ;
42555 wxString *arg5 = (wxString *) &arg5_defvalue ;
42556 wxMenuItem *result = 0 ;
42557 void *argp1 = 0 ;
42558 int res1 = 0 ;
42559 size_t val2 ;
42560 int ecode2 = 0 ;
42561 int val3 ;
42562 int ecode3 = 0 ;
42563 bool temp4 = false ;
42564 bool temp5 = false ;
42565 PyObject * obj0 = 0 ;
42566 PyObject * obj1 = 0 ;
42567 PyObject * obj2 = 0 ;
42568 PyObject * obj3 = 0 ;
42569 PyObject * obj4 = 0 ;
42570 char * kwnames[] = {
42571 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42572 };
42573
42574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42576 if (!SWIG_IsOK(res1)) {
42577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42578 }
42579 arg1 = reinterpret_cast< wxMenu * >(argp1);
42580 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42581 if (!SWIG_IsOK(ecode2)) {
42582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42583 }
42584 arg2 = static_cast< size_t >(val2);
42585 ecode3 = SWIG_AsVal_int(obj2, &val3);
42586 if (!SWIG_IsOK(ecode3)) {
42587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42588 }
42589 arg3 = static_cast< int >(val3);
42590 {
42591 arg4 = wxString_in_helper(obj3);
42592 if (arg4 == NULL) SWIG_fail;
42593 temp4 = true;
42594 }
42595 if (obj4) {
42596 {
42597 arg5 = wxString_in_helper(obj4);
42598 if (arg5 == NULL) SWIG_fail;
42599 temp5 = true;
42600 }
42601 }
42602 {
42603 PyThreadState* __tstate = wxPyBeginAllowThreads();
42604 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42605 wxPyEndAllowThreads(__tstate);
42606 if (PyErr_Occurred()) SWIG_fail;
42607 }
42608 {
42609 resultobj = wxPyMake_wxObject(result, (bool)0);
42610 }
42611 {
42612 if (temp4)
42613 delete arg4;
42614 }
42615 {
42616 if (temp5)
42617 delete arg5;
42618 }
42619 return resultobj;
42620 fail:
42621 {
42622 if (temp4)
42623 delete arg4;
42624 }
42625 {
42626 if (temp5)
42627 delete arg5;
42628 }
42629 return NULL;
42630 }
42631
42632
42633 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42634 PyObject *resultobj = 0;
42635 wxMenu *arg1 = (wxMenu *) 0 ;
42636 size_t arg2 ;
42637 int arg3 ;
42638 wxString *arg4 = 0 ;
42639 wxMenu *arg5 = (wxMenu *) 0 ;
42640 wxString const &arg6_defvalue = wxPyEmptyString ;
42641 wxString *arg6 = (wxString *) &arg6_defvalue ;
42642 wxMenuItem *result = 0 ;
42643 void *argp1 = 0 ;
42644 int res1 = 0 ;
42645 size_t val2 ;
42646 int ecode2 = 0 ;
42647 int val3 ;
42648 int ecode3 = 0 ;
42649 bool temp4 = false ;
42650 void *argp5 = 0 ;
42651 int res5 = 0 ;
42652 bool temp6 = false ;
42653 PyObject * obj0 = 0 ;
42654 PyObject * obj1 = 0 ;
42655 PyObject * obj2 = 0 ;
42656 PyObject * obj3 = 0 ;
42657 PyObject * obj4 = 0 ;
42658 PyObject * obj5 = 0 ;
42659 char * kwnames[] = {
42660 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42661 };
42662
42663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42665 if (!SWIG_IsOK(res1)) {
42666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42667 }
42668 arg1 = reinterpret_cast< wxMenu * >(argp1);
42669 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42670 if (!SWIG_IsOK(ecode2)) {
42671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42672 }
42673 arg2 = static_cast< size_t >(val2);
42674 ecode3 = SWIG_AsVal_int(obj2, &val3);
42675 if (!SWIG_IsOK(ecode3)) {
42676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42677 }
42678 arg3 = static_cast< int >(val3);
42679 {
42680 arg4 = wxString_in_helper(obj3);
42681 if (arg4 == NULL) SWIG_fail;
42682 temp4 = true;
42683 }
42684 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42685 if (!SWIG_IsOK(res5)) {
42686 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42687 }
42688 arg5 = reinterpret_cast< wxMenu * >(argp5);
42689 if (obj5) {
42690 {
42691 arg6 = wxString_in_helper(obj5);
42692 if (arg6 == NULL) SWIG_fail;
42693 temp6 = true;
42694 }
42695 }
42696 {
42697 PyThreadState* __tstate = wxPyBeginAllowThreads();
42698 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42699 wxPyEndAllowThreads(__tstate);
42700 if (PyErr_Occurred()) SWIG_fail;
42701 }
42702 {
42703 resultobj = wxPyMake_wxObject(result, (bool)0);
42704 }
42705 {
42706 if (temp4)
42707 delete arg4;
42708 }
42709 {
42710 if (temp6)
42711 delete arg6;
42712 }
42713 return resultobj;
42714 fail:
42715 {
42716 if (temp4)
42717 delete arg4;
42718 }
42719 {
42720 if (temp6)
42721 delete arg6;
42722 }
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42728 PyObject *resultobj = 0;
42729 wxMenu *arg1 = (wxMenu *) 0 ;
42730 int arg2 ;
42731 wxString const &arg3_defvalue = wxPyEmptyString ;
42732 wxString *arg3 = (wxString *) &arg3_defvalue ;
42733 wxString const &arg4_defvalue = wxPyEmptyString ;
42734 wxString *arg4 = (wxString *) &arg4_defvalue ;
42735 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42736 wxMenuItem *result = 0 ;
42737 void *argp1 = 0 ;
42738 int res1 = 0 ;
42739 int val2 ;
42740 int ecode2 = 0 ;
42741 bool temp3 = false ;
42742 bool temp4 = false ;
42743 int val5 ;
42744 int ecode5 = 0 ;
42745 PyObject * obj0 = 0 ;
42746 PyObject * obj1 = 0 ;
42747 PyObject * obj2 = 0 ;
42748 PyObject * obj3 = 0 ;
42749 PyObject * obj4 = 0 ;
42750 char * kwnames[] = {
42751 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42752 };
42753
42754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42756 if (!SWIG_IsOK(res1)) {
42757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42758 }
42759 arg1 = reinterpret_cast< wxMenu * >(argp1);
42760 ecode2 = SWIG_AsVal_int(obj1, &val2);
42761 if (!SWIG_IsOK(ecode2)) {
42762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42763 }
42764 arg2 = static_cast< int >(val2);
42765 if (obj2) {
42766 {
42767 arg3 = wxString_in_helper(obj2);
42768 if (arg3 == NULL) SWIG_fail;
42769 temp3 = true;
42770 }
42771 }
42772 if (obj3) {
42773 {
42774 arg4 = wxString_in_helper(obj3);
42775 if (arg4 == NULL) SWIG_fail;
42776 temp4 = true;
42777 }
42778 }
42779 if (obj4) {
42780 ecode5 = SWIG_AsVal_int(obj4, &val5);
42781 if (!SWIG_IsOK(ecode5)) {
42782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42783 }
42784 arg5 = static_cast< wxItemKind >(val5);
42785 }
42786 {
42787 PyThreadState* __tstate = wxPyBeginAllowThreads();
42788 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42789 wxPyEndAllowThreads(__tstate);
42790 if (PyErr_Occurred()) SWIG_fail;
42791 }
42792 {
42793 resultobj = wxPyMake_wxObject(result, (bool)0);
42794 }
42795 {
42796 if (temp3)
42797 delete arg3;
42798 }
42799 {
42800 if (temp4)
42801 delete arg4;
42802 }
42803 return resultobj;
42804 fail:
42805 {
42806 if (temp3)
42807 delete arg3;
42808 }
42809 {
42810 if (temp4)
42811 delete arg4;
42812 }
42813 return NULL;
42814 }
42815
42816
42817 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42818 PyObject *resultobj = 0;
42819 wxMenu *arg1 = (wxMenu *) 0 ;
42820 wxMenuItem *result = 0 ;
42821 void *argp1 = 0 ;
42822 int res1 = 0 ;
42823 PyObject *swig_obj[1] ;
42824
42825 if (!args) SWIG_fail;
42826 swig_obj[0] = args;
42827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42828 if (!SWIG_IsOK(res1)) {
42829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42830 }
42831 arg1 = reinterpret_cast< wxMenu * >(argp1);
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 result = (wxMenuItem *)(arg1)->PrependSeparator();
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 {
42839 resultobj = wxPyMake_wxObject(result, (bool)0);
42840 }
42841 return resultobj;
42842 fail:
42843 return NULL;
42844 }
42845
42846
42847 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42848 PyObject *resultobj = 0;
42849 wxMenu *arg1 = (wxMenu *) 0 ;
42850 int arg2 ;
42851 wxString *arg3 = 0 ;
42852 wxString const &arg4_defvalue = wxPyEmptyString ;
42853 wxString *arg4 = (wxString *) &arg4_defvalue ;
42854 wxMenuItem *result = 0 ;
42855 void *argp1 = 0 ;
42856 int res1 = 0 ;
42857 int val2 ;
42858 int ecode2 = 0 ;
42859 bool temp3 = false ;
42860 bool temp4 = false ;
42861 PyObject * obj0 = 0 ;
42862 PyObject * obj1 = 0 ;
42863 PyObject * obj2 = 0 ;
42864 PyObject * obj3 = 0 ;
42865 char * kwnames[] = {
42866 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42867 };
42868
42869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42871 if (!SWIG_IsOK(res1)) {
42872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42873 }
42874 arg1 = reinterpret_cast< wxMenu * >(argp1);
42875 ecode2 = SWIG_AsVal_int(obj1, &val2);
42876 if (!SWIG_IsOK(ecode2)) {
42877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42878 }
42879 arg2 = static_cast< int >(val2);
42880 {
42881 arg3 = wxString_in_helper(obj2);
42882 if (arg3 == NULL) SWIG_fail;
42883 temp3 = true;
42884 }
42885 if (obj3) {
42886 {
42887 arg4 = wxString_in_helper(obj3);
42888 if (arg4 == NULL) SWIG_fail;
42889 temp4 = true;
42890 }
42891 }
42892 {
42893 PyThreadState* __tstate = wxPyBeginAllowThreads();
42894 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42895 wxPyEndAllowThreads(__tstate);
42896 if (PyErr_Occurred()) SWIG_fail;
42897 }
42898 {
42899 resultobj = wxPyMake_wxObject(result, (bool)0);
42900 }
42901 {
42902 if (temp3)
42903 delete arg3;
42904 }
42905 {
42906 if (temp4)
42907 delete arg4;
42908 }
42909 return resultobj;
42910 fail:
42911 {
42912 if (temp3)
42913 delete arg3;
42914 }
42915 {
42916 if (temp4)
42917 delete arg4;
42918 }
42919 return NULL;
42920 }
42921
42922
42923 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42924 PyObject *resultobj = 0;
42925 wxMenu *arg1 = (wxMenu *) 0 ;
42926 int arg2 ;
42927 wxString *arg3 = 0 ;
42928 wxString const &arg4_defvalue = wxPyEmptyString ;
42929 wxString *arg4 = (wxString *) &arg4_defvalue ;
42930 wxMenuItem *result = 0 ;
42931 void *argp1 = 0 ;
42932 int res1 = 0 ;
42933 int val2 ;
42934 int ecode2 = 0 ;
42935 bool temp3 = false ;
42936 bool temp4 = false ;
42937 PyObject * obj0 = 0 ;
42938 PyObject * obj1 = 0 ;
42939 PyObject * obj2 = 0 ;
42940 PyObject * obj3 = 0 ;
42941 char * kwnames[] = {
42942 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42943 };
42944
42945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42947 if (!SWIG_IsOK(res1)) {
42948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42949 }
42950 arg1 = reinterpret_cast< wxMenu * >(argp1);
42951 ecode2 = SWIG_AsVal_int(obj1, &val2);
42952 if (!SWIG_IsOK(ecode2)) {
42953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42954 }
42955 arg2 = static_cast< int >(val2);
42956 {
42957 arg3 = wxString_in_helper(obj2);
42958 if (arg3 == NULL) SWIG_fail;
42959 temp3 = true;
42960 }
42961 if (obj3) {
42962 {
42963 arg4 = wxString_in_helper(obj3);
42964 if (arg4 == NULL) SWIG_fail;
42965 temp4 = true;
42966 }
42967 }
42968 {
42969 PyThreadState* __tstate = wxPyBeginAllowThreads();
42970 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42971 wxPyEndAllowThreads(__tstate);
42972 if (PyErr_Occurred()) SWIG_fail;
42973 }
42974 {
42975 resultobj = wxPyMake_wxObject(result, (bool)0);
42976 }
42977 {
42978 if (temp3)
42979 delete arg3;
42980 }
42981 {
42982 if (temp4)
42983 delete arg4;
42984 }
42985 return resultobj;
42986 fail:
42987 {
42988 if (temp3)
42989 delete arg3;
42990 }
42991 {
42992 if (temp4)
42993 delete arg4;
42994 }
42995 return NULL;
42996 }
42997
42998
42999 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43000 PyObject *resultobj = 0;
43001 wxMenu *arg1 = (wxMenu *) 0 ;
43002 int arg2 ;
43003 wxString *arg3 = 0 ;
43004 wxMenu *arg4 = (wxMenu *) 0 ;
43005 wxString const &arg5_defvalue = wxPyEmptyString ;
43006 wxString *arg5 = (wxString *) &arg5_defvalue ;
43007 wxMenuItem *result = 0 ;
43008 void *argp1 = 0 ;
43009 int res1 = 0 ;
43010 int val2 ;
43011 int ecode2 = 0 ;
43012 bool temp3 = false ;
43013 void *argp4 = 0 ;
43014 int res4 = 0 ;
43015 bool temp5 = false ;
43016 PyObject * obj0 = 0 ;
43017 PyObject * obj1 = 0 ;
43018 PyObject * obj2 = 0 ;
43019 PyObject * obj3 = 0 ;
43020 PyObject * obj4 = 0 ;
43021 char * kwnames[] = {
43022 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43023 };
43024
43025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43027 if (!SWIG_IsOK(res1)) {
43028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43029 }
43030 arg1 = reinterpret_cast< wxMenu * >(argp1);
43031 ecode2 = SWIG_AsVal_int(obj1, &val2);
43032 if (!SWIG_IsOK(ecode2)) {
43033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43034 }
43035 arg2 = static_cast< int >(val2);
43036 {
43037 arg3 = wxString_in_helper(obj2);
43038 if (arg3 == NULL) SWIG_fail;
43039 temp3 = true;
43040 }
43041 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43042 if (!SWIG_IsOK(res4)) {
43043 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43044 }
43045 arg4 = reinterpret_cast< wxMenu * >(argp4);
43046 if (obj4) {
43047 {
43048 arg5 = wxString_in_helper(obj4);
43049 if (arg5 == NULL) SWIG_fail;
43050 temp5 = true;
43051 }
43052 }
43053 {
43054 PyThreadState* __tstate = wxPyBeginAllowThreads();
43055 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43056 wxPyEndAllowThreads(__tstate);
43057 if (PyErr_Occurred()) SWIG_fail;
43058 }
43059 {
43060 resultobj = wxPyMake_wxObject(result, (bool)0);
43061 }
43062 {
43063 if (temp3)
43064 delete arg3;
43065 }
43066 {
43067 if (temp5)
43068 delete arg5;
43069 }
43070 return resultobj;
43071 fail:
43072 {
43073 if (temp3)
43074 delete arg3;
43075 }
43076 {
43077 if (temp5)
43078 delete arg5;
43079 }
43080 return NULL;
43081 }
43082
43083
43084 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43085 PyObject *resultobj = 0;
43086 wxMenu *arg1 = (wxMenu *) 0 ;
43087 int arg2 ;
43088 wxMenuItem *result = 0 ;
43089 void *argp1 = 0 ;
43090 int res1 = 0 ;
43091 int val2 ;
43092 int ecode2 = 0 ;
43093 PyObject * obj0 = 0 ;
43094 PyObject * obj1 = 0 ;
43095 char * kwnames[] = {
43096 (char *) "self",(char *) "id", NULL
43097 };
43098
43099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43101 if (!SWIG_IsOK(res1)) {
43102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43103 }
43104 arg1 = reinterpret_cast< wxMenu * >(argp1);
43105 ecode2 = SWIG_AsVal_int(obj1, &val2);
43106 if (!SWIG_IsOK(ecode2)) {
43107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43108 }
43109 arg2 = static_cast< int >(val2);
43110 {
43111 PyThreadState* __tstate = wxPyBeginAllowThreads();
43112 result = (wxMenuItem *)(arg1)->Remove(arg2);
43113 wxPyEndAllowThreads(__tstate);
43114 if (PyErr_Occurred()) SWIG_fail;
43115 }
43116 {
43117 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43118 }
43119 return resultobj;
43120 fail:
43121 return NULL;
43122 }
43123
43124
43125 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43126 PyObject *resultobj = 0;
43127 wxMenu *arg1 = (wxMenu *) 0 ;
43128 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43129 wxMenuItem *result = 0 ;
43130 void *argp1 = 0 ;
43131 int res1 = 0 ;
43132 void *argp2 = 0 ;
43133 int res2 = 0 ;
43134 PyObject * obj0 = 0 ;
43135 PyObject * obj1 = 0 ;
43136 char * kwnames[] = {
43137 (char *) "self",(char *) "item", NULL
43138 };
43139
43140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43142 if (!SWIG_IsOK(res1)) {
43143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43144 }
43145 arg1 = reinterpret_cast< wxMenu * >(argp1);
43146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43147 if (!SWIG_IsOK(res2)) {
43148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43149 }
43150 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43151 {
43152 PyThreadState* __tstate = wxPyBeginAllowThreads();
43153 result = (wxMenuItem *)(arg1)->Remove(arg2);
43154 wxPyEndAllowThreads(__tstate);
43155 if (PyErr_Occurred()) SWIG_fail;
43156 }
43157 {
43158 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43159 }
43160 return resultobj;
43161 fail:
43162 return NULL;
43163 }
43164
43165
43166 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43167 PyObject *resultobj = 0;
43168 wxMenu *arg1 = (wxMenu *) 0 ;
43169 int arg2 ;
43170 bool result;
43171 void *argp1 = 0 ;
43172 int res1 = 0 ;
43173 int val2 ;
43174 int ecode2 = 0 ;
43175 PyObject * obj0 = 0 ;
43176 PyObject * obj1 = 0 ;
43177 char * kwnames[] = {
43178 (char *) "self",(char *) "id", NULL
43179 };
43180
43181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43183 if (!SWIG_IsOK(res1)) {
43184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43185 }
43186 arg1 = reinterpret_cast< wxMenu * >(argp1);
43187 ecode2 = SWIG_AsVal_int(obj1, &val2);
43188 if (!SWIG_IsOK(ecode2)) {
43189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43190 }
43191 arg2 = static_cast< int >(val2);
43192 {
43193 PyThreadState* __tstate = wxPyBeginAllowThreads();
43194 result = (bool)(arg1)->Delete(arg2);
43195 wxPyEndAllowThreads(__tstate);
43196 if (PyErr_Occurred()) SWIG_fail;
43197 }
43198 {
43199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43200 }
43201 return resultobj;
43202 fail:
43203 return NULL;
43204 }
43205
43206
43207 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43208 PyObject *resultobj = 0;
43209 wxMenu *arg1 = (wxMenu *) 0 ;
43210 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43211 bool result;
43212 void *argp1 = 0 ;
43213 int res1 = 0 ;
43214 void *argp2 = 0 ;
43215 int res2 = 0 ;
43216 PyObject * obj0 = 0 ;
43217 PyObject * obj1 = 0 ;
43218 char * kwnames[] = {
43219 (char *) "self",(char *) "item", NULL
43220 };
43221
43222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43224 if (!SWIG_IsOK(res1)) {
43225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43226 }
43227 arg1 = reinterpret_cast< wxMenu * >(argp1);
43228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43229 if (!SWIG_IsOK(res2)) {
43230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43231 }
43232 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43233 {
43234 PyThreadState* __tstate = wxPyBeginAllowThreads();
43235 result = (bool)(arg1)->Delete(arg2);
43236 wxPyEndAllowThreads(__tstate);
43237 if (PyErr_Occurred()) SWIG_fail;
43238 }
43239 {
43240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43241 }
43242 return resultobj;
43243 fail:
43244 return NULL;
43245 }
43246
43247
43248 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43249 PyObject *resultobj = 0;
43250 wxMenu *arg1 = (wxMenu *) 0 ;
43251 void *argp1 = 0 ;
43252 int res1 = 0 ;
43253 PyObject *swig_obj[1] ;
43254
43255 if (!args) SWIG_fail;
43256 swig_obj[0] = args;
43257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43258 if (!SWIG_IsOK(res1)) {
43259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43260 }
43261 arg1 = reinterpret_cast< wxMenu * >(argp1);
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 wxMenu_Destroy(arg1);
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 resultobj = SWIG_Py_Void();
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43276 PyObject *resultobj = 0;
43277 wxMenu *arg1 = (wxMenu *) 0 ;
43278 int arg2 ;
43279 bool result;
43280 void *argp1 = 0 ;
43281 int res1 = 0 ;
43282 int val2 ;
43283 int ecode2 = 0 ;
43284 PyObject * obj0 = 0 ;
43285 PyObject * obj1 = 0 ;
43286 char * kwnames[] = {
43287 (char *) "self",(char *) "id", NULL
43288 };
43289
43290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43292 if (!SWIG_IsOK(res1)) {
43293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43294 }
43295 arg1 = reinterpret_cast< wxMenu * >(argp1);
43296 ecode2 = SWIG_AsVal_int(obj1, &val2);
43297 if (!SWIG_IsOK(ecode2)) {
43298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43299 }
43300 arg2 = static_cast< int >(val2);
43301 {
43302 PyThreadState* __tstate = wxPyBeginAllowThreads();
43303 result = (bool)(arg1)->Destroy(arg2);
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 {
43308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43309 }
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43317 PyObject *resultobj = 0;
43318 wxMenu *arg1 = (wxMenu *) 0 ;
43319 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43320 bool result;
43321 void *argp1 = 0 ;
43322 int res1 = 0 ;
43323 void *argp2 = 0 ;
43324 int res2 = 0 ;
43325 PyObject * obj0 = 0 ;
43326 PyObject * obj1 = 0 ;
43327 char * kwnames[] = {
43328 (char *) "self",(char *) "item", NULL
43329 };
43330
43331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43333 if (!SWIG_IsOK(res1)) {
43334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43335 }
43336 arg1 = reinterpret_cast< wxMenu * >(argp1);
43337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43338 if (!SWIG_IsOK(res2)) {
43339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43340 }
43341 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43342 {
43343 PyThreadState* __tstate = wxPyBeginAllowThreads();
43344 result = (bool)(arg1)->Destroy(arg2);
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_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43358 PyObject *resultobj = 0;
43359 wxMenu *arg1 = (wxMenu *) 0 ;
43360 size_t result;
43361 void *argp1 = 0 ;
43362 int res1 = 0 ;
43363 PyObject *swig_obj[1] ;
43364
43365 if (!args) SWIG_fail;
43366 swig_obj[0] = args;
43367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43368 if (!SWIG_IsOK(res1)) {
43369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43370 }
43371 arg1 = reinterpret_cast< wxMenu * >(argp1);
43372 {
43373 PyThreadState* __tstate = wxPyBeginAllowThreads();
43374 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43375 wxPyEndAllowThreads(__tstate);
43376 if (PyErr_Occurred()) SWIG_fail;
43377 }
43378 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43379 return resultobj;
43380 fail:
43381 return NULL;
43382 }
43383
43384
43385 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43386 PyObject *resultobj = 0;
43387 wxMenu *arg1 = (wxMenu *) 0 ;
43388 PyObject *result = 0 ;
43389 void *argp1 = 0 ;
43390 int res1 = 0 ;
43391 PyObject *swig_obj[1] ;
43392
43393 if (!args) SWIG_fail;
43394 swig_obj[0] = args;
43395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43396 if (!SWIG_IsOK(res1)) {
43397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43398 }
43399 arg1 = reinterpret_cast< wxMenu * >(argp1);
43400 {
43401 PyThreadState* __tstate = wxPyBeginAllowThreads();
43402 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43403 wxPyEndAllowThreads(__tstate);
43404 if (PyErr_Occurred()) SWIG_fail;
43405 }
43406 resultobj = result;
43407 return resultobj;
43408 fail:
43409 return NULL;
43410 }
43411
43412
43413 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43414 PyObject *resultobj = 0;
43415 wxMenu *arg1 = (wxMenu *) 0 ;
43416 wxString *arg2 = 0 ;
43417 int result;
43418 void *argp1 = 0 ;
43419 int res1 = 0 ;
43420 bool temp2 = false ;
43421 PyObject * obj0 = 0 ;
43422 PyObject * obj1 = 0 ;
43423 char * kwnames[] = {
43424 (char *) "self",(char *) "item", NULL
43425 };
43426
43427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43429 if (!SWIG_IsOK(res1)) {
43430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43431 }
43432 arg1 = reinterpret_cast< wxMenu * >(argp1);
43433 {
43434 arg2 = wxString_in_helper(obj1);
43435 if (arg2 == NULL) SWIG_fail;
43436 temp2 = true;
43437 }
43438 {
43439 PyThreadState* __tstate = wxPyBeginAllowThreads();
43440 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43441 wxPyEndAllowThreads(__tstate);
43442 if (PyErr_Occurred()) SWIG_fail;
43443 }
43444 resultobj = SWIG_From_int(static_cast< int >(result));
43445 {
43446 if (temp2)
43447 delete arg2;
43448 }
43449 return resultobj;
43450 fail:
43451 {
43452 if (temp2)
43453 delete arg2;
43454 }
43455 return NULL;
43456 }
43457
43458
43459 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43460 PyObject *resultobj = 0;
43461 wxMenu *arg1 = (wxMenu *) 0 ;
43462 int arg2 ;
43463 wxMenuItem *result = 0 ;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 int val2 ;
43467 int ecode2 = 0 ;
43468 PyObject * obj0 = 0 ;
43469 PyObject * obj1 = 0 ;
43470 char * kwnames[] = {
43471 (char *) "self",(char *) "id", NULL
43472 };
43473
43474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43476 if (!SWIG_IsOK(res1)) {
43477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43478 }
43479 arg1 = reinterpret_cast< wxMenu * >(argp1);
43480 ecode2 = SWIG_AsVal_int(obj1, &val2);
43481 if (!SWIG_IsOK(ecode2)) {
43482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43483 }
43484 arg2 = static_cast< int >(val2);
43485 {
43486 PyThreadState* __tstate = wxPyBeginAllowThreads();
43487 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43488 wxPyEndAllowThreads(__tstate);
43489 if (PyErr_Occurred()) SWIG_fail;
43490 }
43491 {
43492 resultobj = wxPyMake_wxObject(result, (bool)0);
43493 }
43494 return resultobj;
43495 fail:
43496 return NULL;
43497 }
43498
43499
43500 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43501 PyObject *resultobj = 0;
43502 wxMenu *arg1 = (wxMenu *) 0 ;
43503 size_t arg2 ;
43504 wxMenuItem *result = 0 ;
43505 void *argp1 = 0 ;
43506 int res1 = 0 ;
43507 size_t val2 ;
43508 int ecode2 = 0 ;
43509 PyObject * obj0 = 0 ;
43510 PyObject * obj1 = 0 ;
43511 char * kwnames[] = {
43512 (char *) "self",(char *) "position", NULL
43513 };
43514
43515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43517 if (!SWIG_IsOK(res1)) {
43518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43519 }
43520 arg1 = reinterpret_cast< wxMenu * >(argp1);
43521 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43522 if (!SWIG_IsOK(ecode2)) {
43523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43524 }
43525 arg2 = static_cast< size_t >(val2);
43526 {
43527 PyThreadState* __tstate = wxPyBeginAllowThreads();
43528 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43529 wxPyEndAllowThreads(__tstate);
43530 if (PyErr_Occurred()) SWIG_fail;
43531 }
43532 {
43533 resultobj = wxPyMake_wxObject(result, (bool)0);
43534 }
43535 return resultobj;
43536 fail:
43537 return NULL;
43538 }
43539
43540
43541 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43542 PyObject *resultobj = 0;
43543 wxMenu *arg1 = (wxMenu *) 0 ;
43544 int arg2 ;
43545 bool arg3 ;
43546 void *argp1 = 0 ;
43547 int res1 = 0 ;
43548 int val2 ;
43549 int ecode2 = 0 ;
43550 bool val3 ;
43551 int ecode3 = 0 ;
43552 PyObject * obj0 = 0 ;
43553 PyObject * obj1 = 0 ;
43554 PyObject * obj2 = 0 ;
43555 char * kwnames[] = {
43556 (char *) "self",(char *) "id",(char *) "enable", NULL
43557 };
43558
43559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43561 if (!SWIG_IsOK(res1)) {
43562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43563 }
43564 arg1 = reinterpret_cast< wxMenu * >(argp1);
43565 ecode2 = SWIG_AsVal_int(obj1, &val2);
43566 if (!SWIG_IsOK(ecode2)) {
43567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43568 }
43569 arg2 = static_cast< int >(val2);
43570 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43571 if (!SWIG_IsOK(ecode3)) {
43572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43573 }
43574 arg3 = static_cast< bool >(val3);
43575 {
43576 PyThreadState* __tstate = wxPyBeginAllowThreads();
43577 (arg1)->Enable(arg2,arg3);
43578 wxPyEndAllowThreads(__tstate);
43579 if (PyErr_Occurred()) SWIG_fail;
43580 }
43581 resultobj = SWIG_Py_Void();
43582 return resultobj;
43583 fail:
43584 return NULL;
43585 }
43586
43587
43588 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43589 PyObject *resultobj = 0;
43590 wxMenu *arg1 = (wxMenu *) 0 ;
43591 int arg2 ;
43592 bool result;
43593 void *argp1 = 0 ;
43594 int res1 = 0 ;
43595 int val2 ;
43596 int ecode2 = 0 ;
43597 PyObject * obj0 = 0 ;
43598 PyObject * obj1 = 0 ;
43599 char * kwnames[] = {
43600 (char *) "self",(char *) "id", NULL
43601 };
43602
43603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43605 if (!SWIG_IsOK(res1)) {
43606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43607 }
43608 arg1 = reinterpret_cast< wxMenu * >(argp1);
43609 ecode2 = SWIG_AsVal_int(obj1, &val2);
43610 if (!SWIG_IsOK(ecode2)) {
43611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43612 }
43613 arg2 = static_cast< int >(val2);
43614 {
43615 PyThreadState* __tstate = wxPyBeginAllowThreads();
43616 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43617 wxPyEndAllowThreads(__tstate);
43618 if (PyErr_Occurred()) SWIG_fail;
43619 }
43620 {
43621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43622 }
43623 return resultobj;
43624 fail:
43625 return NULL;
43626 }
43627
43628
43629 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43630 PyObject *resultobj = 0;
43631 wxMenu *arg1 = (wxMenu *) 0 ;
43632 int arg2 ;
43633 bool arg3 ;
43634 void *argp1 = 0 ;
43635 int res1 = 0 ;
43636 int val2 ;
43637 int ecode2 = 0 ;
43638 bool val3 ;
43639 int ecode3 = 0 ;
43640 PyObject * obj0 = 0 ;
43641 PyObject * obj1 = 0 ;
43642 PyObject * obj2 = 0 ;
43643 char * kwnames[] = {
43644 (char *) "self",(char *) "id",(char *) "check", NULL
43645 };
43646
43647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43649 if (!SWIG_IsOK(res1)) {
43650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43651 }
43652 arg1 = reinterpret_cast< wxMenu * >(argp1);
43653 ecode2 = SWIG_AsVal_int(obj1, &val2);
43654 if (!SWIG_IsOK(ecode2)) {
43655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43656 }
43657 arg2 = static_cast< int >(val2);
43658 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43659 if (!SWIG_IsOK(ecode3)) {
43660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43661 }
43662 arg3 = static_cast< bool >(val3);
43663 {
43664 PyThreadState* __tstate = wxPyBeginAllowThreads();
43665 (arg1)->Check(arg2,arg3);
43666 wxPyEndAllowThreads(__tstate);
43667 if (PyErr_Occurred()) SWIG_fail;
43668 }
43669 resultobj = SWIG_Py_Void();
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43677 PyObject *resultobj = 0;
43678 wxMenu *arg1 = (wxMenu *) 0 ;
43679 int arg2 ;
43680 bool result;
43681 void *argp1 = 0 ;
43682 int res1 = 0 ;
43683 int val2 ;
43684 int ecode2 = 0 ;
43685 PyObject * obj0 = 0 ;
43686 PyObject * obj1 = 0 ;
43687 char * kwnames[] = {
43688 (char *) "self",(char *) "id", NULL
43689 };
43690
43691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43693 if (!SWIG_IsOK(res1)) {
43694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43695 }
43696 arg1 = reinterpret_cast< wxMenu * >(argp1);
43697 ecode2 = SWIG_AsVal_int(obj1, &val2);
43698 if (!SWIG_IsOK(ecode2)) {
43699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43700 }
43701 arg2 = static_cast< int >(val2);
43702 {
43703 PyThreadState* __tstate = wxPyBeginAllowThreads();
43704 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43705 wxPyEndAllowThreads(__tstate);
43706 if (PyErr_Occurred()) SWIG_fail;
43707 }
43708 {
43709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43710 }
43711 return resultobj;
43712 fail:
43713 return NULL;
43714 }
43715
43716
43717 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43718 PyObject *resultobj = 0;
43719 wxMenu *arg1 = (wxMenu *) 0 ;
43720 int arg2 ;
43721 wxString *arg3 = 0 ;
43722 void *argp1 = 0 ;
43723 int res1 = 0 ;
43724 int val2 ;
43725 int ecode2 = 0 ;
43726 bool temp3 = false ;
43727 PyObject * obj0 = 0 ;
43728 PyObject * obj1 = 0 ;
43729 PyObject * obj2 = 0 ;
43730 char * kwnames[] = {
43731 (char *) "self",(char *) "id",(char *) "label", NULL
43732 };
43733
43734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43736 if (!SWIG_IsOK(res1)) {
43737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43738 }
43739 arg1 = reinterpret_cast< wxMenu * >(argp1);
43740 ecode2 = SWIG_AsVal_int(obj1, &val2);
43741 if (!SWIG_IsOK(ecode2)) {
43742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43743 }
43744 arg2 = static_cast< int >(val2);
43745 {
43746 arg3 = wxString_in_helper(obj2);
43747 if (arg3 == NULL) SWIG_fail;
43748 temp3 = true;
43749 }
43750 {
43751 PyThreadState* __tstate = wxPyBeginAllowThreads();
43752 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43753 wxPyEndAllowThreads(__tstate);
43754 if (PyErr_Occurred()) SWIG_fail;
43755 }
43756 resultobj = SWIG_Py_Void();
43757 {
43758 if (temp3)
43759 delete arg3;
43760 }
43761 return resultobj;
43762 fail:
43763 {
43764 if (temp3)
43765 delete arg3;
43766 }
43767 return NULL;
43768 }
43769
43770
43771 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43772 PyObject *resultobj = 0;
43773 wxMenu *arg1 = (wxMenu *) 0 ;
43774 int arg2 ;
43775 wxString result;
43776 void *argp1 = 0 ;
43777 int res1 = 0 ;
43778 int val2 ;
43779 int ecode2 = 0 ;
43780 PyObject * obj0 = 0 ;
43781 PyObject * obj1 = 0 ;
43782 char * kwnames[] = {
43783 (char *) "self",(char *) "id", NULL
43784 };
43785
43786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43788 if (!SWIG_IsOK(res1)) {
43789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43790 }
43791 arg1 = reinterpret_cast< wxMenu * >(argp1);
43792 ecode2 = SWIG_AsVal_int(obj1, &val2);
43793 if (!SWIG_IsOK(ecode2)) {
43794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43795 }
43796 arg2 = static_cast< int >(val2);
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43800 wxPyEndAllowThreads(__tstate);
43801 if (PyErr_Occurred()) SWIG_fail;
43802 }
43803 {
43804 #if wxUSE_UNICODE
43805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43806 #else
43807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43808 #endif
43809 }
43810 return resultobj;
43811 fail:
43812 return NULL;
43813 }
43814
43815
43816 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43817 PyObject *resultobj = 0;
43818 wxMenu *arg1 = (wxMenu *) 0 ;
43819 int arg2 ;
43820 wxString *arg3 = 0 ;
43821 void *argp1 = 0 ;
43822 int res1 = 0 ;
43823 int val2 ;
43824 int ecode2 = 0 ;
43825 bool temp3 = false ;
43826 PyObject * obj0 = 0 ;
43827 PyObject * obj1 = 0 ;
43828 PyObject * obj2 = 0 ;
43829 char * kwnames[] = {
43830 (char *) "self",(char *) "id",(char *) "helpString", NULL
43831 };
43832
43833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43835 if (!SWIG_IsOK(res1)) {
43836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43837 }
43838 arg1 = reinterpret_cast< wxMenu * >(argp1);
43839 ecode2 = SWIG_AsVal_int(obj1, &val2);
43840 if (!SWIG_IsOK(ecode2)) {
43841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43842 }
43843 arg2 = static_cast< int >(val2);
43844 {
43845 arg3 = wxString_in_helper(obj2);
43846 if (arg3 == NULL) SWIG_fail;
43847 temp3 = true;
43848 }
43849 {
43850 PyThreadState* __tstate = wxPyBeginAllowThreads();
43851 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43852 wxPyEndAllowThreads(__tstate);
43853 if (PyErr_Occurred()) SWIG_fail;
43854 }
43855 resultobj = SWIG_Py_Void();
43856 {
43857 if (temp3)
43858 delete arg3;
43859 }
43860 return resultobj;
43861 fail:
43862 {
43863 if (temp3)
43864 delete arg3;
43865 }
43866 return NULL;
43867 }
43868
43869
43870 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43871 PyObject *resultobj = 0;
43872 wxMenu *arg1 = (wxMenu *) 0 ;
43873 int arg2 ;
43874 wxString result;
43875 void *argp1 = 0 ;
43876 int res1 = 0 ;
43877 int val2 ;
43878 int ecode2 = 0 ;
43879 PyObject * obj0 = 0 ;
43880 PyObject * obj1 = 0 ;
43881 char * kwnames[] = {
43882 (char *) "self",(char *) "id", NULL
43883 };
43884
43885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43887 if (!SWIG_IsOK(res1)) {
43888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43889 }
43890 arg1 = reinterpret_cast< wxMenu * >(argp1);
43891 ecode2 = SWIG_AsVal_int(obj1, &val2);
43892 if (!SWIG_IsOK(ecode2)) {
43893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43894 }
43895 arg2 = static_cast< int >(val2);
43896 {
43897 PyThreadState* __tstate = wxPyBeginAllowThreads();
43898 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43899 wxPyEndAllowThreads(__tstate);
43900 if (PyErr_Occurred()) SWIG_fail;
43901 }
43902 {
43903 #if wxUSE_UNICODE
43904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43905 #else
43906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43907 #endif
43908 }
43909 return resultobj;
43910 fail:
43911 return NULL;
43912 }
43913
43914
43915 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43916 PyObject *resultobj = 0;
43917 wxMenu *arg1 = (wxMenu *) 0 ;
43918 wxString *arg2 = 0 ;
43919 void *argp1 = 0 ;
43920 int res1 = 0 ;
43921 bool temp2 = false ;
43922 PyObject * obj0 = 0 ;
43923 PyObject * obj1 = 0 ;
43924 char * kwnames[] = {
43925 (char *) "self",(char *) "title", NULL
43926 };
43927
43928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43930 if (!SWIG_IsOK(res1)) {
43931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43932 }
43933 arg1 = reinterpret_cast< wxMenu * >(argp1);
43934 {
43935 arg2 = wxString_in_helper(obj1);
43936 if (arg2 == NULL) SWIG_fail;
43937 temp2 = true;
43938 }
43939 {
43940 PyThreadState* __tstate = wxPyBeginAllowThreads();
43941 (arg1)->SetTitle((wxString const &)*arg2);
43942 wxPyEndAllowThreads(__tstate);
43943 if (PyErr_Occurred()) SWIG_fail;
43944 }
43945 resultobj = SWIG_Py_Void();
43946 {
43947 if (temp2)
43948 delete arg2;
43949 }
43950 return resultobj;
43951 fail:
43952 {
43953 if (temp2)
43954 delete arg2;
43955 }
43956 return NULL;
43957 }
43958
43959
43960 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43961 PyObject *resultobj = 0;
43962 wxMenu *arg1 = (wxMenu *) 0 ;
43963 wxString result;
43964 void *argp1 = 0 ;
43965 int res1 = 0 ;
43966 PyObject *swig_obj[1] ;
43967
43968 if (!args) SWIG_fail;
43969 swig_obj[0] = args;
43970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43971 if (!SWIG_IsOK(res1)) {
43972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43973 }
43974 arg1 = reinterpret_cast< wxMenu * >(argp1);
43975 {
43976 PyThreadState* __tstate = wxPyBeginAllowThreads();
43977 result = ((wxMenu const *)arg1)->GetTitle();
43978 wxPyEndAllowThreads(__tstate);
43979 if (PyErr_Occurred()) SWIG_fail;
43980 }
43981 {
43982 #if wxUSE_UNICODE
43983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43984 #else
43985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43986 #endif
43987 }
43988 return resultobj;
43989 fail:
43990 return NULL;
43991 }
43992
43993
43994 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43995 PyObject *resultobj = 0;
43996 wxMenu *arg1 = (wxMenu *) 0 ;
43997 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43998 void *argp1 = 0 ;
43999 int res1 = 0 ;
44000 void *argp2 = 0 ;
44001 int res2 = 0 ;
44002 PyObject * obj0 = 0 ;
44003 PyObject * obj1 = 0 ;
44004 char * kwnames[] = {
44005 (char *) "self",(char *) "handler", NULL
44006 };
44007
44008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44010 if (!SWIG_IsOK(res1)) {
44011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44012 }
44013 arg1 = reinterpret_cast< wxMenu * >(argp1);
44014 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44015 if (!SWIG_IsOK(res2)) {
44016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44017 }
44018 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44019 {
44020 PyThreadState* __tstate = wxPyBeginAllowThreads();
44021 (arg1)->SetEventHandler(arg2);
44022 wxPyEndAllowThreads(__tstate);
44023 if (PyErr_Occurred()) SWIG_fail;
44024 }
44025 resultobj = SWIG_Py_Void();
44026 return resultobj;
44027 fail:
44028 return NULL;
44029 }
44030
44031
44032 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44033 PyObject *resultobj = 0;
44034 wxMenu *arg1 = (wxMenu *) 0 ;
44035 wxEvtHandler *result = 0 ;
44036 void *argp1 = 0 ;
44037 int res1 = 0 ;
44038 PyObject *swig_obj[1] ;
44039
44040 if (!args) SWIG_fail;
44041 swig_obj[0] = args;
44042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44043 if (!SWIG_IsOK(res1)) {
44044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44045 }
44046 arg1 = reinterpret_cast< wxMenu * >(argp1);
44047 {
44048 PyThreadState* __tstate = wxPyBeginAllowThreads();
44049 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44050 wxPyEndAllowThreads(__tstate);
44051 if (PyErr_Occurred()) SWIG_fail;
44052 }
44053 {
44054 resultobj = wxPyMake_wxObject(result, 0);
44055 }
44056 return resultobj;
44057 fail:
44058 return NULL;
44059 }
44060
44061
44062 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44063 PyObject *resultobj = 0;
44064 wxMenu *arg1 = (wxMenu *) 0 ;
44065 wxWindow *arg2 = (wxWindow *) 0 ;
44066 void *argp1 = 0 ;
44067 int res1 = 0 ;
44068 void *argp2 = 0 ;
44069 int res2 = 0 ;
44070 PyObject * obj0 = 0 ;
44071 PyObject * obj1 = 0 ;
44072 char * kwnames[] = {
44073 (char *) "self",(char *) "win", NULL
44074 };
44075
44076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44078 if (!SWIG_IsOK(res1)) {
44079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44080 }
44081 arg1 = reinterpret_cast< wxMenu * >(argp1);
44082 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44083 if (!SWIG_IsOK(res2)) {
44084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44085 }
44086 arg2 = reinterpret_cast< wxWindow * >(argp2);
44087 {
44088 PyThreadState* __tstate = wxPyBeginAllowThreads();
44089 (arg1)->SetInvokingWindow(arg2);
44090 wxPyEndAllowThreads(__tstate);
44091 if (PyErr_Occurred()) SWIG_fail;
44092 }
44093 resultobj = SWIG_Py_Void();
44094 return resultobj;
44095 fail:
44096 return NULL;
44097 }
44098
44099
44100 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44101 PyObject *resultobj = 0;
44102 wxMenu *arg1 = (wxMenu *) 0 ;
44103 wxWindow *result = 0 ;
44104 void *argp1 = 0 ;
44105 int res1 = 0 ;
44106 PyObject *swig_obj[1] ;
44107
44108 if (!args) SWIG_fail;
44109 swig_obj[0] = args;
44110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44111 if (!SWIG_IsOK(res1)) {
44112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44113 }
44114 arg1 = reinterpret_cast< wxMenu * >(argp1);
44115 {
44116 PyThreadState* __tstate = wxPyBeginAllowThreads();
44117 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44118 wxPyEndAllowThreads(__tstate);
44119 if (PyErr_Occurred()) SWIG_fail;
44120 }
44121 {
44122 resultobj = wxPyMake_wxObject(result, 0);
44123 }
44124 return resultobj;
44125 fail:
44126 return NULL;
44127 }
44128
44129
44130 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44131 PyObject *resultobj = 0;
44132 wxMenu *arg1 = (wxMenu *) 0 ;
44133 long result;
44134 void *argp1 = 0 ;
44135 int res1 = 0 ;
44136 PyObject *swig_obj[1] ;
44137
44138 if (!args) SWIG_fail;
44139 swig_obj[0] = args;
44140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44141 if (!SWIG_IsOK(res1)) {
44142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44143 }
44144 arg1 = reinterpret_cast< wxMenu * >(argp1);
44145 {
44146 PyThreadState* __tstate = wxPyBeginAllowThreads();
44147 result = (long)((wxMenu const *)arg1)->GetStyle();
44148 wxPyEndAllowThreads(__tstate);
44149 if (PyErr_Occurred()) SWIG_fail;
44150 }
44151 resultobj = SWIG_From_long(static_cast< long >(result));
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44159 PyObject *resultobj = 0;
44160 wxMenu *arg1 = (wxMenu *) 0 ;
44161 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44162 void *argp1 = 0 ;
44163 int res1 = 0 ;
44164 void *argp2 = 0 ;
44165 int res2 = 0 ;
44166 PyObject * obj0 = 0 ;
44167 PyObject * obj1 = 0 ;
44168 char * kwnames[] = {
44169 (char *) "self",(char *) "source", NULL
44170 };
44171
44172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44174 if (!SWIG_IsOK(res1)) {
44175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44176 }
44177 arg1 = reinterpret_cast< wxMenu * >(argp1);
44178 if (obj1) {
44179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44180 if (!SWIG_IsOK(res2)) {
44181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44182 }
44183 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44184 }
44185 {
44186 PyThreadState* __tstate = wxPyBeginAllowThreads();
44187 (arg1)->UpdateUI(arg2);
44188 wxPyEndAllowThreads(__tstate);
44189 if (PyErr_Occurred()) SWIG_fail;
44190 }
44191 resultobj = SWIG_Py_Void();
44192 return resultobj;
44193 fail:
44194 return NULL;
44195 }
44196
44197
44198 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44199 PyObject *resultobj = 0;
44200 wxMenu *arg1 = (wxMenu *) 0 ;
44201 wxMenuBar *result = 0 ;
44202 void *argp1 = 0 ;
44203 int res1 = 0 ;
44204 PyObject *swig_obj[1] ;
44205
44206 if (!args) SWIG_fail;
44207 swig_obj[0] = args;
44208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44209 if (!SWIG_IsOK(res1)) {
44210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44211 }
44212 arg1 = reinterpret_cast< wxMenu * >(argp1);
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44216 wxPyEndAllowThreads(__tstate);
44217 if (PyErr_Occurred()) SWIG_fail;
44218 }
44219 {
44220 resultobj = wxPyMake_wxObject(result, (bool)0);
44221 }
44222 return resultobj;
44223 fail:
44224 return NULL;
44225 }
44226
44227
44228 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44229 PyObject *resultobj = 0;
44230 wxMenu *arg1 = (wxMenu *) 0 ;
44231 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44232 void *argp1 = 0 ;
44233 int res1 = 0 ;
44234 void *argp2 = 0 ;
44235 int res2 = 0 ;
44236 PyObject * obj0 = 0 ;
44237 PyObject * obj1 = 0 ;
44238 char * kwnames[] = {
44239 (char *) "self",(char *) "menubar", NULL
44240 };
44241
44242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44244 if (!SWIG_IsOK(res1)) {
44245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44246 }
44247 arg1 = reinterpret_cast< wxMenu * >(argp1);
44248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44249 if (!SWIG_IsOK(res2)) {
44250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44251 }
44252 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44253 {
44254 PyThreadState* __tstate = wxPyBeginAllowThreads();
44255 (arg1)->Attach(arg2);
44256 wxPyEndAllowThreads(__tstate);
44257 if (PyErr_Occurred()) SWIG_fail;
44258 }
44259 resultobj = SWIG_Py_Void();
44260 return resultobj;
44261 fail:
44262 return NULL;
44263 }
44264
44265
44266 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44267 PyObject *resultobj = 0;
44268 wxMenu *arg1 = (wxMenu *) 0 ;
44269 void *argp1 = 0 ;
44270 int res1 = 0 ;
44271 PyObject *swig_obj[1] ;
44272
44273 if (!args) SWIG_fail;
44274 swig_obj[0] = args;
44275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44276 if (!SWIG_IsOK(res1)) {
44277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44278 }
44279 arg1 = reinterpret_cast< wxMenu * >(argp1);
44280 {
44281 PyThreadState* __tstate = wxPyBeginAllowThreads();
44282 (arg1)->Detach();
44283 wxPyEndAllowThreads(__tstate);
44284 if (PyErr_Occurred()) SWIG_fail;
44285 }
44286 resultobj = SWIG_Py_Void();
44287 return resultobj;
44288 fail:
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44294 PyObject *resultobj = 0;
44295 wxMenu *arg1 = (wxMenu *) 0 ;
44296 bool result;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 PyObject *swig_obj[1] ;
44300
44301 if (!args) SWIG_fail;
44302 swig_obj[0] = args;
44303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44304 if (!SWIG_IsOK(res1)) {
44305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44306 }
44307 arg1 = reinterpret_cast< wxMenu * >(argp1);
44308 {
44309 PyThreadState* __tstate = wxPyBeginAllowThreads();
44310 result = (bool)((wxMenu const *)arg1)->IsAttached();
44311 wxPyEndAllowThreads(__tstate);
44312 if (PyErr_Occurred()) SWIG_fail;
44313 }
44314 {
44315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44316 }
44317 return resultobj;
44318 fail:
44319 return NULL;
44320 }
44321
44322
44323 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44324 PyObject *resultobj = 0;
44325 wxMenu *arg1 = (wxMenu *) 0 ;
44326 wxMenu *arg2 = (wxMenu *) 0 ;
44327 void *argp1 = 0 ;
44328 int res1 = 0 ;
44329 void *argp2 = 0 ;
44330 int res2 = 0 ;
44331 PyObject * obj0 = 0 ;
44332 PyObject * obj1 = 0 ;
44333 char * kwnames[] = {
44334 (char *) "self",(char *) "parent", NULL
44335 };
44336
44337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44339 if (!SWIG_IsOK(res1)) {
44340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44341 }
44342 arg1 = reinterpret_cast< wxMenu * >(argp1);
44343 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44344 if (!SWIG_IsOK(res2)) {
44345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44346 }
44347 arg2 = reinterpret_cast< wxMenu * >(argp2);
44348 {
44349 PyThreadState* __tstate = wxPyBeginAllowThreads();
44350 (arg1)->SetParent(arg2);
44351 wxPyEndAllowThreads(__tstate);
44352 if (PyErr_Occurred()) SWIG_fail;
44353 }
44354 resultobj = SWIG_Py_Void();
44355 return resultobj;
44356 fail:
44357 return NULL;
44358 }
44359
44360
44361 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44362 PyObject *resultobj = 0;
44363 wxMenu *arg1 = (wxMenu *) 0 ;
44364 wxMenu *result = 0 ;
44365 void *argp1 = 0 ;
44366 int res1 = 0 ;
44367 PyObject *swig_obj[1] ;
44368
44369 if (!args) SWIG_fail;
44370 swig_obj[0] = args;
44371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44372 if (!SWIG_IsOK(res1)) {
44373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44374 }
44375 arg1 = reinterpret_cast< wxMenu * >(argp1);
44376 {
44377 PyThreadState* __tstate = wxPyBeginAllowThreads();
44378 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44379 wxPyEndAllowThreads(__tstate);
44380 if (PyErr_Occurred()) SWIG_fail;
44381 }
44382 {
44383 resultobj = wxPyMake_wxObject(result, 0);
44384 }
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44392 PyObject *obj;
44393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44394 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44395 return SWIG_Py_Void();
44396 }
44397
44398 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44399 return SWIG_Python_InitShadowInstance(args);
44400 }
44401
44402 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44403 PyObject *resultobj = 0;
44404 long arg1 = (long) 0 ;
44405 wxMenuBar *result = 0 ;
44406 long val1 ;
44407 int ecode1 = 0 ;
44408 PyObject * obj0 = 0 ;
44409 char * kwnames[] = {
44410 (char *) "style", NULL
44411 };
44412
44413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44414 if (obj0) {
44415 ecode1 = SWIG_AsVal_long(obj0, &val1);
44416 if (!SWIG_IsOK(ecode1)) {
44417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44418 }
44419 arg1 = static_cast< long >(val1);
44420 }
44421 {
44422 if (!wxPyCheckForApp()) SWIG_fail;
44423 PyThreadState* __tstate = wxPyBeginAllowThreads();
44424 result = (wxMenuBar *)new wxMenuBar(arg1);
44425 wxPyEndAllowThreads(__tstate);
44426 if (PyErr_Occurred()) SWIG_fail;
44427 }
44428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44429 return resultobj;
44430 fail:
44431 return NULL;
44432 }
44433
44434
44435 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44436 PyObject *resultobj = 0;
44437 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44438 wxMenu *arg2 = (wxMenu *) 0 ;
44439 wxString *arg3 = 0 ;
44440 bool result;
44441 void *argp1 = 0 ;
44442 int res1 = 0 ;
44443 void *argp2 = 0 ;
44444 int res2 = 0 ;
44445 bool temp3 = false ;
44446 PyObject * obj0 = 0 ;
44447 PyObject * obj1 = 0 ;
44448 PyObject * obj2 = 0 ;
44449 char * kwnames[] = {
44450 (char *) "self",(char *) "menu",(char *) "title", NULL
44451 };
44452
44453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44455 if (!SWIG_IsOK(res1)) {
44456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44457 }
44458 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44460 if (!SWIG_IsOK(res2)) {
44461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44462 }
44463 arg2 = reinterpret_cast< wxMenu * >(argp2);
44464 {
44465 arg3 = wxString_in_helper(obj2);
44466 if (arg3 == NULL) SWIG_fail;
44467 temp3 = true;
44468 }
44469 {
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44472 wxPyEndAllowThreads(__tstate);
44473 if (PyErr_Occurred()) SWIG_fail;
44474 }
44475 {
44476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44477 }
44478 {
44479 if (temp3)
44480 delete arg3;
44481 }
44482 return resultobj;
44483 fail:
44484 {
44485 if (temp3)
44486 delete arg3;
44487 }
44488 return NULL;
44489 }
44490
44491
44492 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44493 PyObject *resultobj = 0;
44494 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44495 size_t arg2 ;
44496 wxMenu *arg3 = (wxMenu *) 0 ;
44497 wxString *arg4 = 0 ;
44498 bool result;
44499 void *argp1 = 0 ;
44500 int res1 = 0 ;
44501 size_t val2 ;
44502 int ecode2 = 0 ;
44503 void *argp3 = 0 ;
44504 int res3 = 0 ;
44505 bool temp4 = false ;
44506 PyObject * obj0 = 0 ;
44507 PyObject * obj1 = 0 ;
44508 PyObject * obj2 = 0 ;
44509 PyObject * obj3 = 0 ;
44510 char * kwnames[] = {
44511 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44512 };
44513
44514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44516 if (!SWIG_IsOK(res1)) {
44517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44518 }
44519 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44520 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44521 if (!SWIG_IsOK(ecode2)) {
44522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44523 }
44524 arg2 = static_cast< size_t >(val2);
44525 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44526 if (!SWIG_IsOK(res3)) {
44527 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44528 }
44529 arg3 = reinterpret_cast< wxMenu * >(argp3);
44530 {
44531 arg4 = wxString_in_helper(obj3);
44532 if (arg4 == NULL) SWIG_fail;
44533 temp4 = true;
44534 }
44535 {
44536 PyThreadState* __tstate = wxPyBeginAllowThreads();
44537 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44538 wxPyEndAllowThreads(__tstate);
44539 if (PyErr_Occurred()) SWIG_fail;
44540 }
44541 {
44542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44543 }
44544 {
44545 if (temp4)
44546 delete arg4;
44547 }
44548 return resultobj;
44549 fail:
44550 {
44551 if (temp4)
44552 delete arg4;
44553 }
44554 return NULL;
44555 }
44556
44557
44558 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44559 PyObject *resultobj = 0;
44560 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44561 size_t result;
44562 void *argp1 = 0 ;
44563 int res1 = 0 ;
44564 PyObject *swig_obj[1] ;
44565
44566 if (!args) SWIG_fail;
44567 swig_obj[0] = args;
44568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44569 if (!SWIG_IsOK(res1)) {
44570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44571 }
44572 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44573 {
44574 PyThreadState* __tstate = wxPyBeginAllowThreads();
44575 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44576 wxPyEndAllowThreads(__tstate);
44577 if (PyErr_Occurred()) SWIG_fail;
44578 }
44579 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44580 return resultobj;
44581 fail:
44582 return NULL;
44583 }
44584
44585
44586 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44587 PyObject *resultobj = 0;
44588 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44589 size_t arg2 ;
44590 wxMenu *result = 0 ;
44591 void *argp1 = 0 ;
44592 int res1 = 0 ;
44593 size_t val2 ;
44594 int ecode2 = 0 ;
44595 PyObject * obj0 = 0 ;
44596 PyObject * obj1 = 0 ;
44597 char * kwnames[] = {
44598 (char *) "self",(char *) "pos", NULL
44599 };
44600
44601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44603 if (!SWIG_IsOK(res1)) {
44604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44605 }
44606 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44607 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44608 if (!SWIG_IsOK(ecode2)) {
44609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44610 }
44611 arg2 = static_cast< size_t >(val2);
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44615 wxPyEndAllowThreads(__tstate);
44616 if (PyErr_Occurred()) SWIG_fail;
44617 }
44618 {
44619 resultobj = wxPyMake_wxObject(result, 0);
44620 }
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj = 0;
44629 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44630 size_t arg2 ;
44631 wxMenu *arg3 = (wxMenu *) 0 ;
44632 wxString *arg4 = 0 ;
44633 wxMenu *result = 0 ;
44634 void *argp1 = 0 ;
44635 int res1 = 0 ;
44636 size_t val2 ;
44637 int ecode2 = 0 ;
44638 void *argp3 = 0 ;
44639 int res3 = 0 ;
44640 bool temp4 = false ;
44641 PyObject * obj0 = 0 ;
44642 PyObject * obj1 = 0 ;
44643 PyObject * obj2 = 0 ;
44644 PyObject * obj3 = 0 ;
44645 char * kwnames[] = {
44646 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44647 };
44648
44649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44651 if (!SWIG_IsOK(res1)) {
44652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44653 }
44654 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44656 if (!SWIG_IsOK(ecode2)) {
44657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44658 }
44659 arg2 = static_cast< size_t >(val2);
44660 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44661 if (!SWIG_IsOK(res3)) {
44662 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44663 }
44664 arg3 = reinterpret_cast< wxMenu * >(argp3);
44665 {
44666 arg4 = wxString_in_helper(obj3);
44667 if (arg4 == NULL) SWIG_fail;
44668 temp4 = true;
44669 }
44670 {
44671 PyThreadState* __tstate = wxPyBeginAllowThreads();
44672 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44673 wxPyEndAllowThreads(__tstate);
44674 if (PyErr_Occurred()) SWIG_fail;
44675 }
44676 {
44677 resultobj = wxPyMake_wxObject(result, 0);
44678 }
44679 {
44680 if (temp4)
44681 delete arg4;
44682 }
44683 return resultobj;
44684 fail:
44685 {
44686 if (temp4)
44687 delete arg4;
44688 }
44689 return NULL;
44690 }
44691
44692
44693 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44694 PyObject *resultobj = 0;
44695 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44696 size_t arg2 ;
44697 wxMenu *result = 0 ;
44698 void *argp1 = 0 ;
44699 int res1 = 0 ;
44700 size_t val2 ;
44701 int ecode2 = 0 ;
44702 PyObject * obj0 = 0 ;
44703 PyObject * obj1 = 0 ;
44704 char * kwnames[] = {
44705 (char *) "self",(char *) "pos", NULL
44706 };
44707
44708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44710 if (!SWIG_IsOK(res1)) {
44711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44712 }
44713 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44714 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44715 if (!SWIG_IsOK(ecode2)) {
44716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44717 }
44718 arg2 = static_cast< size_t >(val2);
44719 {
44720 PyThreadState* __tstate = wxPyBeginAllowThreads();
44721 result = (wxMenu *)(arg1)->Remove(arg2);
44722 wxPyEndAllowThreads(__tstate);
44723 if (PyErr_Occurred()) SWIG_fail;
44724 }
44725 {
44726 resultobj = wxPyMake_wxObject(result, 0);
44727 }
44728 return resultobj;
44729 fail:
44730 return NULL;
44731 }
44732
44733
44734 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44735 PyObject *resultobj = 0;
44736 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44737 size_t arg2 ;
44738 bool arg3 ;
44739 void *argp1 = 0 ;
44740 int res1 = 0 ;
44741 size_t val2 ;
44742 int ecode2 = 0 ;
44743 bool val3 ;
44744 int ecode3 = 0 ;
44745 PyObject * obj0 = 0 ;
44746 PyObject * obj1 = 0 ;
44747 PyObject * obj2 = 0 ;
44748 char * kwnames[] = {
44749 (char *) "self",(char *) "pos",(char *) "enable", NULL
44750 };
44751
44752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44754 if (!SWIG_IsOK(res1)) {
44755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44756 }
44757 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44758 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44759 if (!SWIG_IsOK(ecode2)) {
44760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44761 }
44762 arg2 = static_cast< size_t >(val2);
44763 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44764 if (!SWIG_IsOK(ecode3)) {
44765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44766 }
44767 arg3 = static_cast< bool >(val3);
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 (arg1)->EnableTop(arg2,arg3);
44771 wxPyEndAllowThreads(__tstate);
44772 if (PyErr_Occurred()) SWIG_fail;
44773 }
44774 resultobj = SWIG_Py_Void();
44775 return resultobj;
44776 fail:
44777 return NULL;
44778 }
44779
44780
44781 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44782 PyObject *resultobj = 0;
44783 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44784 size_t arg2 ;
44785 bool result;
44786 void *argp1 = 0 ;
44787 int res1 = 0 ;
44788 size_t val2 ;
44789 int ecode2 = 0 ;
44790 PyObject * obj0 = 0 ;
44791 PyObject * obj1 = 0 ;
44792 char * kwnames[] = {
44793 (char *) "self",(char *) "pos", NULL
44794 };
44795
44796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44798 if (!SWIG_IsOK(res1)) {
44799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44800 }
44801 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44802 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44803 if (!SWIG_IsOK(ecode2)) {
44804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44805 }
44806 arg2 = static_cast< size_t >(val2);
44807 {
44808 PyThreadState* __tstate = wxPyBeginAllowThreads();
44809 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44810 wxPyEndAllowThreads(__tstate);
44811 if (PyErr_Occurred()) SWIG_fail;
44812 }
44813 {
44814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44815 }
44816 return resultobj;
44817 fail:
44818 return NULL;
44819 }
44820
44821
44822 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44823 PyObject *resultobj = 0;
44824 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44825 size_t arg2 ;
44826 wxString *arg3 = 0 ;
44827 void *argp1 = 0 ;
44828 int res1 = 0 ;
44829 size_t val2 ;
44830 int ecode2 = 0 ;
44831 bool temp3 = false ;
44832 PyObject * obj0 = 0 ;
44833 PyObject * obj1 = 0 ;
44834 PyObject * obj2 = 0 ;
44835 char * kwnames[] = {
44836 (char *) "self",(char *) "pos",(char *) "label", NULL
44837 };
44838
44839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44841 if (!SWIG_IsOK(res1)) {
44842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44843 }
44844 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44845 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44846 if (!SWIG_IsOK(ecode2)) {
44847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44848 }
44849 arg2 = static_cast< size_t >(val2);
44850 {
44851 arg3 = wxString_in_helper(obj2);
44852 if (arg3 == NULL) SWIG_fail;
44853 temp3 = true;
44854 }
44855 {
44856 PyThreadState* __tstate = wxPyBeginAllowThreads();
44857 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44858 wxPyEndAllowThreads(__tstate);
44859 if (PyErr_Occurred()) SWIG_fail;
44860 }
44861 resultobj = SWIG_Py_Void();
44862 {
44863 if (temp3)
44864 delete arg3;
44865 }
44866 return resultobj;
44867 fail:
44868 {
44869 if (temp3)
44870 delete arg3;
44871 }
44872 return NULL;
44873 }
44874
44875
44876 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44877 PyObject *resultobj = 0;
44878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44879 size_t arg2 ;
44880 wxString result;
44881 void *argp1 = 0 ;
44882 int res1 = 0 ;
44883 size_t val2 ;
44884 int ecode2 = 0 ;
44885 PyObject * obj0 = 0 ;
44886 PyObject * obj1 = 0 ;
44887 char * kwnames[] = {
44888 (char *) "self",(char *) "pos", NULL
44889 };
44890
44891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44893 if (!SWIG_IsOK(res1)) {
44894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44895 }
44896 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44897 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44898 if (!SWIG_IsOK(ecode2)) {
44899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44900 }
44901 arg2 = static_cast< size_t >(val2);
44902 {
44903 PyThreadState* __tstate = wxPyBeginAllowThreads();
44904 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44905 wxPyEndAllowThreads(__tstate);
44906 if (PyErr_Occurred()) SWIG_fail;
44907 }
44908 {
44909 #if wxUSE_UNICODE
44910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44911 #else
44912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44913 #endif
44914 }
44915 return resultobj;
44916 fail:
44917 return NULL;
44918 }
44919
44920
44921 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44922 PyObject *resultobj = 0;
44923 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44924 wxString *arg2 = 0 ;
44925 wxString *arg3 = 0 ;
44926 int result;
44927 void *argp1 = 0 ;
44928 int res1 = 0 ;
44929 bool temp2 = false ;
44930 bool temp3 = false ;
44931 PyObject * obj0 = 0 ;
44932 PyObject * obj1 = 0 ;
44933 PyObject * obj2 = 0 ;
44934 char * kwnames[] = {
44935 (char *) "self",(char *) "menu",(char *) "item", NULL
44936 };
44937
44938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44940 if (!SWIG_IsOK(res1)) {
44941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44942 }
44943 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44944 {
44945 arg2 = wxString_in_helper(obj1);
44946 if (arg2 == NULL) SWIG_fail;
44947 temp2 = true;
44948 }
44949 {
44950 arg3 = wxString_in_helper(obj2);
44951 if (arg3 == NULL) SWIG_fail;
44952 temp3 = true;
44953 }
44954 {
44955 PyThreadState* __tstate = wxPyBeginAllowThreads();
44956 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44957 wxPyEndAllowThreads(__tstate);
44958 if (PyErr_Occurred()) SWIG_fail;
44959 }
44960 resultobj = SWIG_From_int(static_cast< int >(result));
44961 {
44962 if (temp2)
44963 delete arg2;
44964 }
44965 {
44966 if (temp3)
44967 delete arg3;
44968 }
44969 return resultobj;
44970 fail:
44971 {
44972 if (temp2)
44973 delete arg2;
44974 }
44975 {
44976 if (temp3)
44977 delete arg3;
44978 }
44979 return NULL;
44980 }
44981
44982
44983 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44984 PyObject *resultobj = 0;
44985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44986 int arg2 ;
44987 wxMenuItem *result = 0 ;
44988 void *argp1 = 0 ;
44989 int res1 = 0 ;
44990 int val2 ;
44991 int ecode2 = 0 ;
44992 PyObject * obj0 = 0 ;
44993 PyObject * obj1 = 0 ;
44994 char * kwnames[] = {
44995 (char *) "self",(char *) "id", NULL
44996 };
44997
44998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45000 if (!SWIG_IsOK(res1)) {
45001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45002 }
45003 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45004 ecode2 = SWIG_AsVal_int(obj1, &val2);
45005 if (!SWIG_IsOK(ecode2)) {
45006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45007 }
45008 arg2 = static_cast< int >(val2);
45009 {
45010 PyThreadState* __tstate = wxPyBeginAllowThreads();
45011 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45012 wxPyEndAllowThreads(__tstate);
45013 if (PyErr_Occurred()) SWIG_fail;
45014 }
45015 {
45016 resultobj = wxPyMake_wxObject(result, (bool)0);
45017 }
45018 return resultobj;
45019 fail:
45020 return NULL;
45021 }
45022
45023
45024 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45025 PyObject *resultobj = 0;
45026 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45027 wxString *arg2 = 0 ;
45028 int result;
45029 void *argp1 = 0 ;
45030 int res1 = 0 ;
45031 bool temp2 = false ;
45032 PyObject * obj0 = 0 ;
45033 PyObject * obj1 = 0 ;
45034 char * kwnames[] = {
45035 (char *) "self",(char *) "title", NULL
45036 };
45037
45038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45040 if (!SWIG_IsOK(res1)) {
45041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45042 }
45043 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45044 {
45045 arg2 = wxString_in_helper(obj1);
45046 if (arg2 == NULL) SWIG_fail;
45047 temp2 = true;
45048 }
45049 {
45050 PyThreadState* __tstate = wxPyBeginAllowThreads();
45051 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45052 wxPyEndAllowThreads(__tstate);
45053 if (PyErr_Occurred()) SWIG_fail;
45054 }
45055 resultobj = SWIG_From_int(static_cast< int >(result));
45056 {
45057 if (temp2)
45058 delete arg2;
45059 }
45060 return resultobj;
45061 fail:
45062 {
45063 if (temp2)
45064 delete arg2;
45065 }
45066 return NULL;
45067 }
45068
45069
45070 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45071 PyObject *resultobj = 0;
45072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45073 int arg2 ;
45074 bool arg3 ;
45075 void *argp1 = 0 ;
45076 int res1 = 0 ;
45077 int val2 ;
45078 int ecode2 = 0 ;
45079 bool val3 ;
45080 int ecode3 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 PyObject * obj2 = 0 ;
45084 char * kwnames[] = {
45085 (char *) "self",(char *) "id",(char *) "enable", NULL
45086 };
45087
45088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45090 if (!SWIG_IsOK(res1)) {
45091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45092 }
45093 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45094 ecode2 = SWIG_AsVal_int(obj1, &val2);
45095 if (!SWIG_IsOK(ecode2)) {
45096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45097 }
45098 arg2 = static_cast< int >(val2);
45099 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45100 if (!SWIG_IsOK(ecode3)) {
45101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45102 }
45103 arg3 = static_cast< bool >(val3);
45104 {
45105 PyThreadState* __tstate = wxPyBeginAllowThreads();
45106 (arg1)->Enable(arg2,arg3);
45107 wxPyEndAllowThreads(__tstate);
45108 if (PyErr_Occurred()) SWIG_fail;
45109 }
45110 resultobj = SWIG_Py_Void();
45111 return resultobj;
45112 fail:
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45118 PyObject *resultobj = 0;
45119 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45120 int arg2 ;
45121 bool arg3 ;
45122 void *argp1 = 0 ;
45123 int res1 = 0 ;
45124 int val2 ;
45125 int ecode2 = 0 ;
45126 bool val3 ;
45127 int ecode3 = 0 ;
45128 PyObject * obj0 = 0 ;
45129 PyObject * obj1 = 0 ;
45130 PyObject * obj2 = 0 ;
45131 char * kwnames[] = {
45132 (char *) "self",(char *) "id",(char *) "check", NULL
45133 };
45134
45135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45137 if (!SWIG_IsOK(res1)) {
45138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45139 }
45140 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45141 ecode2 = SWIG_AsVal_int(obj1, &val2);
45142 if (!SWIG_IsOK(ecode2)) {
45143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45144 }
45145 arg2 = static_cast< int >(val2);
45146 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45147 if (!SWIG_IsOK(ecode3)) {
45148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45149 }
45150 arg3 = static_cast< bool >(val3);
45151 {
45152 PyThreadState* __tstate = wxPyBeginAllowThreads();
45153 (arg1)->Check(arg2,arg3);
45154 wxPyEndAllowThreads(__tstate);
45155 if (PyErr_Occurred()) SWIG_fail;
45156 }
45157 resultobj = SWIG_Py_Void();
45158 return resultobj;
45159 fail:
45160 return NULL;
45161 }
45162
45163
45164 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45165 PyObject *resultobj = 0;
45166 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45167 int arg2 ;
45168 bool result;
45169 void *argp1 = 0 ;
45170 int res1 = 0 ;
45171 int val2 ;
45172 int ecode2 = 0 ;
45173 PyObject * obj0 = 0 ;
45174 PyObject * obj1 = 0 ;
45175 char * kwnames[] = {
45176 (char *) "self",(char *) "id", NULL
45177 };
45178
45179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45181 if (!SWIG_IsOK(res1)) {
45182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45183 }
45184 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45185 ecode2 = SWIG_AsVal_int(obj1, &val2);
45186 if (!SWIG_IsOK(ecode2)) {
45187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45188 }
45189 arg2 = static_cast< int >(val2);
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45193 wxPyEndAllowThreads(__tstate);
45194 if (PyErr_Occurred()) SWIG_fail;
45195 }
45196 {
45197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45198 }
45199 return resultobj;
45200 fail:
45201 return NULL;
45202 }
45203
45204
45205 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45206 PyObject *resultobj = 0;
45207 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45208 int arg2 ;
45209 bool result;
45210 void *argp1 = 0 ;
45211 int res1 = 0 ;
45212 int val2 ;
45213 int ecode2 = 0 ;
45214 PyObject * obj0 = 0 ;
45215 PyObject * obj1 = 0 ;
45216 char * kwnames[] = {
45217 (char *) "self",(char *) "id", NULL
45218 };
45219
45220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45222 if (!SWIG_IsOK(res1)) {
45223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45224 }
45225 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45226 ecode2 = SWIG_AsVal_int(obj1, &val2);
45227 if (!SWIG_IsOK(ecode2)) {
45228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45229 }
45230 arg2 = static_cast< int >(val2);
45231 {
45232 PyThreadState* __tstate = wxPyBeginAllowThreads();
45233 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45234 wxPyEndAllowThreads(__tstate);
45235 if (PyErr_Occurred()) SWIG_fail;
45236 }
45237 {
45238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45239 }
45240 return resultobj;
45241 fail:
45242 return NULL;
45243 }
45244
45245
45246 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45247 PyObject *resultobj = 0;
45248 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45249 int arg2 ;
45250 wxString *arg3 = 0 ;
45251 void *argp1 = 0 ;
45252 int res1 = 0 ;
45253 int val2 ;
45254 int ecode2 = 0 ;
45255 bool temp3 = false ;
45256 PyObject * obj0 = 0 ;
45257 PyObject * obj1 = 0 ;
45258 PyObject * obj2 = 0 ;
45259 char * kwnames[] = {
45260 (char *) "self",(char *) "id",(char *) "label", NULL
45261 };
45262
45263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45265 if (!SWIG_IsOK(res1)) {
45266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45267 }
45268 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45269 ecode2 = SWIG_AsVal_int(obj1, &val2);
45270 if (!SWIG_IsOK(ecode2)) {
45271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45272 }
45273 arg2 = static_cast< int >(val2);
45274 {
45275 arg3 = wxString_in_helper(obj2);
45276 if (arg3 == NULL) SWIG_fail;
45277 temp3 = true;
45278 }
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45282 wxPyEndAllowThreads(__tstate);
45283 if (PyErr_Occurred()) SWIG_fail;
45284 }
45285 resultobj = SWIG_Py_Void();
45286 {
45287 if (temp3)
45288 delete arg3;
45289 }
45290 return resultobj;
45291 fail:
45292 {
45293 if (temp3)
45294 delete arg3;
45295 }
45296 return NULL;
45297 }
45298
45299
45300 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45301 PyObject *resultobj = 0;
45302 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45303 int arg2 ;
45304 wxString result;
45305 void *argp1 = 0 ;
45306 int res1 = 0 ;
45307 int val2 ;
45308 int ecode2 = 0 ;
45309 PyObject * obj0 = 0 ;
45310 PyObject * obj1 = 0 ;
45311 char * kwnames[] = {
45312 (char *) "self",(char *) "id", NULL
45313 };
45314
45315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45317 if (!SWIG_IsOK(res1)) {
45318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45319 }
45320 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45321 ecode2 = SWIG_AsVal_int(obj1, &val2);
45322 if (!SWIG_IsOK(ecode2)) {
45323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45324 }
45325 arg2 = static_cast< int >(val2);
45326 {
45327 PyThreadState* __tstate = wxPyBeginAllowThreads();
45328 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45329 wxPyEndAllowThreads(__tstate);
45330 if (PyErr_Occurred()) SWIG_fail;
45331 }
45332 {
45333 #if wxUSE_UNICODE
45334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45335 #else
45336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45337 #endif
45338 }
45339 return resultobj;
45340 fail:
45341 return NULL;
45342 }
45343
45344
45345 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45346 PyObject *resultobj = 0;
45347 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45348 int arg2 ;
45349 wxString *arg3 = 0 ;
45350 void *argp1 = 0 ;
45351 int res1 = 0 ;
45352 int val2 ;
45353 int ecode2 = 0 ;
45354 bool temp3 = false ;
45355 PyObject * obj0 = 0 ;
45356 PyObject * obj1 = 0 ;
45357 PyObject * obj2 = 0 ;
45358 char * kwnames[] = {
45359 (char *) "self",(char *) "id",(char *) "helpString", NULL
45360 };
45361
45362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45364 if (!SWIG_IsOK(res1)) {
45365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45366 }
45367 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45368 ecode2 = SWIG_AsVal_int(obj1, &val2);
45369 if (!SWIG_IsOK(ecode2)) {
45370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45371 }
45372 arg2 = static_cast< int >(val2);
45373 {
45374 arg3 = wxString_in_helper(obj2);
45375 if (arg3 == NULL) SWIG_fail;
45376 temp3 = true;
45377 }
45378 {
45379 PyThreadState* __tstate = wxPyBeginAllowThreads();
45380 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45381 wxPyEndAllowThreads(__tstate);
45382 if (PyErr_Occurred()) SWIG_fail;
45383 }
45384 resultobj = SWIG_Py_Void();
45385 {
45386 if (temp3)
45387 delete arg3;
45388 }
45389 return resultobj;
45390 fail:
45391 {
45392 if (temp3)
45393 delete arg3;
45394 }
45395 return NULL;
45396 }
45397
45398
45399 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45400 PyObject *resultobj = 0;
45401 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45402 int arg2 ;
45403 wxString result;
45404 void *argp1 = 0 ;
45405 int res1 = 0 ;
45406 int val2 ;
45407 int ecode2 = 0 ;
45408 PyObject * obj0 = 0 ;
45409 PyObject * obj1 = 0 ;
45410 char * kwnames[] = {
45411 (char *) "self",(char *) "id", NULL
45412 };
45413
45414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45416 if (!SWIG_IsOK(res1)) {
45417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45418 }
45419 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45420 ecode2 = SWIG_AsVal_int(obj1, &val2);
45421 if (!SWIG_IsOK(ecode2)) {
45422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45423 }
45424 arg2 = static_cast< int >(val2);
45425 {
45426 PyThreadState* __tstate = wxPyBeginAllowThreads();
45427 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45428 wxPyEndAllowThreads(__tstate);
45429 if (PyErr_Occurred()) SWIG_fail;
45430 }
45431 {
45432 #if wxUSE_UNICODE
45433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45434 #else
45435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45436 #endif
45437 }
45438 return resultobj;
45439 fail:
45440 return NULL;
45441 }
45442
45443
45444 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45445 PyObject *resultobj = 0;
45446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45447 wxFrame *result = 0 ;
45448 void *argp1 = 0 ;
45449 int res1 = 0 ;
45450 PyObject *swig_obj[1] ;
45451
45452 if (!args) SWIG_fail;
45453 swig_obj[0] = args;
45454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45455 if (!SWIG_IsOK(res1)) {
45456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45457 }
45458 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45459 {
45460 PyThreadState* __tstate = wxPyBeginAllowThreads();
45461 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45462 wxPyEndAllowThreads(__tstate);
45463 if (PyErr_Occurred()) SWIG_fail;
45464 }
45465 {
45466 resultobj = wxPyMake_wxObject(result, (bool)0);
45467 }
45468 return resultobj;
45469 fail:
45470 return NULL;
45471 }
45472
45473
45474 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45475 PyObject *resultobj = 0;
45476 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45477 bool result;
45478 void *argp1 = 0 ;
45479 int res1 = 0 ;
45480 PyObject *swig_obj[1] ;
45481
45482 if (!args) SWIG_fail;
45483 swig_obj[0] = args;
45484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45485 if (!SWIG_IsOK(res1)) {
45486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45487 }
45488 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45489 {
45490 PyThreadState* __tstate = wxPyBeginAllowThreads();
45491 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 {
45496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45497 }
45498 return resultobj;
45499 fail:
45500 return NULL;
45501 }
45502
45503
45504 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45505 PyObject *resultobj = 0;
45506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45507 wxFrame *arg2 = (wxFrame *) 0 ;
45508 void *argp1 = 0 ;
45509 int res1 = 0 ;
45510 void *argp2 = 0 ;
45511 int res2 = 0 ;
45512 PyObject * obj0 = 0 ;
45513 PyObject * obj1 = 0 ;
45514 char * kwnames[] = {
45515 (char *) "self",(char *) "frame", NULL
45516 };
45517
45518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45520 if (!SWIG_IsOK(res1)) {
45521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45522 }
45523 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45525 if (!SWIG_IsOK(res2)) {
45526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45527 }
45528 arg2 = reinterpret_cast< wxFrame * >(argp2);
45529 {
45530 PyThreadState* __tstate = wxPyBeginAllowThreads();
45531 (arg1)->Attach(arg2);
45532 wxPyEndAllowThreads(__tstate);
45533 if (PyErr_Occurred()) SWIG_fail;
45534 }
45535 resultobj = SWIG_Py_Void();
45536 return resultobj;
45537 fail:
45538 return NULL;
45539 }
45540
45541
45542 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45543 PyObject *resultobj = 0;
45544 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45545 void *argp1 = 0 ;
45546 int res1 = 0 ;
45547 PyObject *swig_obj[1] ;
45548
45549 if (!args) SWIG_fail;
45550 swig_obj[0] = args;
45551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45552 if (!SWIG_IsOK(res1)) {
45553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45554 }
45555 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45556 {
45557 PyThreadState* __tstate = wxPyBeginAllowThreads();
45558 (arg1)->Detach();
45559 wxPyEndAllowThreads(__tstate);
45560 if (PyErr_Occurred()) SWIG_fail;
45561 }
45562 resultobj = SWIG_Py_Void();
45563 return resultobj;
45564 fail:
45565 return NULL;
45566 }
45567
45568
45569 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45570 PyObject *resultobj = 0;
45571 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45572 void *argp1 = 0 ;
45573 int res1 = 0 ;
45574 PyObject *swig_obj[1] ;
45575
45576 if (!args) SWIG_fail;
45577 swig_obj[0] = args;
45578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45579 if (!SWIG_IsOK(res1)) {
45580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45581 }
45582 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45583 {
45584 PyThreadState* __tstate = wxPyBeginAllowThreads();
45585 (arg1)->UpdateMenus();
45586 wxPyEndAllowThreads(__tstate);
45587 if (PyErr_Occurred()) SWIG_fail;
45588 }
45589 resultobj = SWIG_Py_Void();
45590 return resultobj;
45591 fail:
45592 return NULL;
45593 }
45594
45595
45596 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45597 PyObject *resultobj = 0;
45598 bool arg1 ;
45599 bool val1 ;
45600 int ecode1 = 0 ;
45601 PyObject * obj0 = 0 ;
45602 char * kwnames[] = {
45603 (char *) "enable", NULL
45604 };
45605
45606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45607 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45608 if (!SWIG_IsOK(ecode1)) {
45609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45610 }
45611 arg1 = static_cast< bool >(val1);
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 wxMenuBar_SetAutoWindowMenu(arg1);
45615 wxPyEndAllowThreads(__tstate);
45616 if (PyErr_Occurred()) SWIG_fail;
45617 }
45618 resultobj = SWIG_Py_Void();
45619 return resultobj;
45620 fail:
45621 return NULL;
45622 }
45623
45624
45625 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45626 PyObject *resultobj = 0;
45627 bool result;
45628
45629 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45630 {
45631 PyThreadState* __tstate = wxPyBeginAllowThreads();
45632 result = (bool)wxMenuBar_GetAutoWindowMenu();
45633 wxPyEndAllowThreads(__tstate);
45634 if (PyErr_Occurred()) SWIG_fail;
45635 }
45636 {
45637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45638 }
45639 return resultobj;
45640 fail:
45641 return NULL;
45642 }
45643
45644
45645 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45646 PyObject *obj;
45647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45648 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45649 return SWIG_Py_Void();
45650 }
45651
45652 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45653 return SWIG_Python_InitShadowInstance(args);
45654 }
45655
45656 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45657 PyObject *resultobj = 0;
45658 wxMenu *arg1 = (wxMenu *) NULL ;
45659 int arg2 = (int) wxID_ANY ;
45660 wxString const &arg3_defvalue = wxPyEmptyString ;
45661 wxString *arg3 = (wxString *) &arg3_defvalue ;
45662 wxString const &arg4_defvalue = wxPyEmptyString ;
45663 wxString *arg4 = (wxString *) &arg4_defvalue ;
45664 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45665 wxMenu *arg6 = (wxMenu *) NULL ;
45666 wxMenuItem *result = 0 ;
45667 void *argp1 = 0 ;
45668 int res1 = 0 ;
45669 int val2 ;
45670 int ecode2 = 0 ;
45671 bool temp3 = false ;
45672 bool temp4 = false ;
45673 int val5 ;
45674 int ecode5 = 0 ;
45675 void *argp6 = 0 ;
45676 int res6 = 0 ;
45677 PyObject * obj0 = 0 ;
45678 PyObject * obj1 = 0 ;
45679 PyObject * obj2 = 0 ;
45680 PyObject * obj3 = 0 ;
45681 PyObject * obj4 = 0 ;
45682 PyObject * obj5 = 0 ;
45683 char * kwnames[] = {
45684 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45685 };
45686
45687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45688 if (obj0) {
45689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45690 if (!SWIG_IsOK(res1)) {
45691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45692 }
45693 arg1 = reinterpret_cast< wxMenu * >(argp1);
45694 }
45695 if (obj1) {
45696 ecode2 = SWIG_AsVal_int(obj1, &val2);
45697 if (!SWIG_IsOK(ecode2)) {
45698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45699 }
45700 arg2 = static_cast< int >(val2);
45701 }
45702 if (obj2) {
45703 {
45704 arg3 = wxString_in_helper(obj2);
45705 if (arg3 == NULL) SWIG_fail;
45706 temp3 = true;
45707 }
45708 }
45709 if (obj3) {
45710 {
45711 arg4 = wxString_in_helper(obj3);
45712 if (arg4 == NULL) SWIG_fail;
45713 temp4 = true;
45714 }
45715 }
45716 if (obj4) {
45717 ecode5 = SWIG_AsVal_int(obj4, &val5);
45718 if (!SWIG_IsOK(ecode5)) {
45719 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45720 }
45721 arg5 = static_cast< wxItemKind >(val5);
45722 }
45723 if (obj5) {
45724 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45725 if (!SWIG_IsOK(res6)) {
45726 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45727 }
45728 arg6 = reinterpret_cast< wxMenu * >(argp6);
45729 }
45730 {
45731 PyThreadState* __tstate = wxPyBeginAllowThreads();
45732 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45733 wxPyEndAllowThreads(__tstate);
45734 if (PyErr_Occurred()) SWIG_fail;
45735 }
45736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45737 {
45738 if (temp3)
45739 delete arg3;
45740 }
45741 {
45742 if (temp4)
45743 delete arg4;
45744 }
45745 return resultobj;
45746 fail:
45747 {
45748 if (temp3)
45749 delete arg3;
45750 }
45751 {
45752 if (temp4)
45753 delete arg4;
45754 }
45755 return NULL;
45756 }
45757
45758
45759 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45760 PyObject *resultobj = 0;
45761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45762 void *argp1 = 0 ;
45763 int res1 = 0 ;
45764 PyObject *swig_obj[1] ;
45765
45766 if (!args) SWIG_fail;
45767 swig_obj[0] = args;
45768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45771 }
45772 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45773 {
45774 PyThreadState* __tstate = wxPyBeginAllowThreads();
45775 delete arg1;
45776
45777 wxPyEndAllowThreads(__tstate);
45778 if (PyErr_Occurred()) SWIG_fail;
45779 }
45780 resultobj = SWIG_Py_Void();
45781 return resultobj;
45782 fail:
45783 return NULL;
45784 }
45785
45786
45787 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45788 PyObject *resultobj = 0;
45789 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45790 wxMenu *result = 0 ;
45791 void *argp1 = 0 ;
45792 int res1 = 0 ;
45793 PyObject *swig_obj[1] ;
45794
45795 if (!args) SWIG_fail;
45796 swig_obj[0] = args;
45797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45800 }
45801 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 {
45809 resultobj = wxPyMake_wxObject(result, 0);
45810 }
45811 return resultobj;
45812 fail:
45813 return NULL;
45814 }
45815
45816
45817 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45818 PyObject *resultobj = 0;
45819 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45820 wxMenu *arg2 = (wxMenu *) 0 ;
45821 void *argp1 = 0 ;
45822 int res1 = 0 ;
45823 void *argp2 = 0 ;
45824 int res2 = 0 ;
45825 PyObject * obj0 = 0 ;
45826 PyObject * obj1 = 0 ;
45827 char * kwnames[] = {
45828 (char *) "self",(char *) "menu", NULL
45829 };
45830
45831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45833 if (!SWIG_IsOK(res1)) {
45834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45835 }
45836 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45838 if (!SWIG_IsOK(res2)) {
45839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45840 }
45841 arg2 = reinterpret_cast< wxMenu * >(argp2);
45842 {
45843 PyThreadState* __tstate = wxPyBeginAllowThreads();
45844 (arg1)->SetMenu(arg2);
45845 wxPyEndAllowThreads(__tstate);
45846 if (PyErr_Occurred()) SWIG_fail;
45847 }
45848 resultobj = SWIG_Py_Void();
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj = 0;
45857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45858 int arg2 ;
45859 void *argp1 = 0 ;
45860 int res1 = 0 ;
45861 int val2 ;
45862 int ecode2 = 0 ;
45863 PyObject * obj0 = 0 ;
45864 PyObject * obj1 = 0 ;
45865 char * kwnames[] = {
45866 (char *) "self",(char *) "id", NULL
45867 };
45868
45869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45871 if (!SWIG_IsOK(res1)) {
45872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45873 }
45874 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45875 ecode2 = SWIG_AsVal_int(obj1, &val2);
45876 if (!SWIG_IsOK(ecode2)) {
45877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45878 }
45879 arg2 = static_cast< int >(val2);
45880 {
45881 PyThreadState* __tstate = wxPyBeginAllowThreads();
45882 (arg1)->SetId(arg2);
45883 wxPyEndAllowThreads(__tstate);
45884 if (PyErr_Occurred()) SWIG_fail;
45885 }
45886 resultobj = SWIG_Py_Void();
45887 return resultobj;
45888 fail:
45889 return NULL;
45890 }
45891
45892
45893 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45894 PyObject *resultobj = 0;
45895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45896 int result;
45897 void *argp1 = 0 ;
45898 int res1 = 0 ;
45899 PyObject *swig_obj[1] ;
45900
45901 if (!args) SWIG_fail;
45902 swig_obj[0] = args;
45903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45904 if (!SWIG_IsOK(res1)) {
45905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45906 }
45907 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 result = (int)((wxMenuItem const *)arg1)->GetId();
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 resultobj = SWIG_From_int(static_cast< int >(result));
45915 return resultobj;
45916 fail:
45917 return NULL;
45918 }
45919
45920
45921 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45922 PyObject *resultobj = 0;
45923 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45924 bool result;
45925 void *argp1 = 0 ;
45926 int res1 = 0 ;
45927 PyObject *swig_obj[1] ;
45928
45929 if (!args) SWIG_fail;
45930 swig_obj[0] = args;
45931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45932 if (!SWIG_IsOK(res1)) {
45933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45934 }
45935 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45936 {
45937 PyThreadState* __tstate = wxPyBeginAllowThreads();
45938 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45939 wxPyEndAllowThreads(__tstate);
45940 if (PyErr_Occurred()) SWIG_fail;
45941 }
45942 {
45943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45944 }
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45952 PyObject *resultobj = 0;
45953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45954 wxString *arg2 = 0 ;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 bool temp2 = false ;
45958 PyObject * obj0 = 0 ;
45959 PyObject * obj1 = 0 ;
45960 char * kwnames[] = {
45961 (char *) "self",(char *) "str", NULL
45962 };
45963
45964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45966 if (!SWIG_IsOK(res1)) {
45967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45968 }
45969 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45970 {
45971 arg2 = wxString_in_helper(obj1);
45972 if (arg2 == NULL) SWIG_fail;
45973 temp2 = true;
45974 }
45975 {
45976 PyThreadState* __tstate = wxPyBeginAllowThreads();
45977 (arg1)->SetText((wxString const &)*arg2);
45978 wxPyEndAllowThreads(__tstate);
45979 if (PyErr_Occurred()) SWIG_fail;
45980 }
45981 resultobj = SWIG_Py_Void();
45982 {
45983 if (temp2)
45984 delete arg2;
45985 }
45986 return resultobj;
45987 fail:
45988 {
45989 if (temp2)
45990 delete arg2;
45991 }
45992 return NULL;
45993 }
45994
45995
45996 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45997 PyObject *resultobj = 0;
45998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45999 wxString result;
46000 void *argp1 = 0 ;
46001 int res1 = 0 ;
46002 PyObject *swig_obj[1] ;
46003
46004 if (!args) SWIG_fail;
46005 swig_obj[0] = args;
46006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46007 if (!SWIG_IsOK(res1)) {
46008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46009 }
46010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46011 {
46012 PyThreadState* __tstate = wxPyBeginAllowThreads();
46013 result = ((wxMenuItem const *)arg1)->GetLabel();
46014 wxPyEndAllowThreads(__tstate);
46015 if (PyErr_Occurred()) SWIG_fail;
46016 }
46017 {
46018 #if wxUSE_UNICODE
46019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46020 #else
46021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46022 #endif
46023 }
46024 return resultobj;
46025 fail:
46026 return NULL;
46027 }
46028
46029
46030 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46031 PyObject *resultobj = 0;
46032 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46033 wxString *result = 0 ;
46034 void *argp1 = 0 ;
46035 int res1 = 0 ;
46036 PyObject *swig_obj[1] ;
46037
46038 if (!args) SWIG_fail;
46039 swig_obj[0] = args;
46040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46041 if (!SWIG_IsOK(res1)) {
46042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46043 }
46044 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46045 {
46046 PyThreadState* __tstate = wxPyBeginAllowThreads();
46047 {
46048 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46049 result = (wxString *) &_result_ref;
46050 }
46051 wxPyEndAllowThreads(__tstate);
46052 if (PyErr_Occurred()) SWIG_fail;
46053 }
46054 {
46055 #if wxUSE_UNICODE
46056 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46057 #else
46058 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46059 #endif
46060 }
46061 return resultobj;
46062 fail:
46063 return NULL;
46064 }
46065
46066
46067 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46068 PyObject *resultobj = 0;
46069 wxString *arg1 = 0 ;
46070 wxString result;
46071 bool temp1 = false ;
46072 PyObject * obj0 = 0 ;
46073 char * kwnames[] = {
46074 (char *) "text", NULL
46075 };
46076
46077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46078 {
46079 arg1 = wxString_in_helper(obj0);
46080 if (arg1 == NULL) SWIG_fail;
46081 temp1 = true;
46082 }
46083 {
46084 PyThreadState* __tstate = wxPyBeginAllowThreads();
46085 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46086 wxPyEndAllowThreads(__tstate);
46087 if (PyErr_Occurred()) SWIG_fail;
46088 }
46089 {
46090 #if wxUSE_UNICODE
46091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46092 #else
46093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46094 #endif
46095 }
46096 {
46097 if (temp1)
46098 delete arg1;
46099 }
46100 return resultobj;
46101 fail:
46102 {
46103 if (temp1)
46104 delete arg1;
46105 }
46106 return NULL;
46107 }
46108
46109
46110 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46111 PyObject *resultobj = 0;
46112 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46113 wxItemKind result;
46114 void *argp1 = 0 ;
46115 int res1 = 0 ;
46116 PyObject *swig_obj[1] ;
46117
46118 if (!args) SWIG_fail;
46119 swig_obj[0] = args;
46120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46121 if (!SWIG_IsOK(res1)) {
46122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46123 }
46124 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46125 {
46126 PyThreadState* __tstate = wxPyBeginAllowThreads();
46127 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46128 wxPyEndAllowThreads(__tstate);
46129 if (PyErr_Occurred()) SWIG_fail;
46130 }
46131 resultobj = SWIG_From_int(static_cast< int >(result));
46132 return resultobj;
46133 fail:
46134 return NULL;
46135 }
46136
46137
46138 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46139 PyObject *resultobj = 0;
46140 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46141 wxItemKind arg2 ;
46142 void *argp1 = 0 ;
46143 int res1 = 0 ;
46144 int val2 ;
46145 int ecode2 = 0 ;
46146 PyObject * obj0 = 0 ;
46147 PyObject * obj1 = 0 ;
46148 char * kwnames[] = {
46149 (char *) "self",(char *) "kind", NULL
46150 };
46151
46152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46154 if (!SWIG_IsOK(res1)) {
46155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46156 }
46157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46158 ecode2 = SWIG_AsVal_int(obj1, &val2);
46159 if (!SWIG_IsOK(ecode2)) {
46160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46161 }
46162 arg2 = static_cast< wxItemKind >(val2);
46163 {
46164 PyThreadState* __tstate = wxPyBeginAllowThreads();
46165 (arg1)->SetKind(arg2);
46166 wxPyEndAllowThreads(__tstate);
46167 if (PyErr_Occurred()) SWIG_fail;
46168 }
46169 resultobj = SWIG_Py_Void();
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46179 bool arg2 ;
46180 void *argp1 = 0 ;
46181 int res1 = 0 ;
46182 bool val2 ;
46183 int ecode2 = 0 ;
46184 PyObject * obj0 = 0 ;
46185 PyObject * obj1 = 0 ;
46186 char * kwnames[] = {
46187 (char *) "self",(char *) "checkable", NULL
46188 };
46189
46190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46192 if (!SWIG_IsOK(res1)) {
46193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46194 }
46195 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46196 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46197 if (!SWIG_IsOK(ecode2)) {
46198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46199 }
46200 arg2 = static_cast< bool >(val2);
46201 {
46202 PyThreadState* __tstate = wxPyBeginAllowThreads();
46203 (arg1)->SetCheckable(arg2);
46204 wxPyEndAllowThreads(__tstate);
46205 if (PyErr_Occurred()) SWIG_fail;
46206 }
46207 resultobj = SWIG_Py_Void();
46208 return resultobj;
46209 fail:
46210 return NULL;
46211 }
46212
46213
46214 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46215 PyObject *resultobj = 0;
46216 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46217 bool result;
46218 void *argp1 = 0 ;
46219 int res1 = 0 ;
46220 PyObject *swig_obj[1] ;
46221
46222 if (!args) SWIG_fail;
46223 swig_obj[0] = args;
46224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46225 if (!SWIG_IsOK(res1)) {
46226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46227 }
46228 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46229 {
46230 PyThreadState* __tstate = wxPyBeginAllowThreads();
46231 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46232 wxPyEndAllowThreads(__tstate);
46233 if (PyErr_Occurred()) SWIG_fail;
46234 }
46235 {
46236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46237 }
46238 return resultobj;
46239 fail:
46240 return NULL;
46241 }
46242
46243
46244 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46245 PyObject *resultobj = 0;
46246 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46247 bool result;
46248 void *argp1 = 0 ;
46249 int res1 = 0 ;
46250 PyObject *swig_obj[1] ;
46251
46252 if (!args) SWIG_fail;
46253 swig_obj[0] = args;
46254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46255 if (!SWIG_IsOK(res1)) {
46256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46257 }
46258 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46259 {
46260 PyThreadState* __tstate = wxPyBeginAllowThreads();
46261 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46262 wxPyEndAllowThreads(__tstate);
46263 if (PyErr_Occurred()) SWIG_fail;
46264 }
46265 {
46266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46267 }
46268 return resultobj;
46269 fail:
46270 return NULL;
46271 }
46272
46273
46274 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46275 PyObject *resultobj = 0;
46276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46277 wxMenu *arg2 = (wxMenu *) 0 ;
46278 void *argp1 = 0 ;
46279 int res1 = 0 ;
46280 void *argp2 = 0 ;
46281 int res2 = 0 ;
46282 PyObject * obj0 = 0 ;
46283 PyObject * obj1 = 0 ;
46284 char * kwnames[] = {
46285 (char *) "self",(char *) "menu", NULL
46286 };
46287
46288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46290 if (!SWIG_IsOK(res1)) {
46291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46292 }
46293 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46295 if (!SWIG_IsOK(res2)) {
46296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46297 }
46298 arg2 = reinterpret_cast< wxMenu * >(argp2);
46299 {
46300 PyThreadState* __tstate = wxPyBeginAllowThreads();
46301 (arg1)->SetSubMenu(arg2);
46302 wxPyEndAllowThreads(__tstate);
46303 if (PyErr_Occurred()) SWIG_fail;
46304 }
46305 resultobj = SWIG_Py_Void();
46306 return resultobj;
46307 fail:
46308 return NULL;
46309 }
46310
46311
46312 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46313 PyObject *resultobj = 0;
46314 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46315 wxMenu *result = 0 ;
46316 void *argp1 = 0 ;
46317 int res1 = 0 ;
46318 PyObject *swig_obj[1] ;
46319
46320 if (!args) SWIG_fail;
46321 swig_obj[0] = args;
46322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46323 if (!SWIG_IsOK(res1)) {
46324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46325 }
46326 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46327 {
46328 PyThreadState* __tstate = wxPyBeginAllowThreads();
46329 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46330 wxPyEndAllowThreads(__tstate);
46331 if (PyErr_Occurred()) SWIG_fail;
46332 }
46333 {
46334 resultobj = wxPyMake_wxObject(result, 0);
46335 }
46336 return resultobj;
46337 fail:
46338 return NULL;
46339 }
46340
46341
46342 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46343 PyObject *resultobj = 0;
46344 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46345 bool arg2 = (bool) true ;
46346 void *argp1 = 0 ;
46347 int res1 = 0 ;
46348 bool val2 ;
46349 int ecode2 = 0 ;
46350 PyObject * obj0 = 0 ;
46351 PyObject * obj1 = 0 ;
46352 char * kwnames[] = {
46353 (char *) "self",(char *) "enable", NULL
46354 };
46355
46356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46358 if (!SWIG_IsOK(res1)) {
46359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46360 }
46361 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46362 if (obj1) {
46363 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46364 if (!SWIG_IsOK(ecode2)) {
46365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46366 }
46367 arg2 = static_cast< bool >(val2);
46368 }
46369 {
46370 PyThreadState* __tstate = wxPyBeginAllowThreads();
46371 (arg1)->Enable(arg2);
46372 wxPyEndAllowThreads(__tstate);
46373 if (PyErr_Occurred()) SWIG_fail;
46374 }
46375 resultobj = SWIG_Py_Void();
46376 return resultobj;
46377 fail:
46378 return NULL;
46379 }
46380
46381
46382 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46383 PyObject *resultobj = 0;
46384 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46385 bool result;
46386 void *argp1 = 0 ;
46387 int res1 = 0 ;
46388 PyObject *swig_obj[1] ;
46389
46390 if (!args) SWIG_fail;
46391 swig_obj[0] = args;
46392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46393 if (!SWIG_IsOK(res1)) {
46394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46395 }
46396 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46397 {
46398 PyThreadState* __tstate = wxPyBeginAllowThreads();
46399 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46400 wxPyEndAllowThreads(__tstate);
46401 if (PyErr_Occurred()) SWIG_fail;
46402 }
46403 {
46404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46405 }
46406 return resultobj;
46407 fail:
46408 return NULL;
46409 }
46410
46411
46412 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46413 PyObject *resultobj = 0;
46414 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46415 bool arg2 = (bool) true ;
46416 void *argp1 = 0 ;
46417 int res1 = 0 ;
46418 bool val2 ;
46419 int ecode2 = 0 ;
46420 PyObject * obj0 = 0 ;
46421 PyObject * obj1 = 0 ;
46422 char * kwnames[] = {
46423 (char *) "self",(char *) "check", NULL
46424 };
46425
46426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46428 if (!SWIG_IsOK(res1)) {
46429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46430 }
46431 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46432 if (obj1) {
46433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46434 if (!SWIG_IsOK(ecode2)) {
46435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46436 }
46437 arg2 = static_cast< bool >(val2);
46438 }
46439 {
46440 PyThreadState* __tstate = wxPyBeginAllowThreads();
46441 (arg1)->Check(arg2);
46442 wxPyEndAllowThreads(__tstate);
46443 if (PyErr_Occurred()) SWIG_fail;
46444 }
46445 resultobj = SWIG_Py_Void();
46446 return resultobj;
46447 fail:
46448 return NULL;
46449 }
46450
46451
46452 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46453 PyObject *resultobj = 0;
46454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46455 bool result;
46456 void *argp1 = 0 ;
46457 int res1 = 0 ;
46458 PyObject *swig_obj[1] ;
46459
46460 if (!args) SWIG_fail;
46461 swig_obj[0] = args;
46462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46463 if (!SWIG_IsOK(res1)) {
46464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46465 }
46466 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46467 {
46468 PyThreadState* __tstate = wxPyBeginAllowThreads();
46469 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46470 wxPyEndAllowThreads(__tstate);
46471 if (PyErr_Occurred()) SWIG_fail;
46472 }
46473 {
46474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46475 }
46476 return resultobj;
46477 fail:
46478 return NULL;
46479 }
46480
46481
46482 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46483 PyObject *resultobj = 0;
46484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46485 void *argp1 = 0 ;
46486 int res1 = 0 ;
46487 PyObject *swig_obj[1] ;
46488
46489 if (!args) SWIG_fail;
46490 swig_obj[0] = args;
46491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46492 if (!SWIG_IsOK(res1)) {
46493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46494 }
46495 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46496 {
46497 PyThreadState* __tstate = wxPyBeginAllowThreads();
46498 (arg1)->Toggle();
46499 wxPyEndAllowThreads(__tstate);
46500 if (PyErr_Occurred()) SWIG_fail;
46501 }
46502 resultobj = SWIG_Py_Void();
46503 return resultobj;
46504 fail:
46505 return NULL;
46506 }
46507
46508
46509 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46510 PyObject *resultobj = 0;
46511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46512 wxString *arg2 = 0 ;
46513 void *argp1 = 0 ;
46514 int res1 = 0 ;
46515 bool temp2 = false ;
46516 PyObject * obj0 = 0 ;
46517 PyObject * obj1 = 0 ;
46518 char * kwnames[] = {
46519 (char *) "self",(char *) "str", NULL
46520 };
46521
46522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46524 if (!SWIG_IsOK(res1)) {
46525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46526 }
46527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46528 {
46529 arg2 = wxString_in_helper(obj1);
46530 if (arg2 == NULL) SWIG_fail;
46531 temp2 = true;
46532 }
46533 {
46534 PyThreadState* __tstate = wxPyBeginAllowThreads();
46535 (arg1)->SetHelp((wxString const &)*arg2);
46536 wxPyEndAllowThreads(__tstate);
46537 if (PyErr_Occurred()) SWIG_fail;
46538 }
46539 resultobj = SWIG_Py_Void();
46540 {
46541 if (temp2)
46542 delete arg2;
46543 }
46544 return resultobj;
46545 fail:
46546 {
46547 if (temp2)
46548 delete arg2;
46549 }
46550 return NULL;
46551 }
46552
46553
46554 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46555 PyObject *resultobj = 0;
46556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46557 wxString *result = 0 ;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 PyObject *swig_obj[1] ;
46561
46562 if (!args) SWIG_fail;
46563 swig_obj[0] = args;
46564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46565 if (!SWIG_IsOK(res1)) {
46566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46567 }
46568 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46569 {
46570 PyThreadState* __tstate = wxPyBeginAllowThreads();
46571 {
46572 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46573 result = (wxString *) &_result_ref;
46574 }
46575 wxPyEndAllowThreads(__tstate);
46576 if (PyErr_Occurred()) SWIG_fail;
46577 }
46578 {
46579 #if wxUSE_UNICODE
46580 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46581 #else
46582 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46583 #endif
46584 }
46585 return resultobj;
46586 fail:
46587 return NULL;
46588 }
46589
46590
46591 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46592 PyObject *resultobj = 0;
46593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46594 wxAcceleratorEntry *result = 0 ;
46595 void *argp1 = 0 ;
46596 int res1 = 0 ;
46597 PyObject *swig_obj[1] ;
46598
46599 if (!args) SWIG_fail;
46600 swig_obj[0] = args;
46601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46602 if (!SWIG_IsOK(res1)) {
46603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46604 }
46605 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46606 {
46607 PyThreadState* __tstate = wxPyBeginAllowThreads();
46608 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46609 wxPyEndAllowThreads(__tstate);
46610 if (PyErr_Occurred()) SWIG_fail;
46611 }
46612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46613 return resultobj;
46614 fail:
46615 return NULL;
46616 }
46617
46618
46619 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46620 PyObject *resultobj = 0;
46621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46622 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46623 void *argp1 = 0 ;
46624 int res1 = 0 ;
46625 void *argp2 = 0 ;
46626 int res2 = 0 ;
46627 PyObject * obj0 = 0 ;
46628 PyObject * obj1 = 0 ;
46629 char * kwnames[] = {
46630 (char *) "self",(char *) "accel", NULL
46631 };
46632
46633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46635 if (!SWIG_IsOK(res1)) {
46636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46637 }
46638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46640 if (!SWIG_IsOK(res2)) {
46641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46642 }
46643 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46644 {
46645 PyThreadState* __tstate = wxPyBeginAllowThreads();
46646 (arg1)->SetAccel(arg2);
46647 wxPyEndAllowThreads(__tstate);
46648 if (PyErr_Occurred()) SWIG_fail;
46649 }
46650 resultobj = SWIG_Py_Void();
46651 return resultobj;
46652 fail:
46653 return NULL;
46654 }
46655
46656
46657 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46658 PyObject *resultobj = 0;
46659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46660 wxBitmap *arg2 = 0 ;
46661 void *argp1 = 0 ;
46662 int res1 = 0 ;
46663 void *argp2 = 0 ;
46664 int res2 = 0 ;
46665 PyObject * obj0 = 0 ;
46666 PyObject * obj1 = 0 ;
46667 char * kwnames[] = {
46668 (char *) "self",(char *) "bitmap", NULL
46669 };
46670
46671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46673 if (!SWIG_IsOK(res1)) {
46674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46675 }
46676 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46677 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46678 if (!SWIG_IsOK(res2)) {
46679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46680 }
46681 if (!argp2) {
46682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46683 }
46684 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46685 {
46686 PyThreadState* __tstate = wxPyBeginAllowThreads();
46687 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46688 wxPyEndAllowThreads(__tstate);
46689 if (PyErr_Occurred()) SWIG_fail;
46690 }
46691 resultobj = SWIG_Py_Void();
46692 return resultobj;
46693 fail:
46694 return NULL;
46695 }
46696
46697
46698 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46699 PyObject *resultobj = 0;
46700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46701 wxBitmap *result = 0 ;
46702 void *argp1 = 0 ;
46703 int res1 = 0 ;
46704 PyObject *swig_obj[1] ;
46705
46706 if (!args) SWIG_fail;
46707 swig_obj[0] = args;
46708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46709 if (!SWIG_IsOK(res1)) {
46710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46711 }
46712 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46713 {
46714 PyThreadState* __tstate = wxPyBeginAllowThreads();
46715 {
46716 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46717 result = (wxBitmap *) &_result_ref;
46718 }
46719 wxPyEndAllowThreads(__tstate);
46720 if (PyErr_Occurred()) SWIG_fail;
46721 }
46722 {
46723 wxBitmap* resultptr = new wxBitmap(*result);
46724 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46725 }
46726 return resultobj;
46727 fail:
46728 return NULL;
46729 }
46730
46731
46732 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46733 PyObject *resultobj = 0;
46734 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46735 wxFont *arg2 = 0 ;
46736 void *argp1 = 0 ;
46737 int res1 = 0 ;
46738 void *argp2 = 0 ;
46739 int res2 = 0 ;
46740 PyObject * obj0 = 0 ;
46741 PyObject * obj1 = 0 ;
46742 char * kwnames[] = {
46743 (char *) "self",(char *) "font", NULL
46744 };
46745
46746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46748 if (!SWIG_IsOK(res1)) {
46749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46750 }
46751 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46753 if (!SWIG_IsOK(res2)) {
46754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46755 }
46756 if (!argp2) {
46757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46758 }
46759 arg2 = reinterpret_cast< wxFont * >(argp2);
46760 {
46761 PyThreadState* __tstate = wxPyBeginAllowThreads();
46762 (arg1)->SetFont((wxFont const &)*arg2);
46763 wxPyEndAllowThreads(__tstate);
46764 if (PyErr_Occurred()) SWIG_fail;
46765 }
46766 resultobj = SWIG_Py_Void();
46767 return resultobj;
46768 fail:
46769 return NULL;
46770 }
46771
46772
46773 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46774 PyObject *resultobj = 0;
46775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46776 wxFont result;
46777 void *argp1 = 0 ;
46778 int res1 = 0 ;
46779 PyObject *swig_obj[1] ;
46780
46781 if (!args) SWIG_fail;
46782 swig_obj[0] = args;
46783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46784 if (!SWIG_IsOK(res1)) {
46785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46786 }
46787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46788 {
46789 PyThreadState* __tstate = wxPyBeginAllowThreads();
46790 result = (arg1)->GetFont();
46791 wxPyEndAllowThreads(__tstate);
46792 if (PyErr_Occurred()) SWIG_fail;
46793 }
46794 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46795 return resultobj;
46796 fail:
46797 return NULL;
46798 }
46799
46800
46801 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46802 PyObject *resultobj = 0;
46803 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46804 wxColour *arg2 = 0 ;
46805 void *argp1 = 0 ;
46806 int res1 = 0 ;
46807 wxColour temp2 ;
46808 PyObject * obj0 = 0 ;
46809 PyObject * obj1 = 0 ;
46810 char * kwnames[] = {
46811 (char *) "self",(char *) "colText", NULL
46812 };
46813
46814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46818 }
46819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46820 {
46821 arg2 = &temp2;
46822 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46823 }
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 (arg1)->SetTextColour((wxColour 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_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46838 PyObject *resultobj = 0;
46839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46840 wxColour result;
46841 void *argp1 = 0 ;
46842 int res1 = 0 ;
46843 PyObject *swig_obj[1] ;
46844
46845 if (!args) SWIG_fail;
46846 swig_obj[0] = args;
46847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46848 if (!SWIG_IsOK(res1)) {
46849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46850 }
46851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46852 {
46853 PyThreadState* __tstate = wxPyBeginAllowThreads();
46854 result = (arg1)->GetTextColour();
46855 wxPyEndAllowThreads(__tstate);
46856 if (PyErr_Occurred()) SWIG_fail;
46857 }
46858 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46859 return resultobj;
46860 fail:
46861 return NULL;
46862 }
46863
46864
46865 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46866 PyObject *resultobj = 0;
46867 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46868 wxColour *arg2 = 0 ;
46869 void *argp1 = 0 ;
46870 int res1 = 0 ;
46871 wxColour temp2 ;
46872 PyObject * obj0 = 0 ;
46873 PyObject * obj1 = 0 ;
46874 char * kwnames[] = {
46875 (char *) "self",(char *) "colBack", NULL
46876 };
46877
46878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46880 if (!SWIG_IsOK(res1)) {
46881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46882 }
46883 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46884 {
46885 arg2 = &temp2;
46886 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46887 }
46888 {
46889 PyThreadState* __tstate = wxPyBeginAllowThreads();
46890 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46891 wxPyEndAllowThreads(__tstate);
46892 if (PyErr_Occurred()) SWIG_fail;
46893 }
46894 resultobj = SWIG_Py_Void();
46895 return resultobj;
46896 fail:
46897 return NULL;
46898 }
46899
46900
46901 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46902 PyObject *resultobj = 0;
46903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46904 wxColour result;
46905 void *argp1 = 0 ;
46906 int res1 = 0 ;
46907 PyObject *swig_obj[1] ;
46908
46909 if (!args) SWIG_fail;
46910 swig_obj[0] = args;
46911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46912 if (!SWIG_IsOK(res1)) {
46913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46914 }
46915 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46916 {
46917 PyThreadState* __tstate = wxPyBeginAllowThreads();
46918 result = (arg1)->GetBackgroundColour();
46919 wxPyEndAllowThreads(__tstate);
46920 if (PyErr_Occurred()) SWIG_fail;
46921 }
46922 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46923 return resultobj;
46924 fail:
46925 return NULL;
46926 }
46927
46928
46929 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46930 PyObject *resultobj = 0;
46931 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46932 wxBitmap *arg2 = 0 ;
46933 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46934 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46935 void *argp1 = 0 ;
46936 int res1 = 0 ;
46937 void *argp2 = 0 ;
46938 int res2 = 0 ;
46939 void *argp3 = 0 ;
46940 int res3 = 0 ;
46941 PyObject * obj0 = 0 ;
46942 PyObject * obj1 = 0 ;
46943 PyObject * obj2 = 0 ;
46944 char * kwnames[] = {
46945 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46946 };
46947
46948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46950 if (!SWIG_IsOK(res1)) {
46951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46952 }
46953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46954 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46955 if (!SWIG_IsOK(res2)) {
46956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46957 }
46958 if (!argp2) {
46959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46960 }
46961 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46962 if (obj2) {
46963 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46964 if (!SWIG_IsOK(res3)) {
46965 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46966 }
46967 if (!argp3) {
46968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46969 }
46970 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46971 }
46972 {
46973 PyThreadState* __tstate = wxPyBeginAllowThreads();
46974 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46975 wxPyEndAllowThreads(__tstate);
46976 if (PyErr_Occurred()) SWIG_fail;
46977 }
46978 resultobj = SWIG_Py_Void();
46979 return resultobj;
46980 fail:
46981 return NULL;
46982 }
46983
46984
46985 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46986 PyObject *resultobj = 0;
46987 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46988 wxBitmap *arg2 = 0 ;
46989 void *argp1 = 0 ;
46990 int res1 = 0 ;
46991 void *argp2 = 0 ;
46992 int res2 = 0 ;
46993 PyObject * obj0 = 0 ;
46994 PyObject * obj1 = 0 ;
46995 char * kwnames[] = {
46996 (char *) "self",(char *) "bmpDisabled", NULL
46997 };
46998
46999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47001 if (!SWIG_IsOK(res1)) {
47002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47003 }
47004 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47006 if (!SWIG_IsOK(res2)) {
47007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47008 }
47009 if (!argp2) {
47010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47011 }
47012 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47013 {
47014 PyThreadState* __tstate = wxPyBeginAllowThreads();
47015 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47016 wxPyEndAllowThreads(__tstate);
47017 if (PyErr_Occurred()) SWIG_fail;
47018 }
47019 resultobj = SWIG_Py_Void();
47020 return resultobj;
47021 fail:
47022 return NULL;
47023 }
47024
47025
47026 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47027 PyObject *resultobj = 0;
47028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47029 wxBitmap *result = 0 ;
47030 void *argp1 = 0 ;
47031 int res1 = 0 ;
47032 PyObject *swig_obj[1] ;
47033
47034 if (!args) SWIG_fail;
47035 swig_obj[0] = args;
47036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47037 if (!SWIG_IsOK(res1)) {
47038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47039 }
47040 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47041 {
47042 PyThreadState* __tstate = wxPyBeginAllowThreads();
47043 {
47044 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47045 result = (wxBitmap *) &_result_ref;
47046 }
47047 wxPyEndAllowThreads(__tstate);
47048 if (PyErr_Occurred()) SWIG_fail;
47049 }
47050 {
47051 wxBitmap* resultptr = new wxBitmap(*result);
47052 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47053 }
47054 return resultobj;
47055 fail:
47056 return NULL;
47057 }
47058
47059
47060 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47061 PyObject *resultobj = 0;
47062 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47063 int arg2 ;
47064 void *argp1 = 0 ;
47065 int res1 = 0 ;
47066 int val2 ;
47067 int ecode2 = 0 ;
47068 PyObject * obj0 = 0 ;
47069 PyObject * obj1 = 0 ;
47070 char * kwnames[] = {
47071 (char *) "self",(char *) "nWidth", NULL
47072 };
47073
47074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47078 }
47079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47080 ecode2 = SWIG_AsVal_int(obj1, &val2);
47081 if (!SWIG_IsOK(ecode2)) {
47082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47083 }
47084 arg2 = static_cast< int >(val2);
47085 {
47086 PyThreadState* __tstate = wxPyBeginAllowThreads();
47087 (arg1)->SetMarginWidth(arg2);
47088 wxPyEndAllowThreads(__tstate);
47089 if (PyErr_Occurred()) SWIG_fail;
47090 }
47091 resultobj = SWIG_Py_Void();
47092 return resultobj;
47093 fail:
47094 return NULL;
47095 }
47096
47097
47098 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47099 PyObject *resultobj = 0;
47100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47101 int result;
47102 void *argp1 = 0 ;
47103 int res1 = 0 ;
47104 PyObject *swig_obj[1] ;
47105
47106 if (!args) SWIG_fail;
47107 swig_obj[0] = args;
47108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47109 if (!SWIG_IsOK(res1)) {
47110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47111 }
47112 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47113 {
47114 PyThreadState* __tstate = wxPyBeginAllowThreads();
47115 result = (int)(arg1)->GetMarginWidth();
47116 wxPyEndAllowThreads(__tstate);
47117 if (PyErr_Occurred()) SWIG_fail;
47118 }
47119 resultobj = SWIG_From_int(static_cast< int >(result));
47120 return resultobj;
47121 fail:
47122 return NULL;
47123 }
47124
47125
47126 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47127 PyObject *resultobj = 0;
47128 int result;
47129
47130 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47131 {
47132 PyThreadState* __tstate = wxPyBeginAllowThreads();
47133 result = (int)wxMenuItem::GetDefaultMarginWidth();
47134 wxPyEndAllowThreads(__tstate);
47135 if (PyErr_Occurred()) SWIG_fail;
47136 }
47137 resultobj = SWIG_From_int(static_cast< int >(result));
47138 return resultobj;
47139 fail:
47140 return NULL;
47141 }
47142
47143
47144 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47145 PyObject *resultobj = 0;
47146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47147 bool result;
47148 void *argp1 = 0 ;
47149 int res1 = 0 ;
47150 PyObject *swig_obj[1] ;
47151
47152 if (!args) SWIG_fail;
47153 swig_obj[0] = args;
47154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47155 if (!SWIG_IsOK(res1)) {
47156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47157 }
47158 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47159 {
47160 PyThreadState* __tstate = wxPyBeginAllowThreads();
47161 result = (bool)(arg1)->IsOwnerDrawn();
47162 wxPyEndAllowThreads(__tstate);
47163 if (PyErr_Occurred()) SWIG_fail;
47164 }
47165 {
47166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47167 }
47168 return resultobj;
47169 fail:
47170 return NULL;
47171 }
47172
47173
47174 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47175 PyObject *resultobj = 0;
47176 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47177 bool arg2 = (bool) true ;
47178 void *argp1 = 0 ;
47179 int res1 = 0 ;
47180 bool val2 ;
47181 int ecode2 = 0 ;
47182 PyObject * obj0 = 0 ;
47183 PyObject * obj1 = 0 ;
47184 char * kwnames[] = {
47185 (char *) "self",(char *) "ownerDrawn", NULL
47186 };
47187
47188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47190 if (!SWIG_IsOK(res1)) {
47191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47192 }
47193 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47194 if (obj1) {
47195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47196 if (!SWIG_IsOK(ecode2)) {
47197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47198 }
47199 arg2 = static_cast< bool >(val2);
47200 }
47201 {
47202 PyThreadState* __tstate = wxPyBeginAllowThreads();
47203 (arg1)->SetOwnerDrawn(arg2);
47204 wxPyEndAllowThreads(__tstate);
47205 if (PyErr_Occurred()) SWIG_fail;
47206 }
47207 resultobj = SWIG_Py_Void();
47208 return resultobj;
47209 fail:
47210 return NULL;
47211 }
47212
47213
47214 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47215 PyObject *resultobj = 0;
47216 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47217 void *argp1 = 0 ;
47218 int res1 = 0 ;
47219 PyObject *swig_obj[1] ;
47220
47221 if (!args) SWIG_fail;
47222 swig_obj[0] = args;
47223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47224 if (!SWIG_IsOK(res1)) {
47225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47226 }
47227 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47228 {
47229 PyThreadState* __tstate = wxPyBeginAllowThreads();
47230 (arg1)->ResetOwnerDrawn();
47231 wxPyEndAllowThreads(__tstate);
47232 if (PyErr_Occurred()) SWIG_fail;
47233 }
47234 resultobj = SWIG_Py_Void();
47235 return resultobj;
47236 fail:
47237 return NULL;
47238 }
47239
47240
47241 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47242 PyObject *obj;
47243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47244 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47245 return SWIG_Py_Void();
47246 }
47247
47248 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47249 return SWIG_Python_InitShadowInstance(args);
47250 }
47251
47252 SWIGINTERN int ControlNameStr_set(PyObject *) {
47253 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47254 return 1;
47255 }
47256
47257
47258 SWIGINTERN PyObject *ControlNameStr_get(void) {
47259 PyObject *pyobj = 0;
47260
47261 {
47262 #if wxUSE_UNICODE
47263 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47264 #else
47265 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47266 #endif
47267 }
47268 return pyobj;
47269 }
47270
47271
47272 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47273 PyObject *resultobj = 0;
47274 wxWindow *arg1 = (wxWindow *) 0 ;
47275 int arg2 = (int) -1 ;
47276 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47277 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47278 wxSize const &arg4_defvalue = wxDefaultSize ;
47279 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47280 long arg5 = (long) 0 ;
47281 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47282 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47283 wxString const &arg7_defvalue = wxPyControlNameStr ;
47284 wxString *arg7 = (wxString *) &arg7_defvalue ;
47285 wxControl *result = 0 ;
47286 void *argp1 = 0 ;
47287 int res1 = 0 ;
47288 int val2 ;
47289 int ecode2 = 0 ;
47290 wxPoint temp3 ;
47291 wxSize temp4 ;
47292 long val5 ;
47293 int ecode5 = 0 ;
47294 void *argp6 = 0 ;
47295 int res6 = 0 ;
47296 bool temp7 = false ;
47297 PyObject * obj0 = 0 ;
47298 PyObject * obj1 = 0 ;
47299 PyObject * obj2 = 0 ;
47300 PyObject * obj3 = 0 ;
47301 PyObject * obj4 = 0 ;
47302 PyObject * obj5 = 0 ;
47303 PyObject * obj6 = 0 ;
47304 char * kwnames[] = {
47305 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47306 };
47307
47308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47310 if (!SWIG_IsOK(res1)) {
47311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47312 }
47313 arg1 = reinterpret_cast< wxWindow * >(argp1);
47314 if (obj1) {
47315 ecode2 = SWIG_AsVal_int(obj1, &val2);
47316 if (!SWIG_IsOK(ecode2)) {
47317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47318 }
47319 arg2 = static_cast< int >(val2);
47320 }
47321 if (obj2) {
47322 {
47323 arg3 = &temp3;
47324 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47325 }
47326 }
47327 if (obj3) {
47328 {
47329 arg4 = &temp4;
47330 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47331 }
47332 }
47333 if (obj4) {
47334 ecode5 = SWIG_AsVal_long(obj4, &val5);
47335 if (!SWIG_IsOK(ecode5)) {
47336 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47337 }
47338 arg5 = static_cast< long >(val5);
47339 }
47340 if (obj5) {
47341 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47342 if (!SWIG_IsOK(res6)) {
47343 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47344 }
47345 if (!argp6) {
47346 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47347 }
47348 arg6 = reinterpret_cast< wxValidator * >(argp6);
47349 }
47350 if (obj6) {
47351 {
47352 arg7 = wxString_in_helper(obj6);
47353 if (arg7 == NULL) SWIG_fail;
47354 temp7 = true;
47355 }
47356 }
47357 {
47358 if (!wxPyCheckForApp()) SWIG_fail;
47359 PyThreadState* __tstate = wxPyBeginAllowThreads();
47360 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47361 wxPyEndAllowThreads(__tstate);
47362 if (PyErr_Occurred()) SWIG_fail;
47363 }
47364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47365 {
47366 if (temp7)
47367 delete arg7;
47368 }
47369 return resultobj;
47370 fail:
47371 {
47372 if (temp7)
47373 delete arg7;
47374 }
47375 return NULL;
47376 }
47377
47378
47379 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47380 PyObject *resultobj = 0;
47381 wxControl *result = 0 ;
47382
47383 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47384 {
47385 if (!wxPyCheckForApp()) SWIG_fail;
47386 PyThreadState* __tstate = wxPyBeginAllowThreads();
47387 result = (wxControl *)new wxControl();
47388 wxPyEndAllowThreads(__tstate);
47389 if (PyErr_Occurred()) SWIG_fail;
47390 }
47391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47392 return resultobj;
47393 fail:
47394 return NULL;
47395 }
47396
47397
47398 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47399 PyObject *resultobj = 0;
47400 wxControl *arg1 = (wxControl *) 0 ;
47401 wxWindow *arg2 = (wxWindow *) 0 ;
47402 int arg3 = (int) -1 ;
47403 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47404 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47405 wxSize const &arg5_defvalue = wxDefaultSize ;
47406 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47407 long arg6 = (long) 0 ;
47408 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47409 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47410 wxString const &arg8_defvalue = wxPyControlNameStr ;
47411 wxString *arg8 = (wxString *) &arg8_defvalue ;
47412 bool result;
47413 void *argp1 = 0 ;
47414 int res1 = 0 ;
47415 void *argp2 = 0 ;
47416 int res2 = 0 ;
47417 int val3 ;
47418 int ecode3 = 0 ;
47419 wxPoint temp4 ;
47420 wxSize temp5 ;
47421 long val6 ;
47422 int ecode6 = 0 ;
47423 void *argp7 = 0 ;
47424 int res7 = 0 ;
47425 bool temp8 = false ;
47426 PyObject * obj0 = 0 ;
47427 PyObject * obj1 = 0 ;
47428 PyObject * obj2 = 0 ;
47429 PyObject * obj3 = 0 ;
47430 PyObject * obj4 = 0 ;
47431 PyObject * obj5 = 0 ;
47432 PyObject * obj6 = 0 ;
47433 PyObject * obj7 = 0 ;
47434 char * kwnames[] = {
47435 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47436 };
47437
47438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47440 if (!SWIG_IsOK(res1)) {
47441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47442 }
47443 arg1 = reinterpret_cast< wxControl * >(argp1);
47444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47445 if (!SWIG_IsOK(res2)) {
47446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47447 }
47448 arg2 = reinterpret_cast< wxWindow * >(argp2);
47449 if (obj2) {
47450 ecode3 = SWIG_AsVal_int(obj2, &val3);
47451 if (!SWIG_IsOK(ecode3)) {
47452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47453 }
47454 arg3 = static_cast< int >(val3);
47455 }
47456 if (obj3) {
47457 {
47458 arg4 = &temp4;
47459 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47460 }
47461 }
47462 if (obj4) {
47463 {
47464 arg5 = &temp5;
47465 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47466 }
47467 }
47468 if (obj5) {
47469 ecode6 = SWIG_AsVal_long(obj5, &val6);
47470 if (!SWIG_IsOK(ecode6)) {
47471 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47472 }
47473 arg6 = static_cast< long >(val6);
47474 }
47475 if (obj6) {
47476 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47477 if (!SWIG_IsOK(res7)) {
47478 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47479 }
47480 if (!argp7) {
47481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47482 }
47483 arg7 = reinterpret_cast< wxValidator * >(argp7);
47484 }
47485 if (obj7) {
47486 {
47487 arg8 = wxString_in_helper(obj7);
47488 if (arg8 == NULL) SWIG_fail;
47489 temp8 = true;
47490 }
47491 }
47492 {
47493 PyThreadState* __tstate = wxPyBeginAllowThreads();
47494 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47495 wxPyEndAllowThreads(__tstate);
47496 if (PyErr_Occurred()) SWIG_fail;
47497 }
47498 {
47499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47500 }
47501 {
47502 if (temp8)
47503 delete arg8;
47504 }
47505 return resultobj;
47506 fail:
47507 {
47508 if (temp8)
47509 delete arg8;
47510 }
47511 return NULL;
47512 }
47513
47514
47515 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47516 PyObject *resultobj = 0;
47517 wxControl *arg1 = (wxControl *) 0 ;
47518 int result;
47519 void *argp1 = 0 ;
47520 int res1 = 0 ;
47521 PyObject *swig_obj[1] ;
47522
47523 if (!args) SWIG_fail;
47524 swig_obj[0] = args;
47525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47526 if (!SWIG_IsOK(res1)) {
47527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47528 }
47529 arg1 = reinterpret_cast< wxControl * >(argp1);
47530 {
47531 PyThreadState* __tstate = wxPyBeginAllowThreads();
47532 result = (int)((wxControl const *)arg1)->GetAlignment();
47533 wxPyEndAllowThreads(__tstate);
47534 if (PyErr_Occurred()) SWIG_fail;
47535 }
47536 resultobj = SWIG_From_int(static_cast< int >(result));
47537 return resultobj;
47538 fail:
47539 return NULL;
47540 }
47541
47542
47543 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47544 PyObject *resultobj = 0;
47545 wxControl *arg1 = (wxControl *) 0 ;
47546 wxString result;
47547 void *argp1 = 0 ;
47548 int res1 = 0 ;
47549 PyObject *swig_obj[1] ;
47550
47551 if (!args) SWIG_fail;
47552 swig_obj[0] = args;
47553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47554 if (!SWIG_IsOK(res1)) {
47555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47556 }
47557 arg1 = reinterpret_cast< wxControl * >(argp1);
47558 {
47559 PyThreadState* __tstate = wxPyBeginAllowThreads();
47560 result = ((wxControl const *)arg1)->GetLabelText();
47561 wxPyEndAllowThreads(__tstate);
47562 if (PyErr_Occurred()) SWIG_fail;
47563 }
47564 {
47565 #if wxUSE_UNICODE
47566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47567 #else
47568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47569 #endif
47570 }
47571 return resultobj;
47572 fail:
47573 return NULL;
47574 }
47575
47576
47577 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47578 PyObject *resultobj = 0;
47579 wxControl *arg1 = (wxControl *) 0 ;
47580 wxCommandEvent *arg2 = 0 ;
47581 void *argp1 = 0 ;
47582 int res1 = 0 ;
47583 void *argp2 = 0 ;
47584 int res2 = 0 ;
47585 PyObject * obj0 = 0 ;
47586 PyObject * obj1 = 0 ;
47587 char * kwnames[] = {
47588 (char *) "self",(char *) "event", NULL
47589 };
47590
47591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47593 if (!SWIG_IsOK(res1)) {
47594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47595 }
47596 arg1 = reinterpret_cast< wxControl * >(argp1);
47597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47598 if (!SWIG_IsOK(res2)) {
47599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47600 }
47601 if (!argp2) {
47602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47603 }
47604 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47605 {
47606 PyThreadState* __tstate = wxPyBeginAllowThreads();
47607 (arg1)->Command(*arg2);
47608 wxPyEndAllowThreads(__tstate);
47609 if (PyErr_Occurred()) SWIG_fail;
47610 }
47611 resultobj = SWIG_Py_Void();
47612 return resultobj;
47613 fail:
47614 return NULL;
47615 }
47616
47617
47618 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47619 PyObject *resultobj = 0;
47620 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47621 SwigValueWrapper<wxVisualAttributes > result;
47622 int val1 ;
47623 int ecode1 = 0 ;
47624 PyObject * obj0 = 0 ;
47625 char * kwnames[] = {
47626 (char *) "variant", NULL
47627 };
47628
47629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47630 if (obj0) {
47631 ecode1 = SWIG_AsVal_int(obj0, &val1);
47632 if (!SWIG_IsOK(ecode1)) {
47633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47634 }
47635 arg1 = static_cast< wxWindowVariant >(val1);
47636 }
47637 {
47638 if (!wxPyCheckForApp()) SWIG_fail;
47639 PyThreadState* __tstate = wxPyBeginAllowThreads();
47640 result = wxControl::GetClassDefaultAttributes(arg1);
47641 wxPyEndAllowThreads(__tstate);
47642 if (PyErr_Occurred()) SWIG_fail;
47643 }
47644 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47645 return resultobj;
47646 fail:
47647 return NULL;
47648 }
47649
47650
47651 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47652 PyObject *obj;
47653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47654 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47655 return SWIG_Py_Void();
47656 }
47657
47658 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47659 return SWIG_Python_InitShadowInstance(args);
47660 }
47661
47662 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47663 PyObject *resultobj = 0;
47664 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47665 wxString *arg2 = 0 ;
47666 PyObject *arg3 = (PyObject *) NULL ;
47667 int result;
47668 void *argp1 = 0 ;
47669 int res1 = 0 ;
47670 bool temp2 = false ;
47671 PyObject * obj0 = 0 ;
47672 PyObject * obj1 = 0 ;
47673 PyObject * obj2 = 0 ;
47674 char * kwnames[] = {
47675 (char *) "self",(char *) "item",(char *) "clientData", NULL
47676 };
47677
47678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47680 if (!SWIG_IsOK(res1)) {
47681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47682 }
47683 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47684 {
47685 arg2 = wxString_in_helper(obj1);
47686 if (arg2 == NULL) SWIG_fail;
47687 temp2 = true;
47688 }
47689 if (obj2) {
47690 arg3 = obj2;
47691 }
47692 {
47693 PyThreadState* __tstate = wxPyBeginAllowThreads();
47694 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47695 wxPyEndAllowThreads(__tstate);
47696 if (PyErr_Occurred()) SWIG_fail;
47697 }
47698 resultobj = SWIG_From_int(static_cast< int >(result));
47699 {
47700 if (temp2)
47701 delete arg2;
47702 }
47703 return resultobj;
47704 fail:
47705 {
47706 if (temp2)
47707 delete arg2;
47708 }
47709 return NULL;
47710 }
47711
47712
47713 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47714 PyObject *resultobj = 0;
47715 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47716 wxArrayString *arg2 = 0 ;
47717 void *argp1 = 0 ;
47718 int res1 = 0 ;
47719 bool temp2 = false ;
47720 PyObject * obj0 = 0 ;
47721 PyObject * obj1 = 0 ;
47722 char * kwnames[] = {
47723 (char *) "self",(char *) "strings", NULL
47724 };
47725
47726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47728 if (!SWIG_IsOK(res1)) {
47729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47730 }
47731 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47732 {
47733 if (! PySequence_Check(obj1)) {
47734 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47735 SWIG_fail;
47736 }
47737 arg2 = new wxArrayString;
47738 temp2 = true;
47739 int i, len=PySequence_Length(obj1);
47740 for (i=0; i<len; i++) {
47741 PyObject* item = PySequence_GetItem(obj1, i);
47742 wxString* s = wxString_in_helper(item);
47743 if (PyErr_Occurred()) SWIG_fail;
47744 arg2->Add(*s);
47745 delete s;
47746 Py_DECREF(item);
47747 }
47748 }
47749 {
47750 PyThreadState* __tstate = wxPyBeginAllowThreads();
47751 (arg1)->Append((wxArrayString const &)*arg2);
47752 wxPyEndAllowThreads(__tstate);
47753 if (PyErr_Occurred()) SWIG_fail;
47754 }
47755 resultobj = SWIG_Py_Void();
47756 {
47757 if (temp2) delete arg2;
47758 }
47759 return resultobj;
47760 fail:
47761 {
47762 if (temp2) delete arg2;
47763 }
47764 return NULL;
47765 }
47766
47767
47768 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47769 PyObject *resultobj = 0;
47770 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47771 wxString *arg2 = 0 ;
47772 unsigned int arg3 ;
47773 PyObject *arg4 = (PyObject *) NULL ;
47774 int result;
47775 void *argp1 = 0 ;
47776 int res1 = 0 ;
47777 bool temp2 = false ;
47778 unsigned int val3 ;
47779 int ecode3 = 0 ;
47780 PyObject * obj0 = 0 ;
47781 PyObject * obj1 = 0 ;
47782 PyObject * obj2 = 0 ;
47783 PyObject * obj3 = 0 ;
47784 char * kwnames[] = {
47785 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47786 };
47787
47788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47790 if (!SWIG_IsOK(res1)) {
47791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47792 }
47793 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47794 {
47795 arg2 = wxString_in_helper(obj1);
47796 if (arg2 == NULL) SWIG_fail;
47797 temp2 = true;
47798 }
47799 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47800 if (!SWIG_IsOK(ecode3)) {
47801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47802 }
47803 arg3 = static_cast< unsigned int >(val3);
47804 if (obj3) {
47805 arg4 = obj3;
47806 }
47807 {
47808 PyThreadState* __tstate = wxPyBeginAllowThreads();
47809 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47810 wxPyEndAllowThreads(__tstate);
47811 if (PyErr_Occurred()) SWIG_fail;
47812 }
47813 resultobj = SWIG_From_int(static_cast< int >(result));
47814 {
47815 if (temp2)
47816 delete arg2;
47817 }
47818 return resultobj;
47819 fail:
47820 {
47821 if (temp2)
47822 delete arg2;
47823 }
47824 return NULL;
47825 }
47826
47827
47828 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47829 PyObject *resultobj = 0;
47830 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47831 void *argp1 = 0 ;
47832 int res1 = 0 ;
47833 PyObject *swig_obj[1] ;
47834
47835 if (!args) SWIG_fail;
47836 swig_obj[0] = args;
47837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47838 if (!SWIG_IsOK(res1)) {
47839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47840 }
47841 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47842 {
47843 PyThreadState* __tstate = wxPyBeginAllowThreads();
47844 (arg1)->Clear();
47845 wxPyEndAllowThreads(__tstate);
47846 if (PyErr_Occurred()) SWIG_fail;
47847 }
47848 resultobj = SWIG_Py_Void();
47849 return resultobj;
47850 fail:
47851 return NULL;
47852 }
47853
47854
47855 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47856 PyObject *resultobj = 0;
47857 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47858 unsigned int arg2 ;
47859 void *argp1 = 0 ;
47860 int res1 = 0 ;
47861 unsigned int val2 ;
47862 int ecode2 = 0 ;
47863 PyObject * obj0 = 0 ;
47864 PyObject * obj1 = 0 ;
47865 char * kwnames[] = {
47866 (char *) "self",(char *) "n", NULL
47867 };
47868
47869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47873 }
47874 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47875 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47876 if (!SWIG_IsOK(ecode2)) {
47877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47878 }
47879 arg2 = static_cast< unsigned int >(val2);
47880 {
47881 PyThreadState* __tstate = wxPyBeginAllowThreads();
47882 (arg1)->Delete(arg2);
47883 wxPyEndAllowThreads(__tstate);
47884 if (PyErr_Occurred()) SWIG_fail;
47885 }
47886 resultobj = SWIG_Py_Void();
47887 return resultobj;
47888 fail:
47889 return NULL;
47890 }
47891
47892
47893 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47894 PyObject *resultobj = 0;
47895 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47896 unsigned int arg2 ;
47897 PyObject *result = 0 ;
47898 void *argp1 = 0 ;
47899 int res1 = 0 ;
47900 unsigned int val2 ;
47901 int ecode2 = 0 ;
47902 PyObject * obj0 = 0 ;
47903 PyObject * obj1 = 0 ;
47904 char * kwnames[] = {
47905 (char *) "self",(char *) "n", NULL
47906 };
47907
47908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47910 if (!SWIG_IsOK(res1)) {
47911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47912 }
47913 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47914 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47915 if (!SWIG_IsOK(ecode2)) {
47916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47917 }
47918 arg2 = static_cast< unsigned int >(val2);
47919 {
47920 PyThreadState* __tstate = wxPyBeginAllowThreads();
47921 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47922 wxPyEndAllowThreads(__tstate);
47923 if (PyErr_Occurred()) SWIG_fail;
47924 }
47925 resultobj = result;
47926 return resultobj;
47927 fail:
47928 return NULL;
47929 }
47930
47931
47932 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47933 PyObject *resultobj = 0;
47934 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47935 unsigned int arg2 ;
47936 PyObject *arg3 = (PyObject *) 0 ;
47937 void *argp1 = 0 ;
47938 int res1 = 0 ;
47939 unsigned int val2 ;
47940 int ecode2 = 0 ;
47941 PyObject * obj0 = 0 ;
47942 PyObject * obj1 = 0 ;
47943 PyObject * obj2 = 0 ;
47944 char * kwnames[] = {
47945 (char *) "self",(char *) "n",(char *) "clientData", NULL
47946 };
47947
47948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47950 if (!SWIG_IsOK(res1)) {
47951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47952 }
47953 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47954 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47955 if (!SWIG_IsOK(ecode2)) {
47956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47957 }
47958 arg2 = static_cast< unsigned int >(val2);
47959 arg3 = obj2;
47960 {
47961 PyThreadState* __tstate = wxPyBeginAllowThreads();
47962 wxItemContainer_SetClientData(arg1,arg2,arg3);
47963 wxPyEndAllowThreads(__tstate);
47964 if (PyErr_Occurred()) SWIG_fail;
47965 }
47966 resultobj = SWIG_Py_Void();
47967 return resultobj;
47968 fail:
47969 return NULL;
47970 }
47971
47972
47973 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47974 PyObject *resultobj = 0;
47975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47976 unsigned int result;
47977 void *argp1 = 0 ;
47978 int res1 = 0 ;
47979 PyObject *swig_obj[1] ;
47980
47981 if (!args) SWIG_fail;
47982 swig_obj[0] = args;
47983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47984 if (!SWIG_IsOK(res1)) {
47985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47986 }
47987 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47988 {
47989 PyThreadState* __tstate = wxPyBeginAllowThreads();
47990 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47991 wxPyEndAllowThreads(__tstate);
47992 if (PyErr_Occurred()) SWIG_fail;
47993 }
47994 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47995 return resultobj;
47996 fail:
47997 return NULL;
47998 }
47999
48000
48001 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48002 PyObject *resultobj = 0;
48003 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48004 bool result;
48005 void *argp1 = 0 ;
48006 int res1 = 0 ;
48007 PyObject *swig_obj[1] ;
48008
48009 if (!args) SWIG_fail;
48010 swig_obj[0] = args;
48011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48012 if (!SWIG_IsOK(res1)) {
48013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48014 }
48015 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48016 {
48017 PyThreadState* __tstate = wxPyBeginAllowThreads();
48018 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48019 wxPyEndAllowThreads(__tstate);
48020 if (PyErr_Occurred()) SWIG_fail;
48021 }
48022 {
48023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48024 }
48025 return resultobj;
48026 fail:
48027 return NULL;
48028 }
48029
48030
48031 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48032 PyObject *resultobj = 0;
48033 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48034 unsigned int arg2 ;
48035 wxString result;
48036 void *argp1 = 0 ;
48037 int res1 = 0 ;
48038 unsigned int val2 ;
48039 int ecode2 = 0 ;
48040 PyObject * obj0 = 0 ;
48041 PyObject * obj1 = 0 ;
48042 char * kwnames[] = {
48043 (char *) "self",(char *) "n", NULL
48044 };
48045
48046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48048 if (!SWIG_IsOK(res1)) {
48049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48050 }
48051 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48052 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48053 if (!SWIG_IsOK(ecode2)) {
48054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48055 }
48056 arg2 = static_cast< unsigned int >(val2);
48057 {
48058 PyThreadState* __tstate = wxPyBeginAllowThreads();
48059 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48060 wxPyEndAllowThreads(__tstate);
48061 if (PyErr_Occurred()) SWIG_fail;
48062 }
48063 {
48064 #if wxUSE_UNICODE
48065 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48066 #else
48067 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48068 #endif
48069 }
48070 return resultobj;
48071 fail:
48072 return NULL;
48073 }
48074
48075
48076 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48077 PyObject *resultobj = 0;
48078 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48079 wxArrayString result;
48080 void *argp1 = 0 ;
48081 int res1 = 0 ;
48082 PyObject *swig_obj[1] ;
48083
48084 if (!args) SWIG_fail;
48085 swig_obj[0] = args;
48086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48087 if (!SWIG_IsOK(res1)) {
48088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48089 }
48090 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48091 {
48092 PyThreadState* __tstate = wxPyBeginAllowThreads();
48093 result = ((wxItemContainer const *)arg1)->GetStrings();
48094 wxPyEndAllowThreads(__tstate);
48095 if (PyErr_Occurred()) SWIG_fail;
48096 }
48097 {
48098 resultobj = wxArrayString2PyList_helper(result);
48099 }
48100 return resultobj;
48101 fail:
48102 return NULL;
48103 }
48104
48105
48106 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48107 PyObject *resultobj = 0;
48108 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48109 unsigned int arg2 ;
48110 wxString *arg3 = 0 ;
48111 void *argp1 = 0 ;
48112 int res1 = 0 ;
48113 unsigned int val2 ;
48114 int ecode2 = 0 ;
48115 bool temp3 = false ;
48116 PyObject * obj0 = 0 ;
48117 PyObject * obj1 = 0 ;
48118 PyObject * obj2 = 0 ;
48119 char * kwnames[] = {
48120 (char *) "self",(char *) "n",(char *) "s", NULL
48121 };
48122
48123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48125 if (!SWIG_IsOK(res1)) {
48126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48127 }
48128 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48129 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48130 if (!SWIG_IsOK(ecode2)) {
48131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48132 }
48133 arg2 = static_cast< unsigned int >(val2);
48134 {
48135 arg3 = wxString_in_helper(obj2);
48136 if (arg3 == NULL) SWIG_fail;
48137 temp3 = true;
48138 }
48139 {
48140 PyThreadState* __tstate = wxPyBeginAllowThreads();
48141 (arg1)->SetString(arg2,(wxString const &)*arg3);
48142 wxPyEndAllowThreads(__tstate);
48143 if (PyErr_Occurred()) SWIG_fail;
48144 }
48145 resultobj = SWIG_Py_Void();
48146 {
48147 if (temp3)
48148 delete arg3;
48149 }
48150 return resultobj;
48151 fail:
48152 {
48153 if (temp3)
48154 delete arg3;
48155 }
48156 return NULL;
48157 }
48158
48159
48160 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48161 PyObject *resultobj = 0;
48162 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48163 wxString *arg2 = 0 ;
48164 int result;
48165 void *argp1 = 0 ;
48166 int res1 = 0 ;
48167 bool temp2 = false ;
48168 PyObject * obj0 = 0 ;
48169 PyObject * obj1 = 0 ;
48170 char * kwnames[] = {
48171 (char *) "self",(char *) "s", NULL
48172 };
48173
48174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48176 if (!SWIG_IsOK(res1)) {
48177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48178 }
48179 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48180 {
48181 arg2 = wxString_in_helper(obj1);
48182 if (arg2 == NULL) SWIG_fail;
48183 temp2 = true;
48184 }
48185 {
48186 PyThreadState* __tstate = wxPyBeginAllowThreads();
48187 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48188 wxPyEndAllowThreads(__tstate);
48189 if (PyErr_Occurred()) SWIG_fail;
48190 }
48191 resultobj = SWIG_From_int(static_cast< int >(result));
48192 {
48193 if (temp2)
48194 delete arg2;
48195 }
48196 return resultobj;
48197 fail:
48198 {
48199 if (temp2)
48200 delete arg2;
48201 }
48202 return NULL;
48203 }
48204
48205
48206 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48207 PyObject *resultobj = 0;
48208 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48209 int arg2 ;
48210 void *argp1 = 0 ;
48211 int res1 = 0 ;
48212 int val2 ;
48213 int ecode2 = 0 ;
48214 PyObject * obj0 = 0 ;
48215 PyObject * obj1 = 0 ;
48216 char * kwnames[] = {
48217 (char *) "self",(char *) "n", NULL
48218 };
48219
48220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48222 if (!SWIG_IsOK(res1)) {
48223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48224 }
48225 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48226 ecode2 = SWIG_AsVal_int(obj1, &val2);
48227 if (!SWIG_IsOK(ecode2)) {
48228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48229 }
48230 arg2 = static_cast< int >(val2);
48231 {
48232 PyThreadState* __tstate = wxPyBeginAllowThreads();
48233 (arg1)->SetSelection(arg2);
48234 wxPyEndAllowThreads(__tstate);
48235 if (PyErr_Occurred()) SWIG_fail;
48236 }
48237 resultobj = SWIG_Py_Void();
48238 return resultobj;
48239 fail:
48240 return NULL;
48241 }
48242
48243
48244 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48245 PyObject *resultobj = 0;
48246 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48247 int result;
48248 void *argp1 = 0 ;
48249 int res1 = 0 ;
48250 PyObject *swig_obj[1] ;
48251
48252 if (!args) SWIG_fail;
48253 swig_obj[0] = args;
48254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48257 }
48258 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48259 {
48260 PyThreadState* __tstate = wxPyBeginAllowThreads();
48261 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48262 wxPyEndAllowThreads(__tstate);
48263 if (PyErr_Occurred()) SWIG_fail;
48264 }
48265 resultobj = SWIG_From_int(static_cast< int >(result));
48266 return resultobj;
48267 fail:
48268 return NULL;
48269 }
48270
48271
48272 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48273 PyObject *resultobj = 0;
48274 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48275 wxString *arg2 = 0 ;
48276 bool result;
48277 void *argp1 = 0 ;
48278 int res1 = 0 ;
48279 bool temp2 = false ;
48280 PyObject * obj0 = 0 ;
48281 PyObject * obj1 = 0 ;
48282 char * kwnames[] = {
48283 (char *) "self",(char *) "s", NULL
48284 };
48285
48286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48288 if (!SWIG_IsOK(res1)) {
48289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48290 }
48291 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48292 {
48293 arg2 = wxString_in_helper(obj1);
48294 if (arg2 == NULL) SWIG_fail;
48295 temp2 = true;
48296 }
48297 {
48298 PyThreadState* __tstate = wxPyBeginAllowThreads();
48299 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48300 wxPyEndAllowThreads(__tstate);
48301 if (PyErr_Occurred()) SWIG_fail;
48302 }
48303 {
48304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48305 }
48306 {
48307 if (temp2)
48308 delete arg2;
48309 }
48310 return resultobj;
48311 fail:
48312 {
48313 if (temp2)
48314 delete arg2;
48315 }
48316 return NULL;
48317 }
48318
48319
48320 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48321 PyObject *resultobj = 0;
48322 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48323 wxString result;
48324 void *argp1 = 0 ;
48325 int res1 = 0 ;
48326 PyObject *swig_obj[1] ;
48327
48328 if (!args) SWIG_fail;
48329 swig_obj[0] = args;
48330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48331 if (!SWIG_IsOK(res1)) {
48332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48333 }
48334 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48335 {
48336 PyThreadState* __tstate = wxPyBeginAllowThreads();
48337 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48338 wxPyEndAllowThreads(__tstate);
48339 if (PyErr_Occurred()) SWIG_fail;
48340 }
48341 {
48342 #if wxUSE_UNICODE
48343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48344 #else
48345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48346 #endif
48347 }
48348 return resultobj;
48349 fail:
48350 return NULL;
48351 }
48352
48353
48354 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48355 PyObject *resultobj = 0;
48356 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48357 int arg2 ;
48358 void *argp1 = 0 ;
48359 int res1 = 0 ;
48360 int val2 ;
48361 int ecode2 = 0 ;
48362 PyObject * obj0 = 0 ;
48363 PyObject * obj1 = 0 ;
48364 char * kwnames[] = {
48365 (char *) "self",(char *) "n", NULL
48366 };
48367
48368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48370 if (!SWIG_IsOK(res1)) {
48371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48372 }
48373 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48374 ecode2 = SWIG_AsVal_int(obj1, &val2);
48375 if (!SWIG_IsOK(ecode2)) {
48376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48377 }
48378 arg2 = static_cast< int >(val2);
48379 {
48380 PyThreadState* __tstate = wxPyBeginAllowThreads();
48381 (arg1)->Select(arg2);
48382 wxPyEndAllowThreads(__tstate);
48383 if (PyErr_Occurred()) SWIG_fail;
48384 }
48385 resultobj = SWIG_Py_Void();
48386 return resultobj;
48387 fail:
48388 return NULL;
48389 }
48390
48391
48392 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48393 PyObject *obj;
48394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48395 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48396 return SWIG_Py_Void();
48397 }
48398
48399 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48400 PyObject *obj;
48401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48402 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48403 return SWIG_Py_Void();
48404 }
48405
48406 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48407 PyObject *resultobj = 0;
48408 wxSizerItem *result = 0 ;
48409
48410 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48411 {
48412 PyThreadState* __tstate = wxPyBeginAllowThreads();
48413 result = (wxSizerItem *)new wxSizerItem();
48414 wxPyEndAllowThreads(__tstate);
48415 if (PyErr_Occurred()) SWIG_fail;
48416 }
48417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48418 return resultobj;
48419 fail:
48420 return NULL;
48421 }
48422
48423
48424 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48425 PyObject *resultobj = 0;
48426 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48427 void *argp1 = 0 ;
48428 int res1 = 0 ;
48429 PyObject *swig_obj[1] ;
48430
48431 if (!args) SWIG_fail;
48432 swig_obj[0] = args;
48433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48434 if (!SWIG_IsOK(res1)) {
48435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48436 }
48437 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48438 {
48439 PyThreadState* __tstate = wxPyBeginAllowThreads();
48440 delete arg1;
48441
48442 wxPyEndAllowThreads(__tstate);
48443 if (PyErr_Occurred()) SWIG_fail;
48444 }
48445 resultobj = SWIG_Py_Void();
48446 return resultobj;
48447 fail:
48448 return NULL;
48449 }
48450
48451
48452 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48453 PyObject *resultobj = 0;
48454 wxWindow *arg1 = (wxWindow *) 0 ;
48455 int arg2 ;
48456 int arg3 ;
48457 int arg4 ;
48458 PyObject *arg5 = (PyObject *) NULL ;
48459 wxSizerItem *result = 0 ;
48460 void *argp1 = 0 ;
48461 int res1 = 0 ;
48462 int val2 ;
48463 int ecode2 = 0 ;
48464 int val3 ;
48465 int ecode3 = 0 ;
48466 int val4 ;
48467 int ecode4 = 0 ;
48468 PyObject * obj0 = 0 ;
48469 PyObject * obj1 = 0 ;
48470 PyObject * obj2 = 0 ;
48471 PyObject * obj3 = 0 ;
48472 PyObject * obj4 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48479 if (!SWIG_IsOK(res1)) {
48480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48481 }
48482 arg1 = reinterpret_cast< wxWindow * >(argp1);
48483 ecode2 = SWIG_AsVal_int(obj1, &val2);
48484 if (!SWIG_IsOK(ecode2)) {
48485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48486 }
48487 arg2 = static_cast< int >(val2);
48488 ecode3 = SWIG_AsVal_int(obj2, &val3);
48489 if (!SWIG_IsOK(ecode3)) {
48490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48491 }
48492 arg3 = static_cast< int >(val3);
48493 ecode4 = SWIG_AsVal_int(obj3, &val4);
48494 if (!SWIG_IsOK(ecode4)) {
48495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48496 }
48497 arg4 = static_cast< int >(val4);
48498 if (obj4) {
48499 arg5 = obj4;
48500 }
48501 {
48502 PyThreadState* __tstate = wxPyBeginAllowThreads();
48503 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48504 wxPyEndAllowThreads(__tstate);
48505 if (PyErr_Occurred()) SWIG_fail;
48506 }
48507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48508 return resultobj;
48509 fail:
48510 return NULL;
48511 }
48512
48513
48514 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48515 PyObject *resultobj = 0;
48516 int arg1 ;
48517 int arg2 ;
48518 int arg3 ;
48519 int arg4 ;
48520 int arg5 ;
48521 PyObject *arg6 = (PyObject *) NULL ;
48522 wxSizerItem *result = 0 ;
48523 int val1 ;
48524 int ecode1 = 0 ;
48525 int val2 ;
48526 int ecode2 = 0 ;
48527 int val3 ;
48528 int ecode3 = 0 ;
48529 int val4 ;
48530 int ecode4 = 0 ;
48531 int val5 ;
48532 int ecode5 = 0 ;
48533 PyObject * obj0 = 0 ;
48534 PyObject * obj1 = 0 ;
48535 PyObject * obj2 = 0 ;
48536 PyObject * obj3 = 0 ;
48537 PyObject * obj4 = 0 ;
48538 PyObject * obj5 = 0 ;
48539 char * kwnames[] = {
48540 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48541 };
48542
48543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48544 ecode1 = SWIG_AsVal_int(obj0, &val1);
48545 if (!SWIG_IsOK(ecode1)) {
48546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48547 }
48548 arg1 = static_cast< int >(val1);
48549 ecode2 = SWIG_AsVal_int(obj1, &val2);
48550 if (!SWIG_IsOK(ecode2)) {
48551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48552 }
48553 arg2 = static_cast< int >(val2);
48554 ecode3 = SWIG_AsVal_int(obj2, &val3);
48555 if (!SWIG_IsOK(ecode3)) {
48556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48557 }
48558 arg3 = static_cast< int >(val3);
48559 ecode4 = SWIG_AsVal_int(obj3, &val4);
48560 if (!SWIG_IsOK(ecode4)) {
48561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48562 }
48563 arg4 = static_cast< int >(val4);
48564 ecode5 = SWIG_AsVal_int(obj4, &val5);
48565 if (!SWIG_IsOK(ecode5)) {
48566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48567 }
48568 arg5 = static_cast< int >(val5);
48569 if (obj5) {
48570 arg6 = obj5;
48571 }
48572 {
48573 PyThreadState* __tstate = wxPyBeginAllowThreads();
48574 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48575 wxPyEndAllowThreads(__tstate);
48576 if (PyErr_Occurred()) SWIG_fail;
48577 }
48578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48579 return resultobj;
48580 fail:
48581 return NULL;
48582 }
48583
48584
48585 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48586 PyObject *resultobj = 0;
48587 wxSizer *arg1 = (wxSizer *) 0 ;
48588 int arg2 ;
48589 int arg3 ;
48590 int arg4 ;
48591 PyObject *arg5 = (PyObject *) NULL ;
48592 wxSizerItem *result = 0 ;
48593 int res1 = 0 ;
48594 int val2 ;
48595 int ecode2 = 0 ;
48596 int val3 ;
48597 int ecode3 = 0 ;
48598 int val4 ;
48599 int ecode4 = 0 ;
48600 PyObject * obj0 = 0 ;
48601 PyObject * obj1 = 0 ;
48602 PyObject * obj2 = 0 ;
48603 PyObject * obj3 = 0 ;
48604 PyObject * obj4 = 0 ;
48605 char * kwnames[] = {
48606 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48607 };
48608
48609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48610 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48611 if (!SWIG_IsOK(res1)) {
48612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48613 }
48614 ecode2 = SWIG_AsVal_int(obj1, &val2);
48615 if (!SWIG_IsOK(ecode2)) {
48616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48617 }
48618 arg2 = static_cast< int >(val2);
48619 ecode3 = SWIG_AsVal_int(obj2, &val3);
48620 if (!SWIG_IsOK(ecode3)) {
48621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48622 }
48623 arg3 = static_cast< int >(val3);
48624 ecode4 = SWIG_AsVal_int(obj3, &val4);
48625 if (!SWIG_IsOK(ecode4)) {
48626 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48627 }
48628 arg4 = static_cast< int >(val4);
48629 if (obj4) {
48630 arg5 = obj4;
48631 }
48632 {
48633 PyThreadState* __tstate = wxPyBeginAllowThreads();
48634 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48635 wxPyEndAllowThreads(__tstate);
48636 if (PyErr_Occurred()) SWIG_fail;
48637 }
48638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48639 return resultobj;
48640 fail:
48641 return NULL;
48642 }
48643
48644
48645 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48646 PyObject *resultobj = 0;
48647 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48648 void *argp1 = 0 ;
48649 int res1 = 0 ;
48650 PyObject *swig_obj[1] ;
48651
48652 if (!args) SWIG_fail;
48653 swig_obj[0] = args;
48654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48655 if (!SWIG_IsOK(res1)) {
48656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48657 }
48658 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48659 {
48660 PyThreadState* __tstate = wxPyBeginAllowThreads();
48661 (arg1)->DeleteWindows();
48662 wxPyEndAllowThreads(__tstate);
48663 if (PyErr_Occurred()) SWIG_fail;
48664 }
48665 resultobj = SWIG_Py_Void();
48666 return resultobj;
48667 fail:
48668 return NULL;
48669 }
48670
48671
48672 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48673 PyObject *resultobj = 0;
48674 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48675 void *argp1 = 0 ;
48676 int res1 = 0 ;
48677 PyObject *swig_obj[1] ;
48678
48679 if (!args) SWIG_fail;
48680 swig_obj[0] = args;
48681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48682 if (!SWIG_IsOK(res1)) {
48683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48684 }
48685 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48686 {
48687 PyThreadState* __tstate = wxPyBeginAllowThreads();
48688 (arg1)->DetachSizer();
48689 wxPyEndAllowThreads(__tstate);
48690 if (PyErr_Occurred()) SWIG_fail;
48691 }
48692 resultobj = SWIG_Py_Void();
48693 return resultobj;
48694 fail:
48695 return NULL;
48696 }
48697
48698
48699 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48700 PyObject *resultobj = 0;
48701 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48702 wxSize result;
48703 void *argp1 = 0 ;
48704 int res1 = 0 ;
48705 PyObject *swig_obj[1] ;
48706
48707 if (!args) SWIG_fail;
48708 swig_obj[0] = args;
48709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48710 if (!SWIG_IsOK(res1)) {
48711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48712 }
48713 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48714 {
48715 PyThreadState* __tstate = wxPyBeginAllowThreads();
48716 result = (arg1)->GetSize();
48717 wxPyEndAllowThreads(__tstate);
48718 if (PyErr_Occurred()) SWIG_fail;
48719 }
48720 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48721 return resultobj;
48722 fail:
48723 return NULL;
48724 }
48725
48726
48727 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48728 PyObject *resultobj = 0;
48729 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48730 wxSize result;
48731 void *argp1 = 0 ;
48732 int res1 = 0 ;
48733 PyObject *swig_obj[1] ;
48734
48735 if (!args) SWIG_fail;
48736 swig_obj[0] = args;
48737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48738 if (!SWIG_IsOK(res1)) {
48739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48740 }
48741 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48742 {
48743 PyThreadState* __tstate = wxPyBeginAllowThreads();
48744 result = (arg1)->CalcMin();
48745 wxPyEndAllowThreads(__tstate);
48746 if (PyErr_Occurred()) SWIG_fail;
48747 }
48748 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48749 return resultobj;
48750 fail:
48751 return NULL;
48752 }
48753
48754
48755 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48756 PyObject *resultobj = 0;
48757 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48758 wxPoint *arg2 = 0 ;
48759 wxSize *arg3 = 0 ;
48760 void *argp1 = 0 ;
48761 int res1 = 0 ;
48762 wxPoint temp2 ;
48763 wxSize temp3 ;
48764 PyObject * obj0 = 0 ;
48765 PyObject * obj1 = 0 ;
48766 PyObject * obj2 = 0 ;
48767 char * kwnames[] = {
48768 (char *) "self",(char *) "pos",(char *) "size", NULL
48769 };
48770
48771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48773 if (!SWIG_IsOK(res1)) {
48774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48775 }
48776 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48777 {
48778 arg2 = &temp2;
48779 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48780 }
48781 {
48782 arg3 = &temp3;
48783 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48784 }
48785 {
48786 PyThreadState* __tstate = wxPyBeginAllowThreads();
48787 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48788 wxPyEndAllowThreads(__tstate);
48789 if (PyErr_Occurred()) SWIG_fail;
48790 }
48791 resultobj = SWIG_Py_Void();
48792 return resultobj;
48793 fail:
48794 return NULL;
48795 }
48796
48797
48798 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48799 PyObject *resultobj = 0;
48800 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48801 wxSize result;
48802 void *argp1 = 0 ;
48803 int res1 = 0 ;
48804 PyObject *swig_obj[1] ;
48805
48806 if (!args) SWIG_fail;
48807 swig_obj[0] = args;
48808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48809 if (!SWIG_IsOK(res1)) {
48810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48811 }
48812 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48813 {
48814 PyThreadState* __tstate = wxPyBeginAllowThreads();
48815 result = (arg1)->GetMinSize();
48816 wxPyEndAllowThreads(__tstate);
48817 if (PyErr_Occurred()) SWIG_fail;
48818 }
48819 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48820 return resultobj;
48821 fail:
48822 return NULL;
48823 }
48824
48825
48826 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48827 PyObject *resultobj = 0;
48828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48829 wxSize result;
48830 void *argp1 = 0 ;
48831 int res1 = 0 ;
48832 PyObject *swig_obj[1] ;
48833
48834 if (!args) SWIG_fail;
48835 swig_obj[0] = args;
48836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48837 if (!SWIG_IsOK(res1)) {
48838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48839 }
48840 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48841 {
48842 PyThreadState* __tstate = wxPyBeginAllowThreads();
48843 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48844 wxPyEndAllowThreads(__tstate);
48845 if (PyErr_Occurred()) SWIG_fail;
48846 }
48847 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48848 return resultobj;
48849 fail:
48850 return NULL;
48851 }
48852
48853
48854 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48855 PyObject *resultobj = 0;
48856 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48857 int arg2 ;
48858 int arg3 ;
48859 void *argp1 = 0 ;
48860 int res1 = 0 ;
48861 int val2 ;
48862 int ecode2 = 0 ;
48863 int val3 ;
48864 int ecode3 = 0 ;
48865 PyObject * obj0 = 0 ;
48866 PyObject * obj1 = 0 ;
48867 PyObject * obj2 = 0 ;
48868 char * kwnames[] = {
48869 (char *) "self",(char *) "x",(char *) "y", NULL
48870 };
48871
48872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48874 if (!SWIG_IsOK(res1)) {
48875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48876 }
48877 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48878 ecode2 = SWIG_AsVal_int(obj1, &val2);
48879 if (!SWIG_IsOK(ecode2)) {
48880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48881 }
48882 arg2 = static_cast< int >(val2);
48883 ecode3 = SWIG_AsVal_int(obj2, &val3);
48884 if (!SWIG_IsOK(ecode3)) {
48885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48886 }
48887 arg3 = static_cast< int >(val3);
48888 {
48889 PyThreadState* __tstate = wxPyBeginAllowThreads();
48890 (arg1)->SetInitSize(arg2,arg3);
48891 wxPyEndAllowThreads(__tstate);
48892 if (PyErr_Occurred()) SWIG_fail;
48893 }
48894 resultobj = SWIG_Py_Void();
48895 return resultobj;
48896 fail:
48897 return NULL;
48898 }
48899
48900
48901 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48902 PyObject *resultobj = 0;
48903 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48904 int arg2 ;
48905 int arg3 ;
48906 void *argp1 = 0 ;
48907 int res1 = 0 ;
48908 int val2 ;
48909 int ecode2 = 0 ;
48910 int val3 ;
48911 int ecode3 = 0 ;
48912 PyObject * obj0 = 0 ;
48913 PyObject * obj1 = 0 ;
48914 PyObject * obj2 = 0 ;
48915 char * kwnames[] = {
48916 (char *) "self",(char *) "width",(char *) "height", NULL
48917 };
48918
48919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48921 if (!SWIG_IsOK(res1)) {
48922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48923 }
48924 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48925 ecode2 = SWIG_AsVal_int(obj1, &val2);
48926 if (!SWIG_IsOK(ecode2)) {
48927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48928 }
48929 arg2 = static_cast< int >(val2);
48930 ecode3 = SWIG_AsVal_int(obj2, &val3);
48931 if (!SWIG_IsOK(ecode3)) {
48932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48933 }
48934 arg3 = static_cast< int >(val3);
48935 {
48936 PyThreadState* __tstate = wxPyBeginAllowThreads();
48937 (arg1)->SetRatio(arg2,arg3);
48938 wxPyEndAllowThreads(__tstate);
48939 if (PyErr_Occurred()) SWIG_fail;
48940 }
48941 resultobj = SWIG_Py_Void();
48942 return resultobj;
48943 fail:
48944 return NULL;
48945 }
48946
48947
48948 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48949 PyObject *resultobj = 0;
48950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48951 wxSize *arg2 = 0 ;
48952 void *argp1 = 0 ;
48953 int res1 = 0 ;
48954 wxSize temp2 ;
48955 PyObject * obj0 = 0 ;
48956 PyObject * obj1 = 0 ;
48957 char * kwnames[] = {
48958 (char *) "self",(char *) "size", NULL
48959 };
48960
48961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48963 if (!SWIG_IsOK(res1)) {
48964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48965 }
48966 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48967 {
48968 arg2 = &temp2;
48969 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48970 }
48971 {
48972 PyThreadState* __tstate = wxPyBeginAllowThreads();
48973 (arg1)->SetRatio((wxSize const &)*arg2);
48974 wxPyEndAllowThreads(__tstate);
48975 if (PyErr_Occurred()) SWIG_fail;
48976 }
48977 resultobj = SWIG_Py_Void();
48978 return resultobj;
48979 fail:
48980 return NULL;
48981 }
48982
48983
48984 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48985 PyObject *resultobj = 0;
48986 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48987 float arg2 ;
48988 void *argp1 = 0 ;
48989 int res1 = 0 ;
48990 float val2 ;
48991 int ecode2 = 0 ;
48992 PyObject * obj0 = 0 ;
48993 PyObject * obj1 = 0 ;
48994 char * kwnames[] = {
48995 (char *) "self",(char *) "ratio", NULL
48996 };
48997
48998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49000 if (!SWIG_IsOK(res1)) {
49001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49002 }
49003 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49004 ecode2 = SWIG_AsVal_float(obj1, &val2);
49005 if (!SWIG_IsOK(ecode2)) {
49006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49007 }
49008 arg2 = static_cast< float >(val2);
49009 {
49010 PyThreadState* __tstate = wxPyBeginAllowThreads();
49011 (arg1)->SetRatio(arg2);
49012 wxPyEndAllowThreads(__tstate);
49013 if (PyErr_Occurred()) SWIG_fail;
49014 }
49015 resultobj = SWIG_Py_Void();
49016 return resultobj;
49017 fail:
49018 return NULL;
49019 }
49020
49021
49022 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49023 PyObject *resultobj = 0;
49024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49025 float result;
49026 void *argp1 = 0 ;
49027 int res1 = 0 ;
49028 PyObject *swig_obj[1] ;
49029
49030 if (!args) SWIG_fail;
49031 swig_obj[0] = args;
49032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49033 if (!SWIG_IsOK(res1)) {
49034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49035 }
49036 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49037 {
49038 PyThreadState* __tstate = wxPyBeginAllowThreads();
49039 result = (float)(arg1)->GetRatio();
49040 wxPyEndAllowThreads(__tstate);
49041 if (PyErr_Occurred()) SWIG_fail;
49042 }
49043 resultobj = SWIG_From_float(static_cast< float >(result));
49044 return resultobj;
49045 fail:
49046 return NULL;
49047 }
49048
49049
49050 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49051 PyObject *resultobj = 0;
49052 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49053 wxRect result;
49054 void *argp1 = 0 ;
49055 int res1 = 0 ;
49056 PyObject *swig_obj[1] ;
49057
49058 if (!args) SWIG_fail;
49059 swig_obj[0] = args;
49060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49061 if (!SWIG_IsOK(res1)) {
49062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49063 }
49064 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49065 {
49066 PyThreadState* __tstate = wxPyBeginAllowThreads();
49067 result = (arg1)->GetRect();
49068 wxPyEndAllowThreads(__tstate);
49069 if (PyErr_Occurred()) SWIG_fail;
49070 }
49071 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49072 return resultobj;
49073 fail:
49074 return NULL;
49075 }
49076
49077
49078 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49079 PyObject *resultobj = 0;
49080 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49081 bool result;
49082 void *argp1 = 0 ;
49083 int res1 = 0 ;
49084 PyObject *swig_obj[1] ;
49085
49086 if (!args) SWIG_fail;
49087 swig_obj[0] = args;
49088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49089 if (!SWIG_IsOK(res1)) {
49090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49091 }
49092 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49093 {
49094 PyThreadState* __tstate = wxPyBeginAllowThreads();
49095 result = (bool)(arg1)->IsWindow();
49096 wxPyEndAllowThreads(__tstate);
49097 if (PyErr_Occurred()) SWIG_fail;
49098 }
49099 {
49100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49101 }
49102 return resultobj;
49103 fail:
49104 return NULL;
49105 }
49106
49107
49108 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49109 PyObject *resultobj = 0;
49110 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49111 bool result;
49112 void *argp1 = 0 ;
49113 int res1 = 0 ;
49114 PyObject *swig_obj[1] ;
49115
49116 if (!args) SWIG_fail;
49117 swig_obj[0] = args;
49118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49119 if (!SWIG_IsOK(res1)) {
49120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49121 }
49122 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49123 {
49124 PyThreadState* __tstate = wxPyBeginAllowThreads();
49125 result = (bool)(arg1)->IsSizer();
49126 wxPyEndAllowThreads(__tstate);
49127 if (PyErr_Occurred()) SWIG_fail;
49128 }
49129 {
49130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49131 }
49132 return resultobj;
49133 fail:
49134 return NULL;
49135 }
49136
49137
49138 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49139 PyObject *resultobj = 0;
49140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49141 bool result;
49142 void *argp1 = 0 ;
49143 int res1 = 0 ;
49144 PyObject *swig_obj[1] ;
49145
49146 if (!args) SWIG_fail;
49147 swig_obj[0] = args;
49148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49149 if (!SWIG_IsOK(res1)) {
49150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49151 }
49152 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49153 {
49154 PyThreadState* __tstate = wxPyBeginAllowThreads();
49155 result = (bool)(arg1)->IsSpacer();
49156 wxPyEndAllowThreads(__tstate);
49157 if (PyErr_Occurred()) SWIG_fail;
49158 }
49159 {
49160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49161 }
49162 return resultobj;
49163 fail:
49164 return NULL;
49165 }
49166
49167
49168 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49169 PyObject *resultobj = 0;
49170 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49171 int arg2 ;
49172 void *argp1 = 0 ;
49173 int res1 = 0 ;
49174 int val2 ;
49175 int ecode2 = 0 ;
49176 PyObject * obj0 = 0 ;
49177 PyObject * obj1 = 0 ;
49178 char * kwnames[] = {
49179 (char *) "self",(char *) "proportion", NULL
49180 };
49181
49182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49184 if (!SWIG_IsOK(res1)) {
49185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49186 }
49187 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49188 ecode2 = SWIG_AsVal_int(obj1, &val2);
49189 if (!SWIG_IsOK(ecode2)) {
49190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49191 }
49192 arg2 = static_cast< int >(val2);
49193 {
49194 PyThreadState* __tstate = wxPyBeginAllowThreads();
49195 (arg1)->SetProportion(arg2);
49196 wxPyEndAllowThreads(__tstate);
49197 if (PyErr_Occurred()) SWIG_fail;
49198 }
49199 resultobj = SWIG_Py_Void();
49200 return resultobj;
49201 fail:
49202 return NULL;
49203 }
49204
49205
49206 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49207 PyObject *resultobj = 0;
49208 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49209 int result;
49210 void *argp1 = 0 ;
49211 int res1 = 0 ;
49212 PyObject *swig_obj[1] ;
49213
49214 if (!args) SWIG_fail;
49215 swig_obj[0] = args;
49216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49217 if (!SWIG_IsOK(res1)) {
49218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49219 }
49220 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49221 {
49222 PyThreadState* __tstate = wxPyBeginAllowThreads();
49223 result = (int)(arg1)->GetProportion();
49224 wxPyEndAllowThreads(__tstate);
49225 if (PyErr_Occurred()) SWIG_fail;
49226 }
49227 resultobj = SWIG_From_int(static_cast< int >(result));
49228 return resultobj;
49229 fail:
49230 return NULL;
49231 }
49232
49233
49234 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49235 PyObject *resultobj = 0;
49236 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49237 int arg2 ;
49238 void *argp1 = 0 ;
49239 int res1 = 0 ;
49240 int val2 ;
49241 int ecode2 = 0 ;
49242 PyObject * obj0 = 0 ;
49243 PyObject * obj1 = 0 ;
49244 char * kwnames[] = {
49245 (char *) "self",(char *) "flag", NULL
49246 };
49247
49248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49250 if (!SWIG_IsOK(res1)) {
49251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49252 }
49253 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49254 ecode2 = SWIG_AsVal_int(obj1, &val2);
49255 if (!SWIG_IsOK(ecode2)) {
49256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49257 }
49258 arg2 = static_cast< int >(val2);
49259 {
49260 PyThreadState* __tstate = wxPyBeginAllowThreads();
49261 (arg1)->SetFlag(arg2);
49262 wxPyEndAllowThreads(__tstate);
49263 if (PyErr_Occurred()) SWIG_fail;
49264 }
49265 resultobj = SWIG_Py_Void();
49266 return resultobj;
49267 fail:
49268 return NULL;
49269 }
49270
49271
49272 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49273 PyObject *resultobj = 0;
49274 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49275 int result;
49276 void *argp1 = 0 ;
49277 int res1 = 0 ;
49278 PyObject *swig_obj[1] ;
49279
49280 if (!args) SWIG_fail;
49281 swig_obj[0] = args;
49282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49283 if (!SWIG_IsOK(res1)) {
49284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49285 }
49286 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49287 {
49288 PyThreadState* __tstate = wxPyBeginAllowThreads();
49289 result = (int)(arg1)->GetFlag();
49290 wxPyEndAllowThreads(__tstate);
49291 if (PyErr_Occurred()) SWIG_fail;
49292 }
49293 resultobj = SWIG_From_int(static_cast< int >(result));
49294 return resultobj;
49295 fail:
49296 return NULL;
49297 }
49298
49299
49300 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49301 PyObject *resultobj = 0;
49302 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49303 int arg2 ;
49304 void *argp1 = 0 ;
49305 int res1 = 0 ;
49306 int val2 ;
49307 int ecode2 = 0 ;
49308 PyObject * obj0 = 0 ;
49309 PyObject * obj1 = 0 ;
49310 char * kwnames[] = {
49311 (char *) "self",(char *) "border", NULL
49312 };
49313
49314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49316 if (!SWIG_IsOK(res1)) {
49317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49318 }
49319 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49320 ecode2 = SWIG_AsVal_int(obj1, &val2);
49321 if (!SWIG_IsOK(ecode2)) {
49322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49323 }
49324 arg2 = static_cast< int >(val2);
49325 {
49326 PyThreadState* __tstate = wxPyBeginAllowThreads();
49327 (arg1)->SetBorder(arg2);
49328 wxPyEndAllowThreads(__tstate);
49329 if (PyErr_Occurred()) SWIG_fail;
49330 }
49331 resultobj = SWIG_Py_Void();
49332 return resultobj;
49333 fail:
49334 return NULL;
49335 }
49336
49337
49338 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49339 PyObject *resultobj = 0;
49340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49341 int result;
49342 void *argp1 = 0 ;
49343 int res1 = 0 ;
49344 PyObject *swig_obj[1] ;
49345
49346 if (!args) SWIG_fail;
49347 swig_obj[0] = args;
49348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49349 if (!SWIG_IsOK(res1)) {
49350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49351 }
49352 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49353 {
49354 PyThreadState* __tstate = wxPyBeginAllowThreads();
49355 result = (int)(arg1)->GetBorder();
49356 wxPyEndAllowThreads(__tstate);
49357 if (PyErr_Occurred()) SWIG_fail;
49358 }
49359 resultobj = SWIG_From_int(static_cast< int >(result));
49360 return resultobj;
49361 fail:
49362 return NULL;
49363 }
49364
49365
49366 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49367 PyObject *resultobj = 0;
49368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49369 wxWindow *result = 0 ;
49370 void *argp1 = 0 ;
49371 int res1 = 0 ;
49372 PyObject *swig_obj[1] ;
49373
49374 if (!args) SWIG_fail;
49375 swig_obj[0] = args;
49376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49377 if (!SWIG_IsOK(res1)) {
49378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49379 }
49380 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49381 {
49382 PyThreadState* __tstate = wxPyBeginAllowThreads();
49383 result = (wxWindow *)(arg1)->GetWindow();
49384 wxPyEndAllowThreads(__tstate);
49385 if (PyErr_Occurred()) SWIG_fail;
49386 }
49387 {
49388 resultobj = wxPyMake_wxObject(result, 0);
49389 }
49390 return resultobj;
49391 fail:
49392 return NULL;
49393 }
49394
49395
49396 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49397 PyObject *resultobj = 0;
49398 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49399 wxWindow *arg2 = (wxWindow *) 0 ;
49400 void *argp1 = 0 ;
49401 int res1 = 0 ;
49402 void *argp2 = 0 ;
49403 int res2 = 0 ;
49404 PyObject * obj0 = 0 ;
49405 PyObject * obj1 = 0 ;
49406 char * kwnames[] = {
49407 (char *) "self",(char *) "window", NULL
49408 };
49409
49410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49412 if (!SWIG_IsOK(res1)) {
49413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49414 }
49415 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49417 if (!SWIG_IsOK(res2)) {
49418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49419 }
49420 arg2 = reinterpret_cast< wxWindow * >(argp2);
49421 {
49422 PyThreadState* __tstate = wxPyBeginAllowThreads();
49423 (arg1)->SetWindow(arg2);
49424 wxPyEndAllowThreads(__tstate);
49425 if (PyErr_Occurred()) SWIG_fail;
49426 }
49427 resultobj = SWIG_Py_Void();
49428 return resultobj;
49429 fail:
49430 return NULL;
49431 }
49432
49433
49434 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49435 PyObject *resultobj = 0;
49436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49437 wxSizer *result = 0 ;
49438 void *argp1 = 0 ;
49439 int res1 = 0 ;
49440 PyObject *swig_obj[1] ;
49441
49442 if (!args) SWIG_fail;
49443 swig_obj[0] = args;
49444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49445 if (!SWIG_IsOK(res1)) {
49446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49447 }
49448 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49449 {
49450 PyThreadState* __tstate = wxPyBeginAllowThreads();
49451 result = (wxSizer *)(arg1)->GetSizer();
49452 wxPyEndAllowThreads(__tstate);
49453 if (PyErr_Occurred()) SWIG_fail;
49454 }
49455 {
49456 resultobj = wxPyMake_wxObject(result, (bool)0);
49457 }
49458 return resultobj;
49459 fail:
49460 return NULL;
49461 }
49462
49463
49464 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49465 PyObject *resultobj = 0;
49466 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49467 wxSizer *arg2 = (wxSizer *) 0 ;
49468 void *argp1 = 0 ;
49469 int res1 = 0 ;
49470 int res2 = 0 ;
49471 PyObject * obj0 = 0 ;
49472 PyObject * obj1 = 0 ;
49473 char * kwnames[] = {
49474 (char *) "self",(char *) "sizer", NULL
49475 };
49476
49477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49479 if (!SWIG_IsOK(res1)) {
49480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49481 }
49482 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49483 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49484 if (!SWIG_IsOK(res2)) {
49485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49486 }
49487 {
49488 PyThreadState* __tstate = wxPyBeginAllowThreads();
49489 (arg1)->SetSizer(arg2);
49490 wxPyEndAllowThreads(__tstate);
49491 if (PyErr_Occurred()) SWIG_fail;
49492 }
49493 resultobj = SWIG_Py_Void();
49494 return resultobj;
49495 fail:
49496 return NULL;
49497 }
49498
49499
49500 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49501 PyObject *resultobj = 0;
49502 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49503 wxSize result;
49504 void *argp1 = 0 ;
49505 int res1 = 0 ;
49506 PyObject *swig_obj[1] ;
49507
49508 if (!args) SWIG_fail;
49509 swig_obj[0] = args;
49510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49511 if (!SWIG_IsOK(res1)) {
49512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49513 }
49514 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49515 {
49516 PyThreadState* __tstate = wxPyBeginAllowThreads();
49517 result = (arg1)->GetSpacer();
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49522 return resultobj;
49523 fail:
49524 return NULL;
49525 }
49526
49527
49528 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49529 PyObject *resultobj = 0;
49530 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49531 wxSize *arg2 = 0 ;
49532 void *argp1 = 0 ;
49533 int res1 = 0 ;
49534 wxSize temp2 ;
49535 PyObject * obj0 = 0 ;
49536 PyObject * obj1 = 0 ;
49537 char * kwnames[] = {
49538 (char *) "self",(char *) "size", NULL
49539 };
49540
49541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49543 if (!SWIG_IsOK(res1)) {
49544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49545 }
49546 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49547 {
49548 arg2 = &temp2;
49549 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49550 }
49551 {
49552 PyThreadState* __tstate = wxPyBeginAllowThreads();
49553 (arg1)->SetSpacer((wxSize const &)*arg2);
49554 wxPyEndAllowThreads(__tstate);
49555 if (PyErr_Occurred()) SWIG_fail;
49556 }
49557 resultobj = SWIG_Py_Void();
49558 return resultobj;
49559 fail:
49560 return NULL;
49561 }
49562
49563
49564 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49565 PyObject *resultobj = 0;
49566 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49567 bool arg2 ;
49568 void *argp1 = 0 ;
49569 int res1 = 0 ;
49570 bool val2 ;
49571 int ecode2 = 0 ;
49572 PyObject * obj0 = 0 ;
49573 PyObject * obj1 = 0 ;
49574 char * kwnames[] = {
49575 (char *) "self",(char *) "show", NULL
49576 };
49577
49578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49580 if (!SWIG_IsOK(res1)) {
49581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49582 }
49583 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49584 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49585 if (!SWIG_IsOK(ecode2)) {
49586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49587 }
49588 arg2 = static_cast< bool >(val2);
49589 {
49590 PyThreadState* __tstate = wxPyBeginAllowThreads();
49591 (arg1)->Show(arg2);
49592 wxPyEndAllowThreads(__tstate);
49593 if (PyErr_Occurred()) SWIG_fail;
49594 }
49595 resultobj = SWIG_Py_Void();
49596 return resultobj;
49597 fail:
49598 return NULL;
49599 }
49600
49601
49602 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49603 PyObject *resultobj = 0;
49604 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49605 bool result;
49606 void *argp1 = 0 ;
49607 int res1 = 0 ;
49608 PyObject *swig_obj[1] ;
49609
49610 if (!args) SWIG_fail;
49611 swig_obj[0] = args;
49612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49613 if (!SWIG_IsOK(res1)) {
49614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49615 }
49616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49617 {
49618 PyThreadState* __tstate = wxPyBeginAllowThreads();
49619 result = (bool)(arg1)->IsShown();
49620 wxPyEndAllowThreads(__tstate);
49621 if (PyErr_Occurred()) SWIG_fail;
49622 }
49623 {
49624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49625 }
49626 return resultobj;
49627 fail:
49628 return NULL;
49629 }
49630
49631
49632 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49633 PyObject *resultobj = 0;
49634 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49635 wxPoint result;
49636 void *argp1 = 0 ;
49637 int res1 = 0 ;
49638 PyObject *swig_obj[1] ;
49639
49640 if (!args) SWIG_fail;
49641 swig_obj[0] = args;
49642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49643 if (!SWIG_IsOK(res1)) {
49644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49645 }
49646 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49647 {
49648 PyThreadState* __tstate = wxPyBeginAllowThreads();
49649 result = (arg1)->GetPosition();
49650 wxPyEndAllowThreads(__tstate);
49651 if (PyErr_Occurred()) SWIG_fail;
49652 }
49653 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49654 return resultobj;
49655 fail:
49656 return NULL;
49657 }
49658
49659
49660 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49661 PyObject *resultobj = 0;
49662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49663 PyObject *result = 0 ;
49664 void *argp1 = 0 ;
49665 int res1 = 0 ;
49666 PyObject *swig_obj[1] ;
49667
49668 if (!args) SWIG_fail;
49669 swig_obj[0] = args;
49670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49671 if (!SWIG_IsOK(res1)) {
49672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49673 }
49674 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49675 {
49676 PyThreadState* __tstate = wxPyBeginAllowThreads();
49677 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49678 wxPyEndAllowThreads(__tstate);
49679 if (PyErr_Occurred()) SWIG_fail;
49680 }
49681 resultobj = result;
49682 return resultobj;
49683 fail:
49684 return NULL;
49685 }
49686
49687
49688 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49689 PyObject *resultobj = 0;
49690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49691 PyObject *arg2 = (PyObject *) 0 ;
49692 void *argp1 = 0 ;
49693 int res1 = 0 ;
49694 PyObject * obj0 = 0 ;
49695 PyObject * obj1 = 0 ;
49696 char * kwnames[] = {
49697 (char *) "self",(char *) "userData", NULL
49698 };
49699
49700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49702 if (!SWIG_IsOK(res1)) {
49703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49704 }
49705 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49706 arg2 = obj1;
49707 {
49708 PyThreadState* __tstate = wxPyBeginAllowThreads();
49709 wxSizerItem_SetUserData(arg1,arg2);
49710 wxPyEndAllowThreads(__tstate);
49711 if (PyErr_Occurred()) SWIG_fail;
49712 }
49713 resultobj = SWIG_Py_Void();
49714 return resultobj;
49715 fail:
49716 return NULL;
49717 }
49718
49719
49720 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49721 PyObject *obj;
49722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49723 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49724 return SWIG_Py_Void();
49725 }
49726
49727 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49728 return SWIG_Python_InitShadowInstance(args);
49729 }
49730
49731 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49732 PyObject *resultobj = 0;
49733 wxSizer *arg1 = (wxSizer *) 0 ;
49734 void *argp1 = 0 ;
49735 int res1 = 0 ;
49736 PyObject *swig_obj[1] ;
49737
49738 if (!args) SWIG_fail;
49739 swig_obj[0] = args;
49740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49741 if (!SWIG_IsOK(res1)) {
49742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49743 }
49744 arg1 = reinterpret_cast< wxSizer * >(argp1);
49745 {
49746 PyThreadState* __tstate = wxPyBeginAllowThreads();
49747 delete arg1;
49748
49749 wxPyEndAllowThreads(__tstate);
49750 if (PyErr_Occurred()) SWIG_fail;
49751 }
49752 resultobj = SWIG_Py_Void();
49753 return resultobj;
49754 fail:
49755 return NULL;
49756 }
49757
49758
49759 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49760 PyObject *resultobj = 0;
49761 wxSizer *arg1 = (wxSizer *) 0 ;
49762 PyObject *arg2 = (PyObject *) 0 ;
49763 void *argp1 = 0 ;
49764 int res1 = 0 ;
49765 PyObject * obj0 = 0 ;
49766 PyObject * obj1 = 0 ;
49767 char * kwnames[] = {
49768 (char *) "self",(char *) "_self", NULL
49769 };
49770
49771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49773 if (!SWIG_IsOK(res1)) {
49774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49775 }
49776 arg1 = reinterpret_cast< wxSizer * >(argp1);
49777 arg2 = obj1;
49778 {
49779 PyThreadState* __tstate = wxPyBeginAllowThreads();
49780 wxSizer__setOORInfo(arg1,arg2);
49781 wxPyEndAllowThreads(__tstate);
49782 if (PyErr_Occurred()) SWIG_fail;
49783 }
49784 resultobj = SWIG_Py_Void();
49785 return resultobj;
49786 fail:
49787 return NULL;
49788 }
49789
49790
49791 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49792 PyObject *resultobj = 0;
49793 wxSizer *arg1 = (wxSizer *) 0 ;
49794 PyObject *arg2 = (PyObject *) 0 ;
49795 int arg3 = (int) 0 ;
49796 int arg4 = (int) 0 ;
49797 int arg5 = (int) 0 ;
49798 PyObject *arg6 = (PyObject *) NULL ;
49799 wxSizerItem *result = 0 ;
49800 void *argp1 = 0 ;
49801 int res1 = 0 ;
49802 int val3 ;
49803 int ecode3 = 0 ;
49804 int val4 ;
49805 int ecode4 = 0 ;
49806 int val5 ;
49807 int ecode5 = 0 ;
49808 PyObject * obj0 = 0 ;
49809 PyObject * obj1 = 0 ;
49810 PyObject * obj2 = 0 ;
49811 PyObject * obj3 = 0 ;
49812 PyObject * obj4 = 0 ;
49813 PyObject * obj5 = 0 ;
49814 char * kwnames[] = {
49815 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49816 };
49817
49818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49820 if (!SWIG_IsOK(res1)) {
49821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49822 }
49823 arg1 = reinterpret_cast< wxSizer * >(argp1);
49824 arg2 = obj1;
49825 if (obj2) {
49826 ecode3 = SWIG_AsVal_int(obj2, &val3);
49827 if (!SWIG_IsOK(ecode3)) {
49828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49829 }
49830 arg3 = static_cast< int >(val3);
49831 }
49832 if (obj3) {
49833 ecode4 = SWIG_AsVal_int(obj3, &val4);
49834 if (!SWIG_IsOK(ecode4)) {
49835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49836 }
49837 arg4 = static_cast< int >(val4);
49838 }
49839 if (obj4) {
49840 ecode5 = SWIG_AsVal_int(obj4, &val5);
49841 if (!SWIG_IsOK(ecode5)) {
49842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49843 }
49844 arg5 = static_cast< int >(val5);
49845 }
49846 if (obj5) {
49847 arg6 = obj5;
49848 }
49849 {
49850 PyThreadState* __tstate = wxPyBeginAllowThreads();
49851 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49852 wxPyEndAllowThreads(__tstate);
49853 if (PyErr_Occurred()) SWIG_fail;
49854 }
49855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49856 return resultobj;
49857 fail:
49858 return NULL;
49859 }
49860
49861
49862 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49863 PyObject *resultobj = 0;
49864 wxSizer *arg1 = (wxSizer *) 0 ;
49865 int arg2 ;
49866 PyObject *arg3 = (PyObject *) 0 ;
49867 int arg4 = (int) 0 ;
49868 int arg5 = (int) 0 ;
49869 int arg6 = (int) 0 ;
49870 PyObject *arg7 = (PyObject *) NULL ;
49871 wxSizerItem *result = 0 ;
49872 void *argp1 = 0 ;
49873 int res1 = 0 ;
49874 int val2 ;
49875 int ecode2 = 0 ;
49876 int val4 ;
49877 int ecode4 = 0 ;
49878 int val5 ;
49879 int ecode5 = 0 ;
49880 int val6 ;
49881 int ecode6 = 0 ;
49882 PyObject * obj0 = 0 ;
49883 PyObject * obj1 = 0 ;
49884 PyObject * obj2 = 0 ;
49885 PyObject * obj3 = 0 ;
49886 PyObject * obj4 = 0 ;
49887 PyObject * obj5 = 0 ;
49888 PyObject * obj6 = 0 ;
49889 char * kwnames[] = {
49890 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49891 };
49892
49893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49895 if (!SWIG_IsOK(res1)) {
49896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49897 }
49898 arg1 = reinterpret_cast< wxSizer * >(argp1);
49899 ecode2 = SWIG_AsVal_int(obj1, &val2);
49900 if (!SWIG_IsOK(ecode2)) {
49901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49902 }
49903 arg2 = static_cast< int >(val2);
49904 arg3 = obj2;
49905 if (obj3) {
49906 ecode4 = SWIG_AsVal_int(obj3, &val4);
49907 if (!SWIG_IsOK(ecode4)) {
49908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49909 }
49910 arg4 = static_cast< int >(val4);
49911 }
49912 if (obj4) {
49913 ecode5 = SWIG_AsVal_int(obj4, &val5);
49914 if (!SWIG_IsOK(ecode5)) {
49915 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49916 }
49917 arg5 = static_cast< int >(val5);
49918 }
49919 if (obj5) {
49920 ecode6 = SWIG_AsVal_int(obj5, &val6);
49921 if (!SWIG_IsOK(ecode6)) {
49922 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49923 }
49924 arg6 = static_cast< int >(val6);
49925 }
49926 if (obj6) {
49927 arg7 = obj6;
49928 }
49929 {
49930 PyThreadState* __tstate = wxPyBeginAllowThreads();
49931 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49932 wxPyEndAllowThreads(__tstate);
49933 if (PyErr_Occurred()) SWIG_fail;
49934 }
49935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49936 return resultobj;
49937 fail:
49938 return NULL;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49943 PyObject *resultobj = 0;
49944 wxSizer *arg1 = (wxSizer *) 0 ;
49945 PyObject *arg2 = (PyObject *) 0 ;
49946 int arg3 = (int) 0 ;
49947 int arg4 = (int) 0 ;
49948 int arg5 = (int) 0 ;
49949 PyObject *arg6 = (PyObject *) NULL ;
49950 wxSizerItem *result = 0 ;
49951 void *argp1 = 0 ;
49952 int res1 = 0 ;
49953 int val3 ;
49954 int ecode3 = 0 ;
49955 int val4 ;
49956 int ecode4 = 0 ;
49957 int val5 ;
49958 int ecode5 = 0 ;
49959 PyObject * obj0 = 0 ;
49960 PyObject * obj1 = 0 ;
49961 PyObject * obj2 = 0 ;
49962 PyObject * obj3 = 0 ;
49963 PyObject * obj4 = 0 ;
49964 PyObject * obj5 = 0 ;
49965 char * kwnames[] = {
49966 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49967 };
49968
49969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49971 if (!SWIG_IsOK(res1)) {
49972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49973 }
49974 arg1 = reinterpret_cast< wxSizer * >(argp1);
49975 arg2 = obj1;
49976 if (obj2) {
49977 ecode3 = SWIG_AsVal_int(obj2, &val3);
49978 if (!SWIG_IsOK(ecode3)) {
49979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49980 }
49981 arg3 = static_cast< int >(val3);
49982 }
49983 if (obj3) {
49984 ecode4 = SWIG_AsVal_int(obj3, &val4);
49985 if (!SWIG_IsOK(ecode4)) {
49986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49987 }
49988 arg4 = static_cast< int >(val4);
49989 }
49990 if (obj4) {
49991 ecode5 = SWIG_AsVal_int(obj4, &val5);
49992 if (!SWIG_IsOK(ecode5)) {
49993 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49994 }
49995 arg5 = static_cast< int >(val5);
49996 }
49997 if (obj5) {
49998 arg6 = obj5;
49999 }
50000 {
50001 PyThreadState* __tstate = wxPyBeginAllowThreads();
50002 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50003 wxPyEndAllowThreads(__tstate);
50004 if (PyErr_Occurred()) SWIG_fail;
50005 }
50006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50007 return resultobj;
50008 fail:
50009 return NULL;
50010 }
50011
50012
50013 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50014 PyObject *resultobj = 0;
50015 wxSizer *arg1 = (wxSizer *) 0 ;
50016 PyObject *arg2 = (PyObject *) 0 ;
50017 bool result;
50018 void *argp1 = 0 ;
50019 int res1 = 0 ;
50020 PyObject * obj0 = 0 ;
50021 PyObject * obj1 = 0 ;
50022 char * kwnames[] = {
50023 (char *) "self",(char *) "item", NULL
50024 };
50025
50026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50028 if (!SWIG_IsOK(res1)) {
50029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50030 }
50031 arg1 = reinterpret_cast< wxSizer * >(argp1);
50032 arg2 = obj1;
50033 {
50034 PyThreadState* __tstate = wxPyBeginAllowThreads();
50035 result = (bool)wxSizer_Remove(arg1,arg2);
50036 wxPyEndAllowThreads(__tstate);
50037 if (PyErr_Occurred()) SWIG_fail;
50038 }
50039 {
50040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50041 }
50042 return resultobj;
50043 fail:
50044 return NULL;
50045 }
50046
50047
50048 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50049 PyObject *resultobj = 0;
50050 wxSizer *arg1 = (wxSizer *) 0 ;
50051 PyObject *arg2 = (PyObject *) 0 ;
50052 bool result;
50053 void *argp1 = 0 ;
50054 int res1 = 0 ;
50055 PyObject * obj0 = 0 ;
50056 PyObject * obj1 = 0 ;
50057 char * kwnames[] = {
50058 (char *) "self",(char *) "item", NULL
50059 };
50060
50061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50063 if (!SWIG_IsOK(res1)) {
50064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50065 }
50066 arg1 = reinterpret_cast< wxSizer * >(argp1);
50067 arg2 = obj1;
50068 {
50069 PyThreadState* __tstate = wxPyBeginAllowThreads();
50070 result = (bool)wxSizer_Detach(arg1,arg2);
50071 wxPyEndAllowThreads(__tstate);
50072 if (PyErr_Occurred()) SWIG_fail;
50073 }
50074 {
50075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50076 }
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50084 PyObject *resultobj = 0;
50085 wxSizer *arg1 = (wxSizer *) 0 ;
50086 PyObject *arg2 = (PyObject *) 0 ;
50087 wxSizerItem *result = 0 ;
50088 void *argp1 = 0 ;
50089 int res1 = 0 ;
50090 PyObject * obj0 = 0 ;
50091 PyObject * obj1 = 0 ;
50092 char * kwnames[] = {
50093 (char *) "self",(char *) "item", NULL
50094 };
50095
50096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50098 if (!SWIG_IsOK(res1)) {
50099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50100 }
50101 arg1 = reinterpret_cast< wxSizer * >(argp1);
50102 arg2 = obj1;
50103 {
50104 PyThreadState* __tstate = wxPyBeginAllowThreads();
50105 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50106 wxPyEndAllowThreads(__tstate);
50107 if (PyErr_Occurred()) SWIG_fail;
50108 }
50109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50110 return resultobj;
50111 fail:
50112 return NULL;
50113 }
50114
50115
50116 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50117 PyObject *resultobj = 0;
50118 wxSizer *arg1 = (wxSizer *) 0 ;
50119 PyObject *arg2 = (PyObject *) 0 ;
50120 wxSize *arg3 = 0 ;
50121 void *argp1 = 0 ;
50122 int res1 = 0 ;
50123 wxSize temp3 ;
50124 PyObject * obj0 = 0 ;
50125 PyObject * obj1 = 0 ;
50126 PyObject * obj2 = 0 ;
50127 char * kwnames[] = {
50128 (char *) "self",(char *) "item",(char *) "size", NULL
50129 };
50130
50131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50133 if (!SWIG_IsOK(res1)) {
50134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50135 }
50136 arg1 = reinterpret_cast< wxSizer * >(argp1);
50137 arg2 = obj1;
50138 {
50139 arg3 = &temp3;
50140 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50141 }
50142 {
50143 PyThreadState* __tstate = wxPyBeginAllowThreads();
50144 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50145 wxPyEndAllowThreads(__tstate);
50146 if (PyErr_Occurred()) SWIG_fail;
50147 }
50148 resultobj = SWIG_Py_Void();
50149 return resultobj;
50150 fail:
50151 return NULL;
50152 }
50153
50154
50155 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50156 PyObject *resultobj = 0;
50157 wxSizer *arg1 = (wxSizer *) 0 ;
50158 wxWindow *arg2 = (wxWindow *) 0 ;
50159 wxWindow *arg3 = (wxWindow *) 0 ;
50160 bool arg4 = (bool) false ;
50161 bool result;
50162 void *argp1 = 0 ;
50163 int res1 = 0 ;
50164 void *argp2 = 0 ;
50165 int res2 = 0 ;
50166 void *argp3 = 0 ;
50167 int res3 = 0 ;
50168 bool val4 ;
50169 int ecode4 = 0 ;
50170 PyObject * obj0 = 0 ;
50171 PyObject * obj1 = 0 ;
50172 PyObject * obj2 = 0 ;
50173 PyObject * obj3 = 0 ;
50174 char * kwnames[] = {
50175 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50176 };
50177
50178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50180 if (!SWIG_IsOK(res1)) {
50181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50182 }
50183 arg1 = reinterpret_cast< wxSizer * >(argp1);
50184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50185 if (!SWIG_IsOK(res2)) {
50186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50187 }
50188 arg2 = reinterpret_cast< wxWindow * >(argp2);
50189 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50190 if (!SWIG_IsOK(res3)) {
50191 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50192 }
50193 arg3 = reinterpret_cast< wxWindow * >(argp3);
50194 if (obj3) {
50195 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50196 if (!SWIG_IsOK(ecode4)) {
50197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50198 }
50199 arg4 = static_cast< bool >(val4);
50200 }
50201 {
50202 PyThreadState* __tstate = wxPyBeginAllowThreads();
50203 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50204 wxPyEndAllowThreads(__tstate);
50205 if (PyErr_Occurred()) SWIG_fail;
50206 }
50207 {
50208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50209 }
50210 return resultobj;
50211 fail:
50212 return NULL;
50213 }
50214
50215
50216 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50217 PyObject *resultobj = 0;
50218 wxSizer *arg1 = (wxSizer *) 0 ;
50219 wxSizer *arg2 = (wxSizer *) 0 ;
50220 wxSizer *arg3 = (wxSizer *) 0 ;
50221 bool arg4 = (bool) false ;
50222 bool result;
50223 void *argp1 = 0 ;
50224 int res1 = 0 ;
50225 void *argp2 = 0 ;
50226 int res2 = 0 ;
50227 void *argp3 = 0 ;
50228 int res3 = 0 ;
50229 bool val4 ;
50230 int ecode4 = 0 ;
50231 PyObject * obj0 = 0 ;
50232 PyObject * obj1 = 0 ;
50233 PyObject * obj2 = 0 ;
50234 PyObject * obj3 = 0 ;
50235 char * kwnames[] = {
50236 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50237 };
50238
50239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50241 if (!SWIG_IsOK(res1)) {
50242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50243 }
50244 arg1 = reinterpret_cast< wxSizer * >(argp1);
50245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50246 if (!SWIG_IsOK(res2)) {
50247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50248 }
50249 arg2 = reinterpret_cast< wxSizer * >(argp2);
50250 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50251 if (!SWIG_IsOK(res3)) {
50252 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50253 }
50254 arg3 = reinterpret_cast< wxSizer * >(argp3);
50255 if (obj3) {
50256 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50257 if (!SWIG_IsOK(ecode4)) {
50258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50259 }
50260 arg4 = static_cast< bool >(val4);
50261 }
50262 {
50263 PyThreadState* __tstate = wxPyBeginAllowThreads();
50264 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50265 wxPyEndAllowThreads(__tstate);
50266 if (PyErr_Occurred()) SWIG_fail;
50267 }
50268 {
50269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50270 }
50271 return resultobj;
50272 fail:
50273 return NULL;
50274 }
50275
50276
50277 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50278 PyObject *resultobj = 0;
50279 wxSizer *arg1 = (wxSizer *) 0 ;
50280 size_t arg2 ;
50281 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50282 bool result;
50283 void *argp1 = 0 ;
50284 int res1 = 0 ;
50285 size_t val2 ;
50286 int ecode2 = 0 ;
50287 void *argp3 = 0 ;
50288 int res3 = 0 ;
50289 PyObject * obj0 = 0 ;
50290 PyObject * obj1 = 0 ;
50291 PyObject * obj2 = 0 ;
50292 char * kwnames[] = {
50293 (char *) "self",(char *) "index",(char *) "newitem", NULL
50294 };
50295
50296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50298 if (!SWIG_IsOK(res1)) {
50299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50300 }
50301 arg1 = reinterpret_cast< wxSizer * >(argp1);
50302 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50303 if (!SWIG_IsOK(ecode2)) {
50304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50305 }
50306 arg2 = static_cast< size_t >(val2);
50307 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50308 if (!SWIG_IsOK(res3)) {
50309 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50310 }
50311 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50312 {
50313 PyThreadState* __tstate = wxPyBeginAllowThreads();
50314 result = (bool)(arg1)->Replace(arg2,arg3);
50315 wxPyEndAllowThreads(__tstate);
50316 if (PyErr_Occurred()) SWIG_fail;
50317 }
50318 {
50319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50320 }
50321 return resultobj;
50322 fail:
50323 return NULL;
50324 }
50325
50326
50327 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50328 PyObject *resultobj = 0;
50329 wxSizer *arg1 = (wxSizer *) 0 ;
50330 wxWindow *arg2 = (wxWindow *) 0 ;
50331 void *argp1 = 0 ;
50332 int res1 = 0 ;
50333 void *argp2 = 0 ;
50334 int res2 = 0 ;
50335 PyObject * obj0 = 0 ;
50336 PyObject * obj1 = 0 ;
50337 char * kwnames[] = {
50338 (char *) "self",(char *) "window", NULL
50339 };
50340
50341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50343 if (!SWIG_IsOK(res1)) {
50344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50345 }
50346 arg1 = reinterpret_cast< wxSizer * >(argp1);
50347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50348 if (!SWIG_IsOK(res2)) {
50349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50350 }
50351 arg2 = reinterpret_cast< wxWindow * >(argp2);
50352 {
50353 PyThreadState* __tstate = wxPyBeginAllowThreads();
50354 (arg1)->SetContainingWindow(arg2);
50355 wxPyEndAllowThreads(__tstate);
50356 if (PyErr_Occurred()) SWIG_fail;
50357 }
50358 resultobj = SWIG_Py_Void();
50359 return resultobj;
50360 fail:
50361 return NULL;
50362 }
50363
50364
50365 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50366 PyObject *resultobj = 0;
50367 wxSizer *arg1 = (wxSizer *) 0 ;
50368 wxWindow *result = 0 ;
50369 void *argp1 = 0 ;
50370 int res1 = 0 ;
50371 PyObject *swig_obj[1] ;
50372
50373 if (!args) SWIG_fail;
50374 swig_obj[0] = args;
50375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50376 if (!SWIG_IsOK(res1)) {
50377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50378 }
50379 arg1 = reinterpret_cast< wxSizer * >(argp1);
50380 {
50381 PyThreadState* __tstate = wxPyBeginAllowThreads();
50382 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50383 wxPyEndAllowThreads(__tstate);
50384 if (PyErr_Occurred()) SWIG_fail;
50385 }
50386 {
50387 resultobj = wxPyMake_wxObject(result, 0);
50388 }
50389 return resultobj;
50390 fail:
50391 return NULL;
50392 }
50393
50394
50395 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50396 PyObject *resultobj = 0;
50397 wxSizer *arg1 = (wxSizer *) 0 ;
50398 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50399 wxSizerItem *result = 0 ;
50400 void *argp1 = 0 ;
50401 int res1 = 0 ;
50402 int res2 = 0 ;
50403 PyObject * obj0 = 0 ;
50404 PyObject * obj1 = 0 ;
50405 char * kwnames[] = {
50406 (char *) "self",(char *) "item", NULL
50407 };
50408
50409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50411 if (!SWIG_IsOK(res1)) {
50412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50413 }
50414 arg1 = reinterpret_cast< wxSizer * >(argp1);
50415 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50416 if (!SWIG_IsOK(res2)) {
50417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50418 }
50419 {
50420 PyThreadState* __tstate = wxPyBeginAllowThreads();
50421 result = (wxSizerItem *)(arg1)->Add(arg2);
50422 wxPyEndAllowThreads(__tstate);
50423 if (PyErr_Occurred()) SWIG_fail;
50424 }
50425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50426 return resultobj;
50427 fail:
50428 return NULL;
50429 }
50430
50431
50432 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50433 PyObject *resultobj = 0;
50434 wxSizer *arg1 = (wxSizer *) 0 ;
50435 size_t arg2 ;
50436 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50437 wxSizerItem *result = 0 ;
50438 void *argp1 = 0 ;
50439 int res1 = 0 ;
50440 size_t val2 ;
50441 int ecode2 = 0 ;
50442 int res3 = 0 ;
50443 PyObject * obj0 = 0 ;
50444 PyObject * obj1 = 0 ;
50445 PyObject * obj2 = 0 ;
50446 char * kwnames[] = {
50447 (char *) "self",(char *) "index",(char *) "item", NULL
50448 };
50449
50450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50452 if (!SWIG_IsOK(res1)) {
50453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50454 }
50455 arg1 = reinterpret_cast< wxSizer * >(argp1);
50456 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50457 if (!SWIG_IsOK(ecode2)) {
50458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50459 }
50460 arg2 = static_cast< size_t >(val2);
50461 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50462 if (!SWIG_IsOK(res3)) {
50463 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50464 }
50465 {
50466 PyThreadState* __tstate = wxPyBeginAllowThreads();
50467 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50468 wxPyEndAllowThreads(__tstate);
50469 if (PyErr_Occurred()) SWIG_fail;
50470 }
50471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50472 return resultobj;
50473 fail:
50474 return NULL;
50475 }
50476
50477
50478 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50479 PyObject *resultobj = 0;
50480 wxSizer *arg1 = (wxSizer *) 0 ;
50481 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50482 wxSizerItem *result = 0 ;
50483 void *argp1 = 0 ;
50484 int res1 = 0 ;
50485 int res2 = 0 ;
50486 PyObject * obj0 = 0 ;
50487 PyObject * obj1 = 0 ;
50488 char * kwnames[] = {
50489 (char *) "self",(char *) "item", NULL
50490 };
50491
50492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50494 if (!SWIG_IsOK(res1)) {
50495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50496 }
50497 arg1 = reinterpret_cast< wxSizer * >(argp1);
50498 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50499 if (!SWIG_IsOK(res2)) {
50500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50501 }
50502 {
50503 PyThreadState* __tstate = wxPyBeginAllowThreads();
50504 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50505 wxPyEndAllowThreads(__tstate);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50509 return resultobj;
50510 fail:
50511 return NULL;
50512 }
50513
50514
50515 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50516 PyObject *resultobj = 0;
50517 wxSizer *arg1 = (wxSizer *) 0 ;
50518 int arg2 ;
50519 int arg3 ;
50520 int arg4 ;
50521 int arg5 ;
50522 void *argp1 = 0 ;
50523 int res1 = 0 ;
50524 int val2 ;
50525 int ecode2 = 0 ;
50526 int val3 ;
50527 int ecode3 = 0 ;
50528 int val4 ;
50529 int ecode4 = 0 ;
50530 int val5 ;
50531 int ecode5 = 0 ;
50532 PyObject * obj0 = 0 ;
50533 PyObject * obj1 = 0 ;
50534 PyObject * obj2 = 0 ;
50535 PyObject * obj3 = 0 ;
50536 PyObject * obj4 = 0 ;
50537 char * kwnames[] = {
50538 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50539 };
50540
50541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50543 if (!SWIG_IsOK(res1)) {
50544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50545 }
50546 arg1 = reinterpret_cast< wxSizer * >(argp1);
50547 ecode2 = SWIG_AsVal_int(obj1, &val2);
50548 if (!SWIG_IsOK(ecode2)) {
50549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50550 }
50551 arg2 = static_cast< int >(val2);
50552 ecode3 = SWIG_AsVal_int(obj2, &val3);
50553 if (!SWIG_IsOK(ecode3)) {
50554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50555 }
50556 arg3 = static_cast< int >(val3);
50557 ecode4 = SWIG_AsVal_int(obj3, &val4);
50558 if (!SWIG_IsOK(ecode4)) {
50559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50560 }
50561 arg4 = static_cast< int >(val4);
50562 ecode5 = SWIG_AsVal_int(obj4, &val5);
50563 if (!SWIG_IsOK(ecode5)) {
50564 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50565 }
50566 arg5 = static_cast< int >(val5);
50567 {
50568 PyThreadState* __tstate = wxPyBeginAllowThreads();
50569 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50570 wxPyEndAllowThreads(__tstate);
50571 if (PyErr_Occurred()) SWIG_fail;
50572 }
50573 resultobj = SWIG_Py_Void();
50574 return resultobj;
50575 fail:
50576 return NULL;
50577 }
50578
50579
50580 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50581 PyObject *resultobj = 0;
50582 wxSizer *arg1 = (wxSizer *) 0 ;
50583 wxSize *arg2 = 0 ;
50584 void *argp1 = 0 ;
50585 int res1 = 0 ;
50586 wxSize temp2 ;
50587 PyObject * obj0 = 0 ;
50588 PyObject * obj1 = 0 ;
50589 char * kwnames[] = {
50590 (char *) "self",(char *) "size", NULL
50591 };
50592
50593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50595 if (!SWIG_IsOK(res1)) {
50596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50597 }
50598 arg1 = reinterpret_cast< wxSizer * >(argp1);
50599 {
50600 arg2 = &temp2;
50601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50602 }
50603 {
50604 PyThreadState* __tstate = wxPyBeginAllowThreads();
50605 (arg1)->SetMinSize((wxSize const &)*arg2);
50606 wxPyEndAllowThreads(__tstate);
50607 if (PyErr_Occurred()) SWIG_fail;
50608 }
50609 resultobj = SWIG_Py_Void();
50610 return resultobj;
50611 fail:
50612 return NULL;
50613 }
50614
50615
50616 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50617 PyObject *resultobj = 0;
50618 wxSizer *arg1 = (wxSizer *) 0 ;
50619 wxSize result;
50620 void *argp1 = 0 ;
50621 int res1 = 0 ;
50622 PyObject *swig_obj[1] ;
50623
50624 if (!args) SWIG_fail;
50625 swig_obj[0] = args;
50626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50627 if (!SWIG_IsOK(res1)) {
50628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50629 }
50630 arg1 = reinterpret_cast< wxSizer * >(argp1);
50631 {
50632 PyThreadState* __tstate = wxPyBeginAllowThreads();
50633 result = (arg1)->GetSize();
50634 wxPyEndAllowThreads(__tstate);
50635 if (PyErr_Occurred()) SWIG_fail;
50636 }
50637 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50638 return resultobj;
50639 fail:
50640 return NULL;
50641 }
50642
50643
50644 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50645 PyObject *resultobj = 0;
50646 wxSizer *arg1 = (wxSizer *) 0 ;
50647 wxPoint result;
50648 void *argp1 = 0 ;
50649 int res1 = 0 ;
50650 PyObject *swig_obj[1] ;
50651
50652 if (!args) SWIG_fail;
50653 swig_obj[0] = args;
50654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50655 if (!SWIG_IsOK(res1)) {
50656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50657 }
50658 arg1 = reinterpret_cast< wxSizer * >(argp1);
50659 {
50660 PyThreadState* __tstate = wxPyBeginAllowThreads();
50661 result = (arg1)->GetPosition();
50662 wxPyEndAllowThreads(__tstate);
50663 if (PyErr_Occurred()) SWIG_fail;
50664 }
50665 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50666 return resultobj;
50667 fail:
50668 return NULL;
50669 }
50670
50671
50672 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50673 PyObject *resultobj = 0;
50674 wxSizer *arg1 = (wxSizer *) 0 ;
50675 wxSize result;
50676 void *argp1 = 0 ;
50677 int res1 = 0 ;
50678 PyObject *swig_obj[1] ;
50679
50680 if (!args) SWIG_fail;
50681 swig_obj[0] = args;
50682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50683 if (!SWIG_IsOK(res1)) {
50684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50685 }
50686 arg1 = reinterpret_cast< wxSizer * >(argp1);
50687 {
50688 PyThreadState* __tstate = wxPyBeginAllowThreads();
50689 result = (arg1)->GetMinSize();
50690 wxPyEndAllowThreads(__tstate);
50691 if (PyErr_Occurred()) SWIG_fail;
50692 }
50693 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50694 return resultobj;
50695 fail:
50696 return NULL;
50697 }
50698
50699
50700 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50701 PyObject *resultobj = 0;
50702 wxSizer *arg1 = (wxSizer *) 0 ;
50703 void *argp1 = 0 ;
50704 int res1 = 0 ;
50705 PyObject *swig_obj[1] ;
50706
50707 if (!args) SWIG_fail;
50708 swig_obj[0] = args;
50709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50710 if (!SWIG_IsOK(res1)) {
50711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50712 }
50713 arg1 = reinterpret_cast< wxSizer * >(argp1);
50714 {
50715 PyThreadState* __tstate = wxPyBeginAllowThreads();
50716 (arg1)->RecalcSizes();
50717 wxPyEndAllowThreads(__tstate);
50718 if (PyErr_Occurred()) SWIG_fail;
50719 }
50720 resultobj = SWIG_Py_Void();
50721 return resultobj;
50722 fail:
50723 return NULL;
50724 }
50725
50726
50727 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50728 PyObject *resultobj = 0;
50729 wxSizer *arg1 = (wxSizer *) 0 ;
50730 wxSize result;
50731 void *argp1 = 0 ;
50732 int res1 = 0 ;
50733 PyObject *swig_obj[1] ;
50734
50735 if (!args) SWIG_fail;
50736 swig_obj[0] = args;
50737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50738 if (!SWIG_IsOK(res1)) {
50739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50740 }
50741 arg1 = reinterpret_cast< wxSizer * >(argp1);
50742 {
50743 PyThreadState* __tstate = wxPyBeginAllowThreads();
50744 result = (arg1)->CalcMin();
50745 wxPyEndAllowThreads(__tstate);
50746 if (PyErr_Occurred()) SWIG_fail;
50747 }
50748 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50749 return resultobj;
50750 fail:
50751 return NULL;
50752 }
50753
50754
50755 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50756 PyObject *resultobj = 0;
50757 wxSizer *arg1 = (wxSizer *) 0 ;
50758 void *argp1 = 0 ;
50759 int res1 = 0 ;
50760 PyObject *swig_obj[1] ;
50761
50762 if (!args) SWIG_fail;
50763 swig_obj[0] = args;
50764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50765 if (!SWIG_IsOK(res1)) {
50766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50767 }
50768 arg1 = reinterpret_cast< wxSizer * >(argp1);
50769 {
50770 PyThreadState* __tstate = wxPyBeginAllowThreads();
50771 (arg1)->Layout();
50772 wxPyEndAllowThreads(__tstate);
50773 if (PyErr_Occurred()) SWIG_fail;
50774 }
50775 resultobj = SWIG_Py_Void();
50776 return resultobj;
50777 fail:
50778 return NULL;
50779 }
50780
50781
50782 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50783 PyObject *resultobj = 0;
50784 wxSizer *arg1 = (wxSizer *) 0 ;
50785 wxWindow *arg2 = (wxWindow *) 0 ;
50786 wxSize result;
50787 void *argp1 = 0 ;
50788 int res1 = 0 ;
50789 void *argp2 = 0 ;
50790 int res2 = 0 ;
50791 PyObject * obj0 = 0 ;
50792 PyObject * obj1 = 0 ;
50793 char * kwnames[] = {
50794 (char *) "self",(char *) "window", NULL
50795 };
50796
50797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50799 if (!SWIG_IsOK(res1)) {
50800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50801 }
50802 arg1 = reinterpret_cast< wxSizer * >(argp1);
50803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50804 if (!SWIG_IsOK(res2)) {
50805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50806 }
50807 arg2 = reinterpret_cast< wxWindow * >(argp2);
50808 {
50809 PyThreadState* __tstate = wxPyBeginAllowThreads();
50810 result = (arg1)->Fit(arg2);
50811 wxPyEndAllowThreads(__tstate);
50812 if (PyErr_Occurred()) SWIG_fail;
50813 }
50814 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50815 return resultobj;
50816 fail:
50817 return NULL;
50818 }
50819
50820
50821 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50822 PyObject *resultobj = 0;
50823 wxSizer *arg1 = (wxSizer *) 0 ;
50824 wxWindow *arg2 = (wxWindow *) 0 ;
50825 void *argp1 = 0 ;
50826 int res1 = 0 ;
50827 void *argp2 = 0 ;
50828 int res2 = 0 ;
50829 PyObject * obj0 = 0 ;
50830 PyObject * obj1 = 0 ;
50831 char * kwnames[] = {
50832 (char *) "self",(char *) "window", NULL
50833 };
50834
50835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50837 if (!SWIG_IsOK(res1)) {
50838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50839 }
50840 arg1 = reinterpret_cast< wxSizer * >(argp1);
50841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50842 if (!SWIG_IsOK(res2)) {
50843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50844 }
50845 arg2 = reinterpret_cast< wxWindow * >(argp2);
50846 {
50847 PyThreadState* __tstate = wxPyBeginAllowThreads();
50848 (arg1)->FitInside(arg2);
50849 wxPyEndAllowThreads(__tstate);
50850 if (PyErr_Occurred()) SWIG_fail;
50851 }
50852 resultobj = SWIG_Py_Void();
50853 return resultobj;
50854 fail:
50855 return NULL;
50856 }
50857
50858
50859 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50860 PyObject *resultobj = 0;
50861 wxSizer *arg1 = (wxSizer *) 0 ;
50862 wxWindow *arg2 = (wxWindow *) 0 ;
50863 void *argp1 = 0 ;
50864 int res1 = 0 ;
50865 void *argp2 = 0 ;
50866 int res2 = 0 ;
50867 PyObject * obj0 = 0 ;
50868 PyObject * obj1 = 0 ;
50869 char * kwnames[] = {
50870 (char *) "self",(char *) "window", NULL
50871 };
50872
50873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50875 if (!SWIG_IsOK(res1)) {
50876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50877 }
50878 arg1 = reinterpret_cast< wxSizer * >(argp1);
50879 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50880 if (!SWIG_IsOK(res2)) {
50881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50882 }
50883 arg2 = reinterpret_cast< wxWindow * >(argp2);
50884 {
50885 PyThreadState* __tstate = wxPyBeginAllowThreads();
50886 (arg1)->SetSizeHints(arg2);
50887 wxPyEndAllowThreads(__tstate);
50888 if (PyErr_Occurred()) SWIG_fail;
50889 }
50890 resultobj = SWIG_Py_Void();
50891 return resultobj;
50892 fail:
50893 return NULL;
50894 }
50895
50896
50897 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50898 PyObject *resultobj = 0;
50899 wxSizer *arg1 = (wxSizer *) 0 ;
50900 wxWindow *arg2 = (wxWindow *) 0 ;
50901 void *argp1 = 0 ;
50902 int res1 = 0 ;
50903 void *argp2 = 0 ;
50904 int res2 = 0 ;
50905 PyObject * obj0 = 0 ;
50906 PyObject * obj1 = 0 ;
50907 char * kwnames[] = {
50908 (char *) "self",(char *) "window", NULL
50909 };
50910
50911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50913 if (!SWIG_IsOK(res1)) {
50914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50915 }
50916 arg1 = reinterpret_cast< wxSizer * >(argp1);
50917 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50918 if (!SWIG_IsOK(res2)) {
50919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50920 }
50921 arg2 = reinterpret_cast< wxWindow * >(argp2);
50922 {
50923 PyThreadState* __tstate = wxPyBeginAllowThreads();
50924 (arg1)->SetVirtualSizeHints(arg2);
50925 wxPyEndAllowThreads(__tstate);
50926 if (PyErr_Occurred()) SWIG_fail;
50927 }
50928 resultobj = SWIG_Py_Void();
50929 return resultobj;
50930 fail:
50931 return NULL;
50932 }
50933
50934
50935 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50936 PyObject *resultobj = 0;
50937 wxSizer *arg1 = (wxSizer *) 0 ;
50938 bool arg2 = (bool) false ;
50939 void *argp1 = 0 ;
50940 int res1 = 0 ;
50941 bool val2 ;
50942 int ecode2 = 0 ;
50943 PyObject * obj0 = 0 ;
50944 PyObject * obj1 = 0 ;
50945 char * kwnames[] = {
50946 (char *) "self",(char *) "deleteWindows", NULL
50947 };
50948
50949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50951 if (!SWIG_IsOK(res1)) {
50952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50953 }
50954 arg1 = reinterpret_cast< wxSizer * >(argp1);
50955 if (obj1) {
50956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50957 if (!SWIG_IsOK(ecode2)) {
50958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50959 }
50960 arg2 = static_cast< bool >(val2);
50961 }
50962 {
50963 PyThreadState* __tstate = wxPyBeginAllowThreads();
50964 (arg1)->Clear(arg2);
50965 wxPyEndAllowThreads(__tstate);
50966 if (PyErr_Occurred()) SWIG_fail;
50967 }
50968 resultobj = SWIG_Py_Void();
50969 return resultobj;
50970 fail:
50971 return NULL;
50972 }
50973
50974
50975 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50976 PyObject *resultobj = 0;
50977 wxSizer *arg1 = (wxSizer *) 0 ;
50978 void *argp1 = 0 ;
50979 int res1 = 0 ;
50980 PyObject *swig_obj[1] ;
50981
50982 if (!args) SWIG_fail;
50983 swig_obj[0] = args;
50984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50985 if (!SWIG_IsOK(res1)) {
50986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50987 }
50988 arg1 = reinterpret_cast< wxSizer * >(argp1);
50989 {
50990 PyThreadState* __tstate = wxPyBeginAllowThreads();
50991 (arg1)->DeleteWindows();
50992 wxPyEndAllowThreads(__tstate);
50993 if (PyErr_Occurred()) SWIG_fail;
50994 }
50995 resultobj = SWIG_Py_Void();
50996 return resultobj;
50997 fail:
50998 return NULL;
50999 }
51000
51001
51002 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51003 PyObject *resultobj = 0;
51004 wxSizer *arg1 = (wxSizer *) 0 ;
51005 PyObject *result = 0 ;
51006 void *argp1 = 0 ;
51007 int res1 = 0 ;
51008 PyObject *swig_obj[1] ;
51009
51010 if (!args) SWIG_fail;
51011 swig_obj[0] = args;
51012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51013 if (!SWIG_IsOK(res1)) {
51014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51015 }
51016 arg1 = reinterpret_cast< wxSizer * >(argp1);
51017 {
51018 PyThreadState* __tstate = wxPyBeginAllowThreads();
51019 result = (PyObject *)wxSizer_GetChildren(arg1);
51020 wxPyEndAllowThreads(__tstate);
51021 if (PyErr_Occurred()) SWIG_fail;
51022 }
51023 resultobj = result;
51024 return resultobj;
51025 fail:
51026 return NULL;
51027 }
51028
51029
51030 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51031 PyObject *resultobj = 0;
51032 wxSizer *arg1 = (wxSizer *) 0 ;
51033 PyObject *arg2 = (PyObject *) 0 ;
51034 bool arg3 = (bool) true ;
51035 bool arg4 = (bool) false ;
51036 bool result;
51037 void *argp1 = 0 ;
51038 int res1 = 0 ;
51039 bool val3 ;
51040 int ecode3 = 0 ;
51041 bool val4 ;
51042 int ecode4 = 0 ;
51043 PyObject * obj0 = 0 ;
51044 PyObject * obj1 = 0 ;
51045 PyObject * obj2 = 0 ;
51046 PyObject * obj3 = 0 ;
51047 char * kwnames[] = {
51048 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51049 };
51050
51051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51053 if (!SWIG_IsOK(res1)) {
51054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51055 }
51056 arg1 = reinterpret_cast< wxSizer * >(argp1);
51057 arg2 = obj1;
51058 if (obj2) {
51059 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51060 if (!SWIG_IsOK(ecode3)) {
51061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51062 }
51063 arg3 = static_cast< bool >(val3);
51064 }
51065 if (obj3) {
51066 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51067 if (!SWIG_IsOK(ecode4)) {
51068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51069 }
51070 arg4 = static_cast< bool >(val4);
51071 }
51072 {
51073 PyThreadState* __tstate = wxPyBeginAllowThreads();
51074 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51075 wxPyEndAllowThreads(__tstate);
51076 if (PyErr_Occurred()) SWIG_fail;
51077 }
51078 {
51079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51080 }
51081 return resultobj;
51082 fail:
51083 return NULL;
51084 }
51085
51086
51087 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51088 PyObject *resultobj = 0;
51089 wxSizer *arg1 = (wxSizer *) 0 ;
51090 PyObject *arg2 = (PyObject *) 0 ;
51091 bool result;
51092 void *argp1 = 0 ;
51093 int res1 = 0 ;
51094 PyObject * obj0 = 0 ;
51095 PyObject * obj1 = 0 ;
51096 char * kwnames[] = {
51097 (char *) "self",(char *) "item", NULL
51098 };
51099
51100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51102 if (!SWIG_IsOK(res1)) {
51103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51104 }
51105 arg1 = reinterpret_cast< wxSizer * >(argp1);
51106 arg2 = obj1;
51107 {
51108 PyThreadState* __tstate = wxPyBeginAllowThreads();
51109 result = (bool)wxSizer_IsShown(arg1,arg2);
51110 wxPyEndAllowThreads(__tstate);
51111 if (PyErr_Occurred()) SWIG_fail;
51112 }
51113 {
51114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51115 }
51116 return resultobj;
51117 fail:
51118 return NULL;
51119 }
51120
51121
51122 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51123 PyObject *resultobj = 0;
51124 wxSizer *arg1 = (wxSizer *) 0 ;
51125 bool arg2 ;
51126 void *argp1 = 0 ;
51127 int res1 = 0 ;
51128 bool val2 ;
51129 int ecode2 = 0 ;
51130 PyObject * obj0 = 0 ;
51131 PyObject * obj1 = 0 ;
51132 char * kwnames[] = {
51133 (char *) "self",(char *) "show", NULL
51134 };
51135
51136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51138 if (!SWIG_IsOK(res1)) {
51139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51140 }
51141 arg1 = reinterpret_cast< wxSizer * >(argp1);
51142 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51143 if (!SWIG_IsOK(ecode2)) {
51144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51145 }
51146 arg2 = static_cast< bool >(val2);
51147 {
51148 PyThreadState* __tstate = wxPyBeginAllowThreads();
51149 (arg1)->ShowItems(arg2);
51150 wxPyEndAllowThreads(__tstate);
51151 if (PyErr_Occurred()) SWIG_fail;
51152 }
51153 resultobj = SWIG_Py_Void();
51154 return resultobj;
51155 fail:
51156 return NULL;
51157 }
51158
51159
51160 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51161 PyObject *obj;
51162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51163 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51164 return SWIG_Py_Void();
51165 }
51166
51167 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51168 PyObject *resultobj = 0;
51169 wxPySizer *result = 0 ;
51170
51171 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51172 {
51173 PyThreadState* __tstate = wxPyBeginAllowThreads();
51174 result = (wxPySizer *)new wxPySizer();
51175 wxPyEndAllowThreads(__tstate);
51176 if (PyErr_Occurred()) SWIG_fail;
51177 }
51178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51179 return resultobj;
51180 fail:
51181 return NULL;
51182 }
51183
51184
51185 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51186 PyObject *resultobj = 0;
51187 wxPySizer *arg1 = (wxPySizer *) 0 ;
51188 PyObject *arg2 = (PyObject *) 0 ;
51189 PyObject *arg3 = (PyObject *) 0 ;
51190 void *argp1 = 0 ;
51191 int res1 = 0 ;
51192 PyObject * obj0 = 0 ;
51193 PyObject * obj1 = 0 ;
51194 PyObject * obj2 = 0 ;
51195 char * kwnames[] = {
51196 (char *) "self",(char *) "self",(char *) "_class", NULL
51197 };
51198
51199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51201 if (!SWIG_IsOK(res1)) {
51202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51203 }
51204 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51205 arg2 = obj1;
51206 arg3 = obj2;
51207 {
51208 PyThreadState* __tstate = wxPyBeginAllowThreads();
51209 (arg1)->_setCallbackInfo(arg2,arg3);
51210 wxPyEndAllowThreads(__tstate);
51211 if (PyErr_Occurred()) SWIG_fail;
51212 }
51213 resultobj = SWIG_Py_Void();
51214 return resultobj;
51215 fail:
51216 return NULL;
51217 }
51218
51219
51220 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51221 PyObject *obj;
51222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51223 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51224 return SWIG_Py_Void();
51225 }
51226
51227 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51228 return SWIG_Python_InitShadowInstance(args);
51229 }
51230
51231 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51232 PyObject *resultobj = 0;
51233 int arg1 = (int) wxHORIZONTAL ;
51234 wxBoxSizer *result = 0 ;
51235 int val1 ;
51236 int ecode1 = 0 ;
51237 PyObject * obj0 = 0 ;
51238 char * kwnames[] = {
51239 (char *) "orient", NULL
51240 };
51241
51242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51243 if (obj0) {
51244 ecode1 = SWIG_AsVal_int(obj0, &val1);
51245 if (!SWIG_IsOK(ecode1)) {
51246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51247 }
51248 arg1 = static_cast< int >(val1);
51249 }
51250 {
51251 PyThreadState* __tstate = wxPyBeginAllowThreads();
51252 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51253 wxPyEndAllowThreads(__tstate);
51254 if (PyErr_Occurred()) SWIG_fail;
51255 }
51256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51257 return resultobj;
51258 fail:
51259 return NULL;
51260 }
51261
51262
51263 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51264 PyObject *resultobj = 0;
51265 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51266 int result;
51267 void *argp1 = 0 ;
51268 int res1 = 0 ;
51269 PyObject *swig_obj[1] ;
51270
51271 if (!args) SWIG_fail;
51272 swig_obj[0] = args;
51273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51276 }
51277 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51278 {
51279 PyThreadState* __tstate = wxPyBeginAllowThreads();
51280 result = (int)(arg1)->GetOrientation();
51281 wxPyEndAllowThreads(__tstate);
51282 if (PyErr_Occurred()) SWIG_fail;
51283 }
51284 resultobj = SWIG_From_int(static_cast< int >(result));
51285 return resultobj;
51286 fail:
51287 return NULL;
51288 }
51289
51290
51291 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51292 PyObject *resultobj = 0;
51293 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51294 int arg2 ;
51295 void *argp1 = 0 ;
51296 int res1 = 0 ;
51297 int val2 ;
51298 int ecode2 = 0 ;
51299 PyObject * obj0 = 0 ;
51300 PyObject * obj1 = 0 ;
51301 char * kwnames[] = {
51302 (char *) "self",(char *) "orient", NULL
51303 };
51304
51305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51307 if (!SWIG_IsOK(res1)) {
51308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51309 }
51310 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51311 ecode2 = SWIG_AsVal_int(obj1, &val2);
51312 if (!SWIG_IsOK(ecode2)) {
51313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51314 }
51315 arg2 = static_cast< int >(val2);
51316 {
51317 PyThreadState* __tstate = wxPyBeginAllowThreads();
51318 (arg1)->SetOrientation(arg2);
51319 wxPyEndAllowThreads(__tstate);
51320 if (PyErr_Occurred()) SWIG_fail;
51321 }
51322 resultobj = SWIG_Py_Void();
51323 return resultobj;
51324 fail:
51325 return NULL;
51326 }
51327
51328
51329 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51330 PyObject *obj;
51331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51332 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51333 return SWIG_Py_Void();
51334 }
51335
51336 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51337 return SWIG_Python_InitShadowInstance(args);
51338 }
51339
51340 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51341 PyObject *resultobj = 0;
51342 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51343 int arg2 = (int) wxHORIZONTAL ;
51344 wxStaticBoxSizer *result = 0 ;
51345 void *argp1 = 0 ;
51346 int res1 = 0 ;
51347 int val2 ;
51348 int ecode2 = 0 ;
51349 PyObject * obj0 = 0 ;
51350 PyObject * obj1 = 0 ;
51351 char * kwnames[] = {
51352 (char *) "box",(char *) "orient", NULL
51353 };
51354
51355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51357 if (!SWIG_IsOK(res1)) {
51358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51359 }
51360 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51361 if (obj1) {
51362 ecode2 = SWIG_AsVal_int(obj1, &val2);
51363 if (!SWIG_IsOK(ecode2)) {
51364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51365 }
51366 arg2 = static_cast< int >(val2);
51367 }
51368 {
51369 PyThreadState* __tstate = wxPyBeginAllowThreads();
51370 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51371 wxPyEndAllowThreads(__tstate);
51372 if (PyErr_Occurred()) SWIG_fail;
51373 }
51374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51375 return resultobj;
51376 fail:
51377 return NULL;
51378 }
51379
51380
51381 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51382 PyObject *resultobj = 0;
51383 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51384 wxStaticBox *result = 0 ;
51385 void *argp1 = 0 ;
51386 int res1 = 0 ;
51387 PyObject *swig_obj[1] ;
51388
51389 if (!args) SWIG_fail;
51390 swig_obj[0] = args;
51391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51392 if (!SWIG_IsOK(res1)) {
51393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51394 }
51395 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51396 {
51397 PyThreadState* __tstate = wxPyBeginAllowThreads();
51398 result = (wxStaticBox *)(arg1)->GetStaticBox();
51399 wxPyEndAllowThreads(__tstate);
51400 if (PyErr_Occurred()) SWIG_fail;
51401 }
51402 {
51403 resultobj = wxPyMake_wxObject(result, (bool)0);
51404 }
51405 return resultobj;
51406 fail:
51407 return NULL;
51408 }
51409
51410
51411 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51412 PyObject *obj;
51413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51414 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51415 return SWIG_Py_Void();
51416 }
51417
51418 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51419 return SWIG_Python_InitShadowInstance(args);
51420 }
51421
51422 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51423 PyObject *resultobj = 0;
51424 int arg1 = (int) 1 ;
51425 int arg2 = (int) 0 ;
51426 int arg3 = (int) 0 ;
51427 int arg4 = (int) 0 ;
51428 wxGridSizer *result = 0 ;
51429 int val1 ;
51430 int ecode1 = 0 ;
51431 int val2 ;
51432 int ecode2 = 0 ;
51433 int val3 ;
51434 int ecode3 = 0 ;
51435 int val4 ;
51436 int ecode4 = 0 ;
51437 PyObject * obj0 = 0 ;
51438 PyObject * obj1 = 0 ;
51439 PyObject * obj2 = 0 ;
51440 PyObject * obj3 = 0 ;
51441 char * kwnames[] = {
51442 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51443 };
51444
51445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51446 if (obj0) {
51447 ecode1 = SWIG_AsVal_int(obj0, &val1);
51448 if (!SWIG_IsOK(ecode1)) {
51449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51450 }
51451 arg1 = static_cast< int >(val1);
51452 }
51453 if (obj1) {
51454 ecode2 = SWIG_AsVal_int(obj1, &val2);
51455 if (!SWIG_IsOK(ecode2)) {
51456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51457 }
51458 arg2 = static_cast< int >(val2);
51459 }
51460 if (obj2) {
51461 ecode3 = SWIG_AsVal_int(obj2, &val3);
51462 if (!SWIG_IsOK(ecode3)) {
51463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51464 }
51465 arg3 = static_cast< int >(val3);
51466 }
51467 if (obj3) {
51468 ecode4 = SWIG_AsVal_int(obj3, &val4);
51469 if (!SWIG_IsOK(ecode4)) {
51470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51471 }
51472 arg4 = static_cast< int >(val4);
51473 }
51474 {
51475 PyThreadState* __tstate = wxPyBeginAllowThreads();
51476 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51477 wxPyEndAllowThreads(__tstate);
51478 if (PyErr_Occurred()) SWIG_fail;
51479 }
51480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51481 return resultobj;
51482 fail:
51483 return NULL;
51484 }
51485
51486
51487 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51488 PyObject *resultobj = 0;
51489 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51490 int arg2 ;
51491 void *argp1 = 0 ;
51492 int res1 = 0 ;
51493 int val2 ;
51494 int ecode2 = 0 ;
51495 PyObject * obj0 = 0 ;
51496 PyObject * obj1 = 0 ;
51497 char * kwnames[] = {
51498 (char *) "self",(char *) "cols", NULL
51499 };
51500
51501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51503 if (!SWIG_IsOK(res1)) {
51504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51505 }
51506 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51507 ecode2 = SWIG_AsVal_int(obj1, &val2);
51508 if (!SWIG_IsOK(ecode2)) {
51509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51510 }
51511 arg2 = static_cast< int >(val2);
51512 {
51513 PyThreadState* __tstate = wxPyBeginAllowThreads();
51514 (arg1)->SetCols(arg2);
51515 wxPyEndAllowThreads(__tstate);
51516 if (PyErr_Occurred()) SWIG_fail;
51517 }
51518 resultobj = SWIG_Py_Void();
51519 return resultobj;
51520 fail:
51521 return NULL;
51522 }
51523
51524
51525 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51526 PyObject *resultobj = 0;
51527 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51528 int arg2 ;
51529 void *argp1 = 0 ;
51530 int res1 = 0 ;
51531 int val2 ;
51532 int ecode2 = 0 ;
51533 PyObject * obj0 = 0 ;
51534 PyObject * obj1 = 0 ;
51535 char * kwnames[] = {
51536 (char *) "self",(char *) "rows", NULL
51537 };
51538
51539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51541 if (!SWIG_IsOK(res1)) {
51542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51543 }
51544 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51545 ecode2 = SWIG_AsVal_int(obj1, &val2);
51546 if (!SWIG_IsOK(ecode2)) {
51547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51548 }
51549 arg2 = static_cast< int >(val2);
51550 {
51551 PyThreadState* __tstate = wxPyBeginAllowThreads();
51552 (arg1)->SetRows(arg2);
51553 wxPyEndAllowThreads(__tstate);
51554 if (PyErr_Occurred()) SWIG_fail;
51555 }
51556 resultobj = SWIG_Py_Void();
51557 return resultobj;
51558 fail:
51559 return NULL;
51560 }
51561
51562
51563 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51564 PyObject *resultobj = 0;
51565 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51566 int arg2 ;
51567 void *argp1 = 0 ;
51568 int res1 = 0 ;
51569 int val2 ;
51570 int ecode2 = 0 ;
51571 PyObject * obj0 = 0 ;
51572 PyObject * obj1 = 0 ;
51573 char * kwnames[] = {
51574 (char *) "self",(char *) "gap", NULL
51575 };
51576
51577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51579 if (!SWIG_IsOK(res1)) {
51580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51581 }
51582 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51583 ecode2 = SWIG_AsVal_int(obj1, &val2);
51584 if (!SWIG_IsOK(ecode2)) {
51585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51586 }
51587 arg2 = static_cast< int >(val2);
51588 {
51589 PyThreadState* __tstate = wxPyBeginAllowThreads();
51590 (arg1)->SetVGap(arg2);
51591 wxPyEndAllowThreads(__tstate);
51592 if (PyErr_Occurred()) SWIG_fail;
51593 }
51594 resultobj = SWIG_Py_Void();
51595 return resultobj;
51596 fail:
51597 return NULL;
51598 }
51599
51600
51601 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51602 PyObject *resultobj = 0;
51603 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51604 int arg2 ;
51605 void *argp1 = 0 ;
51606 int res1 = 0 ;
51607 int val2 ;
51608 int ecode2 = 0 ;
51609 PyObject * obj0 = 0 ;
51610 PyObject * obj1 = 0 ;
51611 char * kwnames[] = {
51612 (char *) "self",(char *) "gap", NULL
51613 };
51614
51615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51617 if (!SWIG_IsOK(res1)) {
51618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51619 }
51620 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51621 ecode2 = SWIG_AsVal_int(obj1, &val2);
51622 if (!SWIG_IsOK(ecode2)) {
51623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51624 }
51625 arg2 = static_cast< int >(val2);
51626 {
51627 PyThreadState* __tstate = wxPyBeginAllowThreads();
51628 (arg1)->SetHGap(arg2);
51629 wxPyEndAllowThreads(__tstate);
51630 if (PyErr_Occurred()) SWIG_fail;
51631 }
51632 resultobj = SWIG_Py_Void();
51633 return resultobj;
51634 fail:
51635 return NULL;
51636 }
51637
51638
51639 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51640 PyObject *resultobj = 0;
51641 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51642 int result;
51643 void *argp1 = 0 ;
51644 int res1 = 0 ;
51645 PyObject *swig_obj[1] ;
51646
51647 if (!args) SWIG_fail;
51648 swig_obj[0] = args;
51649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51650 if (!SWIG_IsOK(res1)) {
51651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51652 }
51653 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51654 {
51655 PyThreadState* __tstate = wxPyBeginAllowThreads();
51656 result = (int)(arg1)->GetCols();
51657 wxPyEndAllowThreads(__tstate);
51658 if (PyErr_Occurred()) SWIG_fail;
51659 }
51660 resultobj = SWIG_From_int(static_cast< int >(result));
51661 return resultobj;
51662 fail:
51663 return NULL;
51664 }
51665
51666
51667 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51668 PyObject *resultobj = 0;
51669 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51670 int result;
51671 void *argp1 = 0 ;
51672 int res1 = 0 ;
51673 PyObject *swig_obj[1] ;
51674
51675 if (!args) SWIG_fail;
51676 swig_obj[0] = args;
51677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51678 if (!SWIG_IsOK(res1)) {
51679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51680 }
51681 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51682 {
51683 PyThreadState* __tstate = wxPyBeginAllowThreads();
51684 result = (int)(arg1)->GetRows();
51685 wxPyEndAllowThreads(__tstate);
51686 if (PyErr_Occurred()) SWIG_fail;
51687 }
51688 resultobj = SWIG_From_int(static_cast< int >(result));
51689 return resultobj;
51690 fail:
51691 return NULL;
51692 }
51693
51694
51695 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51696 PyObject *resultobj = 0;
51697 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51698 int result;
51699 void *argp1 = 0 ;
51700 int res1 = 0 ;
51701 PyObject *swig_obj[1] ;
51702
51703 if (!args) SWIG_fail;
51704 swig_obj[0] = args;
51705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51706 if (!SWIG_IsOK(res1)) {
51707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51708 }
51709 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51710 {
51711 PyThreadState* __tstate = wxPyBeginAllowThreads();
51712 result = (int)(arg1)->GetVGap();
51713 wxPyEndAllowThreads(__tstate);
51714 if (PyErr_Occurred()) SWIG_fail;
51715 }
51716 resultobj = SWIG_From_int(static_cast< int >(result));
51717 return resultobj;
51718 fail:
51719 return NULL;
51720 }
51721
51722
51723 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51724 PyObject *resultobj = 0;
51725 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51726 int result;
51727 void *argp1 = 0 ;
51728 int res1 = 0 ;
51729 PyObject *swig_obj[1] ;
51730
51731 if (!args) SWIG_fail;
51732 swig_obj[0] = args;
51733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51734 if (!SWIG_IsOK(res1)) {
51735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51736 }
51737 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51738 {
51739 PyThreadState* __tstate = wxPyBeginAllowThreads();
51740 result = (int)(arg1)->GetHGap();
51741 wxPyEndAllowThreads(__tstate);
51742 if (PyErr_Occurred()) SWIG_fail;
51743 }
51744 resultobj = SWIG_From_int(static_cast< int >(result));
51745 return resultobj;
51746 fail:
51747 return NULL;
51748 }
51749
51750
51751 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51752 PyObject *obj;
51753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51754 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51755 return SWIG_Py_Void();
51756 }
51757
51758 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51759 return SWIG_Python_InitShadowInstance(args);
51760 }
51761
51762 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51763 PyObject *resultobj = 0;
51764 int arg1 = (int) 1 ;
51765 int arg2 = (int) 0 ;
51766 int arg3 = (int) 0 ;
51767 int arg4 = (int) 0 ;
51768 wxFlexGridSizer *result = 0 ;
51769 int val1 ;
51770 int ecode1 = 0 ;
51771 int val2 ;
51772 int ecode2 = 0 ;
51773 int val3 ;
51774 int ecode3 = 0 ;
51775 int val4 ;
51776 int ecode4 = 0 ;
51777 PyObject * obj0 = 0 ;
51778 PyObject * obj1 = 0 ;
51779 PyObject * obj2 = 0 ;
51780 PyObject * obj3 = 0 ;
51781 char * kwnames[] = {
51782 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51783 };
51784
51785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51786 if (obj0) {
51787 ecode1 = SWIG_AsVal_int(obj0, &val1);
51788 if (!SWIG_IsOK(ecode1)) {
51789 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51790 }
51791 arg1 = static_cast< int >(val1);
51792 }
51793 if (obj1) {
51794 ecode2 = SWIG_AsVal_int(obj1, &val2);
51795 if (!SWIG_IsOK(ecode2)) {
51796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51797 }
51798 arg2 = static_cast< int >(val2);
51799 }
51800 if (obj2) {
51801 ecode3 = SWIG_AsVal_int(obj2, &val3);
51802 if (!SWIG_IsOK(ecode3)) {
51803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51804 }
51805 arg3 = static_cast< int >(val3);
51806 }
51807 if (obj3) {
51808 ecode4 = SWIG_AsVal_int(obj3, &val4);
51809 if (!SWIG_IsOK(ecode4)) {
51810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51811 }
51812 arg4 = static_cast< int >(val4);
51813 }
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51828 PyObject *resultobj = 0;
51829 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51830 size_t arg2 ;
51831 int arg3 = (int) 0 ;
51832 void *argp1 = 0 ;
51833 int res1 = 0 ;
51834 size_t val2 ;
51835 int ecode2 = 0 ;
51836 int val3 ;
51837 int ecode3 = 0 ;
51838 PyObject * obj0 = 0 ;
51839 PyObject * obj1 = 0 ;
51840 PyObject * obj2 = 0 ;
51841 char * kwnames[] = {
51842 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51843 };
51844
51845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51847 if (!SWIG_IsOK(res1)) {
51848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51849 }
51850 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51851 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51852 if (!SWIG_IsOK(ecode2)) {
51853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51854 }
51855 arg2 = static_cast< size_t >(val2);
51856 if (obj2) {
51857 ecode3 = SWIG_AsVal_int(obj2, &val3);
51858 if (!SWIG_IsOK(ecode3)) {
51859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51860 }
51861 arg3 = static_cast< int >(val3);
51862 }
51863 {
51864 PyThreadState* __tstate = wxPyBeginAllowThreads();
51865 (arg1)->AddGrowableRow(arg2,arg3);
51866 wxPyEndAllowThreads(__tstate);
51867 if (PyErr_Occurred()) SWIG_fail;
51868 }
51869 resultobj = SWIG_Py_Void();
51870 return resultobj;
51871 fail:
51872 return NULL;
51873 }
51874
51875
51876 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51877 PyObject *resultobj = 0;
51878 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51879 size_t arg2 ;
51880 void *argp1 = 0 ;
51881 int res1 = 0 ;
51882 size_t val2 ;
51883 int ecode2 = 0 ;
51884 PyObject * obj0 = 0 ;
51885 PyObject * obj1 = 0 ;
51886 char * kwnames[] = {
51887 (char *) "self",(char *) "idx", NULL
51888 };
51889
51890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51892 if (!SWIG_IsOK(res1)) {
51893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51894 }
51895 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51896 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51897 if (!SWIG_IsOK(ecode2)) {
51898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51899 }
51900 arg2 = static_cast< size_t >(val2);
51901 {
51902 PyThreadState* __tstate = wxPyBeginAllowThreads();
51903 (arg1)->RemoveGrowableRow(arg2);
51904 wxPyEndAllowThreads(__tstate);
51905 if (PyErr_Occurred()) SWIG_fail;
51906 }
51907 resultobj = SWIG_Py_Void();
51908 return resultobj;
51909 fail:
51910 return NULL;
51911 }
51912
51913
51914 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51915 PyObject *resultobj = 0;
51916 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51917 size_t arg2 ;
51918 int arg3 = (int) 0 ;
51919 void *argp1 = 0 ;
51920 int res1 = 0 ;
51921 size_t val2 ;
51922 int ecode2 = 0 ;
51923 int val3 ;
51924 int ecode3 = 0 ;
51925 PyObject * obj0 = 0 ;
51926 PyObject * obj1 = 0 ;
51927 PyObject * obj2 = 0 ;
51928 char * kwnames[] = {
51929 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51930 };
51931
51932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51934 if (!SWIG_IsOK(res1)) {
51935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51936 }
51937 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51938 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51939 if (!SWIG_IsOK(ecode2)) {
51940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51941 }
51942 arg2 = static_cast< size_t >(val2);
51943 if (obj2) {
51944 ecode3 = SWIG_AsVal_int(obj2, &val3);
51945 if (!SWIG_IsOK(ecode3)) {
51946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51947 }
51948 arg3 = static_cast< int >(val3);
51949 }
51950 {
51951 PyThreadState* __tstate = wxPyBeginAllowThreads();
51952 (arg1)->AddGrowableCol(arg2,arg3);
51953 wxPyEndAllowThreads(__tstate);
51954 if (PyErr_Occurred()) SWIG_fail;
51955 }
51956 resultobj = SWIG_Py_Void();
51957 return resultobj;
51958 fail:
51959 return NULL;
51960 }
51961
51962
51963 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51964 PyObject *resultobj = 0;
51965 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51966 size_t arg2 ;
51967 void *argp1 = 0 ;
51968 int res1 = 0 ;
51969 size_t val2 ;
51970 int ecode2 = 0 ;
51971 PyObject * obj0 = 0 ;
51972 PyObject * obj1 = 0 ;
51973 char * kwnames[] = {
51974 (char *) "self",(char *) "idx", NULL
51975 };
51976
51977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51979 if (!SWIG_IsOK(res1)) {
51980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51981 }
51982 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51983 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51984 if (!SWIG_IsOK(ecode2)) {
51985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51986 }
51987 arg2 = static_cast< size_t >(val2);
51988 {
51989 PyThreadState* __tstate = wxPyBeginAllowThreads();
51990 (arg1)->RemoveGrowableCol(arg2);
51991 wxPyEndAllowThreads(__tstate);
51992 if (PyErr_Occurred()) SWIG_fail;
51993 }
51994 resultobj = SWIG_Py_Void();
51995 return resultobj;
51996 fail:
51997 return NULL;
51998 }
51999
52000
52001 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52002 PyObject *resultobj = 0;
52003 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52004 int arg2 ;
52005 void *argp1 = 0 ;
52006 int res1 = 0 ;
52007 int val2 ;
52008 int ecode2 = 0 ;
52009 PyObject * obj0 = 0 ;
52010 PyObject * obj1 = 0 ;
52011 char * kwnames[] = {
52012 (char *) "self",(char *) "direction", NULL
52013 };
52014
52015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52017 if (!SWIG_IsOK(res1)) {
52018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52019 }
52020 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52021 ecode2 = SWIG_AsVal_int(obj1, &val2);
52022 if (!SWIG_IsOK(ecode2)) {
52023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52024 }
52025 arg2 = static_cast< int >(val2);
52026 {
52027 PyThreadState* __tstate = wxPyBeginAllowThreads();
52028 (arg1)->SetFlexibleDirection(arg2);
52029 wxPyEndAllowThreads(__tstate);
52030 if (PyErr_Occurred()) SWIG_fail;
52031 }
52032 resultobj = SWIG_Py_Void();
52033 return resultobj;
52034 fail:
52035 return NULL;
52036 }
52037
52038
52039 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52040 PyObject *resultobj = 0;
52041 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52042 int result;
52043 void *argp1 = 0 ;
52044 int res1 = 0 ;
52045 PyObject *swig_obj[1] ;
52046
52047 if (!args) SWIG_fail;
52048 swig_obj[0] = args;
52049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52050 if (!SWIG_IsOK(res1)) {
52051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52052 }
52053 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52054 {
52055 PyThreadState* __tstate = wxPyBeginAllowThreads();
52056 result = (int)(arg1)->GetFlexibleDirection();
52057 wxPyEndAllowThreads(__tstate);
52058 if (PyErr_Occurred()) SWIG_fail;
52059 }
52060 resultobj = SWIG_From_int(static_cast< int >(result));
52061 return resultobj;
52062 fail:
52063 return NULL;
52064 }
52065
52066
52067 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52068 PyObject *resultobj = 0;
52069 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52070 wxFlexSizerGrowMode arg2 ;
52071 void *argp1 = 0 ;
52072 int res1 = 0 ;
52073 int val2 ;
52074 int ecode2 = 0 ;
52075 PyObject * obj0 = 0 ;
52076 PyObject * obj1 = 0 ;
52077 char * kwnames[] = {
52078 (char *) "self",(char *) "mode", NULL
52079 };
52080
52081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52083 if (!SWIG_IsOK(res1)) {
52084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52085 }
52086 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52087 ecode2 = SWIG_AsVal_int(obj1, &val2);
52088 if (!SWIG_IsOK(ecode2)) {
52089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52090 }
52091 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52092 {
52093 PyThreadState* __tstate = wxPyBeginAllowThreads();
52094 (arg1)->SetNonFlexibleGrowMode(arg2);
52095 wxPyEndAllowThreads(__tstate);
52096 if (PyErr_Occurred()) SWIG_fail;
52097 }
52098 resultobj = SWIG_Py_Void();
52099 return resultobj;
52100 fail:
52101 return NULL;
52102 }
52103
52104
52105 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52106 PyObject *resultobj = 0;
52107 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52108 wxFlexSizerGrowMode result;
52109 void *argp1 = 0 ;
52110 int res1 = 0 ;
52111 PyObject *swig_obj[1] ;
52112
52113 if (!args) SWIG_fail;
52114 swig_obj[0] = args;
52115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52116 if (!SWIG_IsOK(res1)) {
52117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52118 }
52119 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52120 {
52121 PyThreadState* __tstate = wxPyBeginAllowThreads();
52122 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52123 wxPyEndAllowThreads(__tstate);
52124 if (PyErr_Occurred()) SWIG_fail;
52125 }
52126 resultobj = SWIG_From_int(static_cast< int >(result));
52127 return resultobj;
52128 fail:
52129 return NULL;
52130 }
52131
52132
52133 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52134 PyObject *resultobj = 0;
52135 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52136 wxArrayInt *result = 0 ;
52137 void *argp1 = 0 ;
52138 int res1 = 0 ;
52139 PyObject *swig_obj[1] ;
52140
52141 if (!args) SWIG_fail;
52142 swig_obj[0] = args;
52143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52144 if (!SWIG_IsOK(res1)) {
52145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52146 }
52147 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 {
52151 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52152 result = (wxArrayInt *) &_result_ref;
52153 }
52154 wxPyEndAllowThreads(__tstate);
52155 if (PyErr_Occurred()) SWIG_fail;
52156 }
52157 {
52158 resultobj = wxArrayInt2PyList_helper(*result);
52159 }
52160 return resultobj;
52161 fail:
52162 return NULL;
52163 }
52164
52165
52166 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52167 PyObject *resultobj = 0;
52168 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52169 wxArrayInt *result = 0 ;
52170 void *argp1 = 0 ;
52171 int res1 = 0 ;
52172 PyObject *swig_obj[1] ;
52173
52174 if (!args) SWIG_fail;
52175 swig_obj[0] = args;
52176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52179 }
52180 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52181 {
52182 PyThreadState* __tstate = wxPyBeginAllowThreads();
52183 {
52184 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52185 result = (wxArrayInt *) &_result_ref;
52186 }
52187 wxPyEndAllowThreads(__tstate);
52188 if (PyErr_Occurred()) SWIG_fail;
52189 }
52190 {
52191 resultobj = wxArrayInt2PyList_helper(*result);
52192 }
52193 return resultobj;
52194 fail:
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52200 PyObject *obj;
52201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52202 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52203 return SWIG_Py_Void();
52204 }
52205
52206 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52207 return SWIG_Python_InitShadowInstance(args);
52208 }
52209
52210 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52211 PyObject *resultobj = 0;
52212 wxStdDialogButtonSizer *result = 0 ;
52213
52214 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52222 return resultobj;
52223 fail:
52224 return NULL;
52225 }
52226
52227
52228 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52229 PyObject *resultobj = 0;
52230 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52231 wxButton *arg2 = (wxButton *) 0 ;
52232 void *argp1 = 0 ;
52233 int res1 = 0 ;
52234 void *argp2 = 0 ;
52235 int res2 = 0 ;
52236 PyObject * obj0 = 0 ;
52237 PyObject * obj1 = 0 ;
52238 char * kwnames[] = {
52239 (char *) "self",(char *) "button", NULL
52240 };
52241
52242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52244 if (!SWIG_IsOK(res1)) {
52245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52246 }
52247 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52249 if (!SWIG_IsOK(res2)) {
52250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52251 }
52252 arg2 = reinterpret_cast< wxButton * >(argp2);
52253 {
52254 PyThreadState* __tstate = wxPyBeginAllowThreads();
52255 (arg1)->AddButton(arg2);
52256 wxPyEndAllowThreads(__tstate);
52257 if (PyErr_Occurred()) SWIG_fail;
52258 }
52259 resultobj = SWIG_Py_Void();
52260 return resultobj;
52261 fail:
52262 return NULL;
52263 }
52264
52265
52266 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52267 PyObject *resultobj = 0;
52268 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52269 void *argp1 = 0 ;
52270 int res1 = 0 ;
52271 PyObject *swig_obj[1] ;
52272
52273 if (!args) SWIG_fail;
52274 swig_obj[0] = args;
52275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52276 if (!SWIG_IsOK(res1)) {
52277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52278 }
52279 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52280 {
52281 PyThreadState* __tstate = wxPyBeginAllowThreads();
52282 (arg1)->Realize();
52283 wxPyEndAllowThreads(__tstate);
52284 if (PyErr_Occurred()) SWIG_fail;
52285 }
52286 resultobj = SWIG_Py_Void();
52287 return resultobj;
52288 fail:
52289 return NULL;
52290 }
52291
52292
52293 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52294 PyObject *resultobj = 0;
52295 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52296 wxButton *arg2 = (wxButton *) 0 ;
52297 void *argp1 = 0 ;
52298 int res1 = 0 ;
52299 void *argp2 = 0 ;
52300 int res2 = 0 ;
52301 PyObject * obj0 = 0 ;
52302 PyObject * obj1 = 0 ;
52303 char * kwnames[] = {
52304 (char *) "self",(char *) "button", NULL
52305 };
52306
52307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52309 if (!SWIG_IsOK(res1)) {
52310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52311 }
52312 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52314 if (!SWIG_IsOK(res2)) {
52315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52316 }
52317 arg2 = reinterpret_cast< wxButton * >(argp2);
52318 {
52319 PyThreadState* __tstate = wxPyBeginAllowThreads();
52320 (arg1)->SetAffirmativeButton(arg2);
52321 wxPyEndAllowThreads(__tstate);
52322 if (PyErr_Occurred()) SWIG_fail;
52323 }
52324 resultobj = SWIG_Py_Void();
52325 return resultobj;
52326 fail:
52327 return NULL;
52328 }
52329
52330
52331 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52332 PyObject *resultobj = 0;
52333 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52334 wxButton *arg2 = (wxButton *) 0 ;
52335 void *argp1 = 0 ;
52336 int res1 = 0 ;
52337 void *argp2 = 0 ;
52338 int res2 = 0 ;
52339 PyObject * obj0 = 0 ;
52340 PyObject * obj1 = 0 ;
52341 char * kwnames[] = {
52342 (char *) "self",(char *) "button", NULL
52343 };
52344
52345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52347 if (!SWIG_IsOK(res1)) {
52348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52349 }
52350 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52352 if (!SWIG_IsOK(res2)) {
52353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52354 }
52355 arg2 = reinterpret_cast< wxButton * >(argp2);
52356 {
52357 PyThreadState* __tstate = wxPyBeginAllowThreads();
52358 (arg1)->SetNegativeButton(arg2);
52359 wxPyEndAllowThreads(__tstate);
52360 if (PyErr_Occurred()) SWIG_fail;
52361 }
52362 resultobj = SWIG_Py_Void();
52363 return resultobj;
52364 fail:
52365 return NULL;
52366 }
52367
52368
52369 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52370 PyObject *resultobj = 0;
52371 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52372 wxButton *arg2 = (wxButton *) 0 ;
52373 void *argp1 = 0 ;
52374 int res1 = 0 ;
52375 void *argp2 = 0 ;
52376 int res2 = 0 ;
52377 PyObject * obj0 = 0 ;
52378 PyObject * obj1 = 0 ;
52379 char * kwnames[] = {
52380 (char *) "self",(char *) "button", NULL
52381 };
52382
52383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52385 if (!SWIG_IsOK(res1)) {
52386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52387 }
52388 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52390 if (!SWIG_IsOK(res2)) {
52391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52392 }
52393 arg2 = reinterpret_cast< wxButton * >(argp2);
52394 {
52395 PyThreadState* __tstate = wxPyBeginAllowThreads();
52396 (arg1)->SetCancelButton(arg2);
52397 wxPyEndAllowThreads(__tstate);
52398 if (PyErr_Occurred()) SWIG_fail;
52399 }
52400 resultobj = SWIG_Py_Void();
52401 return resultobj;
52402 fail:
52403 return NULL;
52404 }
52405
52406
52407 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52408 PyObject *resultobj = 0;
52409 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52410 wxButton *result = 0 ;
52411 void *argp1 = 0 ;
52412 int res1 = 0 ;
52413 PyObject *swig_obj[1] ;
52414
52415 if (!args) SWIG_fail;
52416 swig_obj[0] = args;
52417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52418 if (!SWIG_IsOK(res1)) {
52419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52420 }
52421 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52422 {
52423 PyThreadState* __tstate = wxPyBeginAllowThreads();
52424 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52425 wxPyEndAllowThreads(__tstate);
52426 if (PyErr_Occurred()) SWIG_fail;
52427 }
52428 {
52429 resultobj = wxPyMake_wxObject(result, (bool)0);
52430 }
52431 return resultobj;
52432 fail:
52433 return NULL;
52434 }
52435
52436
52437 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52438 PyObject *resultobj = 0;
52439 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52440 wxButton *result = 0 ;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 PyObject *swig_obj[1] ;
52444
52445 if (!args) SWIG_fail;
52446 swig_obj[0] = args;
52447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52448 if (!SWIG_IsOK(res1)) {
52449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52450 }
52451 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52452 {
52453 PyThreadState* __tstate = wxPyBeginAllowThreads();
52454 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52455 wxPyEndAllowThreads(__tstate);
52456 if (PyErr_Occurred()) SWIG_fail;
52457 }
52458 {
52459 resultobj = wxPyMake_wxObject(result, (bool)0);
52460 }
52461 return resultobj;
52462 fail:
52463 return NULL;
52464 }
52465
52466
52467 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52468 PyObject *resultobj = 0;
52469 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52470 wxButton *result = 0 ;
52471 void *argp1 = 0 ;
52472 int res1 = 0 ;
52473 PyObject *swig_obj[1] ;
52474
52475 if (!args) SWIG_fail;
52476 swig_obj[0] = args;
52477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52478 if (!SWIG_IsOK(res1)) {
52479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52480 }
52481 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52482 {
52483 PyThreadState* __tstate = wxPyBeginAllowThreads();
52484 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52485 wxPyEndAllowThreads(__tstate);
52486 if (PyErr_Occurred()) SWIG_fail;
52487 }
52488 {
52489 resultobj = wxPyMake_wxObject(result, (bool)0);
52490 }
52491 return resultobj;
52492 fail:
52493 return NULL;
52494 }
52495
52496
52497 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52498 PyObject *resultobj = 0;
52499 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52500 wxButton *result = 0 ;
52501 void *argp1 = 0 ;
52502 int res1 = 0 ;
52503 PyObject *swig_obj[1] ;
52504
52505 if (!args) SWIG_fail;
52506 swig_obj[0] = args;
52507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52508 if (!SWIG_IsOK(res1)) {
52509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52510 }
52511 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52512 {
52513 PyThreadState* __tstate = wxPyBeginAllowThreads();
52514 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52515 wxPyEndAllowThreads(__tstate);
52516 if (PyErr_Occurred()) SWIG_fail;
52517 }
52518 {
52519 resultobj = wxPyMake_wxObject(result, (bool)0);
52520 }
52521 return resultobj;
52522 fail:
52523 return NULL;
52524 }
52525
52526
52527 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52528 PyObject *resultobj = 0;
52529 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52530 wxButton *result = 0 ;
52531 void *argp1 = 0 ;
52532 int res1 = 0 ;
52533 PyObject *swig_obj[1] ;
52534
52535 if (!args) SWIG_fail;
52536 swig_obj[0] = args;
52537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52538 if (!SWIG_IsOK(res1)) {
52539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52540 }
52541 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52542 {
52543 PyThreadState* __tstate = wxPyBeginAllowThreads();
52544 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52545 wxPyEndAllowThreads(__tstate);
52546 if (PyErr_Occurred()) SWIG_fail;
52547 }
52548 {
52549 resultobj = wxPyMake_wxObject(result, (bool)0);
52550 }
52551 return resultobj;
52552 fail:
52553 return NULL;
52554 }
52555
52556
52557 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52558 PyObject *obj;
52559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52560 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52561 return SWIG_Py_Void();
52562 }
52563
52564 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52565 return SWIG_Python_InitShadowInstance(args);
52566 }
52567
52568 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52569 PyObject *resultobj = 0;
52570 int arg1 = (int) 0 ;
52571 int arg2 = (int) 0 ;
52572 wxGBPosition *result = 0 ;
52573 int val1 ;
52574 int ecode1 = 0 ;
52575 int val2 ;
52576 int ecode2 = 0 ;
52577 PyObject * obj0 = 0 ;
52578 PyObject * obj1 = 0 ;
52579 char * kwnames[] = {
52580 (char *) "row",(char *) "col", NULL
52581 };
52582
52583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52584 if (obj0) {
52585 ecode1 = SWIG_AsVal_int(obj0, &val1);
52586 if (!SWIG_IsOK(ecode1)) {
52587 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52588 }
52589 arg1 = static_cast< int >(val1);
52590 }
52591 if (obj1) {
52592 ecode2 = SWIG_AsVal_int(obj1, &val2);
52593 if (!SWIG_IsOK(ecode2)) {
52594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52595 }
52596 arg2 = static_cast< int >(val2);
52597 }
52598 {
52599 PyThreadState* __tstate = wxPyBeginAllowThreads();
52600 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52601 wxPyEndAllowThreads(__tstate);
52602 if (PyErr_Occurred()) SWIG_fail;
52603 }
52604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52605 return resultobj;
52606 fail:
52607 return NULL;
52608 }
52609
52610
52611 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52612 PyObject *resultobj = 0;
52613 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52614 void *argp1 = 0 ;
52615 int res1 = 0 ;
52616 PyObject *swig_obj[1] ;
52617
52618 if (!args) SWIG_fail;
52619 swig_obj[0] = args;
52620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52621 if (!SWIG_IsOK(res1)) {
52622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52623 }
52624 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52625 {
52626 PyThreadState* __tstate = wxPyBeginAllowThreads();
52627 delete arg1;
52628
52629 wxPyEndAllowThreads(__tstate);
52630 if (PyErr_Occurred()) SWIG_fail;
52631 }
52632 resultobj = SWIG_Py_Void();
52633 return resultobj;
52634 fail:
52635 return NULL;
52636 }
52637
52638
52639 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52640 PyObject *resultobj = 0;
52641 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52642 int result;
52643 void *argp1 = 0 ;
52644 int res1 = 0 ;
52645 PyObject *swig_obj[1] ;
52646
52647 if (!args) SWIG_fail;
52648 swig_obj[0] = args;
52649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52650 if (!SWIG_IsOK(res1)) {
52651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52652 }
52653 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52654 {
52655 PyThreadState* __tstate = wxPyBeginAllowThreads();
52656 result = (int)((wxGBPosition const *)arg1)->GetRow();
52657 wxPyEndAllowThreads(__tstate);
52658 if (PyErr_Occurred()) SWIG_fail;
52659 }
52660 resultobj = SWIG_From_int(static_cast< int >(result));
52661 return resultobj;
52662 fail:
52663 return NULL;
52664 }
52665
52666
52667 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52668 PyObject *resultobj = 0;
52669 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52670 int result;
52671 void *argp1 = 0 ;
52672 int res1 = 0 ;
52673 PyObject *swig_obj[1] ;
52674
52675 if (!args) SWIG_fail;
52676 swig_obj[0] = args;
52677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52678 if (!SWIG_IsOK(res1)) {
52679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52680 }
52681 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52682 {
52683 PyThreadState* __tstate = wxPyBeginAllowThreads();
52684 result = (int)((wxGBPosition const *)arg1)->GetCol();
52685 wxPyEndAllowThreads(__tstate);
52686 if (PyErr_Occurred()) SWIG_fail;
52687 }
52688 resultobj = SWIG_From_int(static_cast< int >(result));
52689 return resultobj;
52690 fail:
52691 return NULL;
52692 }
52693
52694
52695 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52696 PyObject *resultobj = 0;
52697 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52698 int arg2 ;
52699 void *argp1 = 0 ;
52700 int res1 = 0 ;
52701 int val2 ;
52702 int ecode2 = 0 ;
52703 PyObject * obj0 = 0 ;
52704 PyObject * obj1 = 0 ;
52705 char * kwnames[] = {
52706 (char *) "self",(char *) "row", NULL
52707 };
52708
52709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52711 if (!SWIG_IsOK(res1)) {
52712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52713 }
52714 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52715 ecode2 = SWIG_AsVal_int(obj1, &val2);
52716 if (!SWIG_IsOK(ecode2)) {
52717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52718 }
52719 arg2 = static_cast< int >(val2);
52720 {
52721 PyThreadState* __tstate = wxPyBeginAllowThreads();
52722 (arg1)->SetRow(arg2);
52723 wxPyEndAllowThreads(__tstate);
52724 if (PyErr_Occurred()) SWIG_fail;
52725 }
52726 resultobj = SWIG_Py_Void();
52727 return resultobj;
52728 fail:
52729 return NULL;
52730 }
52731
52732
52733 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52734 PyObject *resultobj = 0;
52735 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52736 int arg2 ;
52737 void *argp1 = 0 ;
52738 int res1 = 0 ;
52739 int val2 ;
52740 int ecode2 = 0 ;
52741 PyObject * obj0 = 0 ;
52742 PyObject * obj1 = 0 ;
52743 char * kwnames[] = {
52744 (char *) "self",(char *) "col", NULL
52745 };
52746
52747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52749 if (!SWIG_IsOK(res1)) {
52750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52751 }
52752 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52753 ecode2 = SWIG_AsVal_int(obj1, &val2);
52754 if (!SWIG_IsOK(ecode2)) {
52755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52756 }
52757 arg2 = static_cast< int >(val2);
52758 {
52759 PyThreadState* __tstate = wxPyBeginAllowThreads();
52760 (arg1)->SetCol(arg2);
52761 wxPyEndAllowThreads(__tstate);
52762 if (PyErr_Occurred()) SWIG_fail;
52763 }
52764 resultobj = SWIG_Py_Void();
52765 return resultobj;
52766 fail:
52767 return NULL;
52768 }
52769
52770
52771 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52772 PyObject *resultobj = 0;
52773 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52774 PyObject *arg2 = (PyObject *) 0 ;
52775 bool result;
52776 void *argp1 = 0 ;
52777 int res1 = 0 ;
52778 PyObject * obj0 = 0 ;
52779 PyObject * obj1 = 0 ;
52780 char * kwnames[] = {
52781 (char *) "self",(char *) "other", NULL
52782 };
52783
52784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52786 if (!SWIG_IsOK(res1)) {
52787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52788 }
52789 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52790 arg2 = obj1;
52791 {
52792 result = (bool)wxGBPosition___eq__(arg1,arg2);
52793 if (PyErr_Occurred()) SWIG_fail;
52794 }
52795 {
52796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52797 }
52798 return resultobj;
52799 fail:
52800 return NULL;
52801 }
52802
52803
52804 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52805 PyObject *resultobj = 0;
52806 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52807 PyObject *arg2 = (PyObject *) 0 ;
52808 bool result;
52809 void *argp1 = 0 ;
52810 int res1 = 0 ;
52811 PyObject * obj0 = 0 ;
52812 PyObject * obj1 = 0 ;
52813 char * kwnames[] = {
52814 (char *) "self",(char *) "other", NULL
52815 };
52816
52817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52819 if (!SWIG_IsOK(res1)) {
52820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52821 }
52822 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52823 arg2 = obj1;
52824 {
52825 result = (bool)wxGBPosition___ne__(arg1,arg2);
52826 if (PyErr_Occurred()) SWIG_fail;
52827 }
52828 {
52829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52830 }
52831 return resultobj;
52832 fail:
52833 return NULL;
52834 }
52835
52836
52837 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52838 PyObject *resultobj = 0;
52839 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52840 int arg2 = (int) 0 ;
52841 int arg3 = (int) 0 ;
52842 void *argp1 = 0 ;
52843 int res1 = 0 ;
52844 int val2 ;
52845 int ecode2 = 0 ;
52846 int val3 ;
52847 int ecode3 = 0 ;
52848 PyObject * obj0 = 0 ;
52849 PyObject * obj1 = 0 ;
52850 PyObject * obj2 = 0 ;
52851 char * kwnames[] = {
52852 (char *) "self",(char *) "row",(char *) "col", NULL
52853 };
52854
52855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52857 if (!SWIG_IsOK(res1)) {
52858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52859 }
52860 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52861 if (obj1) {
52862 ecode2 = SWIG_AsVal_int(obj1, &val2);
52863 if (!SWIG_IsOK(ecode2)) {
52864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52865 }
52866 arg2 = static_cast< int >(val2);
52867 }
52868 if (obj2) {
52869 ecode3 = SWIG_AsVal_int(obj2, &val3);
52870 if (!SWIG_IsOK(ecode3)) {
52871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52872 }
52873 arg3 = static_cast< int >(val3);
52874 }
52875 {
52876 PyThreadState* __tstate = wxPyBeginAllowThreads();
52877 wxGBPosition_Set(arg1,arg2,arg3);
52878 wxPyEndAllowThreads(__tstate);
52879 if (PyErr_Occurred()) SWIG_fail;
52880 }
52881 resultobj = SWIG_Py_Void();
52882 return resultobj;
52883 fail:
52884 return NULL;
52885 }
52886
52887
52888 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52889 PyObject *resultobj = 0;
52890 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52891 PyObject *result = 0 ;
52892 void *argp1 = 0 ;
52893 int res1 = 0 ;
52894 PyObject *swig_obj[1] ;
52895
52896 if (!args) SWIG_fail;
52897 swig_obj[0] = args;
52898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52899 if (!SWIG_IsOK(res1)) {
52900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52901 }
52902 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52903 {
52904 PyThreadState* __tstate = wxPyBeginAllowThreads();
52905 result = (PyObject *)wxGBPosition_Get(arg1);
52906 wxPyEndAllowThreads(__tstate);
52907 if (PyErr_Occurred()) SWIG_fail;
52908 }
52909 resultobj = result;
52910 return resultobj;
52911 fail:
52912 return NULL;
52913 }
52914
52915
52916 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52917 PyObject *obj;
52918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52919 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52920 return SWIG_Py_Void();
52921 }
52922
52923 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52924 return SWIG_Python_InitShadowInstance(args);
52925 }
52926
52927 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52928 PyObject *resultobj = 0;
52929 int arg1 = (int) 1 ;
52930 int arg2 = (int) 1 ;
52931 wxGBSpan *result = 0 ;
52932 int val1 ;
52933 int ecode1 = 0 ;
52934 int val2 ;
52935 int ecode2 = 0 ;
52936 PyObject * obj0 = 0 ;
52937 PyObject * obj1 = 0 ;
52938 char * kwnames[] = {
52939 (char *) "rowspan",(char *) "colspan", NULL
52940 };
52941
52942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52943 if (obj0) {
52944 ecode1 = SWIG_AsVal_int(obj0, &val1);
52945 if (!SWIG_IsOK(ecode1)) {
52946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52947 }
52948 arg1 = static_cast< int >(val1);
52949 }
52950 if (obj1) {
52951 ecode2 = SWIG_AsVal_int(obj1, &val2);
52952 if (!SWIG_IsOK(ecode2)) {
52953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52954 }
52955 arg2 = static_cast< int >(val2);
52956 }
52957 {
52958 PyThreadState* __tstate = wxPyBeginAllowThreads();
52959 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52960 wxPyEndAllowThreads(__tstate);
52961 if (PyErr_Occurred()) SWIG_fail;
52962 }
52963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52964 return resultobj;
52965 fail:
52966 return NULL;
52967 }
52968
52969
52970 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52971 PyObject *resultobj = 0;
52972 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52973 void *argp1 = 0 ;
52974 int res1 = 0 ;
52975 PyObject *swig_obj[1] ;
52976
52977 if (!args) SWIG_fail;
52978 swig_obj[0] = args;
52979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52980 if (!SWIG_IsOK(res1)) {
52981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52982 }
52983 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52984 {
52985 PyThreadState* __tstate = wxPyBeginAllowThreads();
52986 delete arg1;
52987
52988 wxPyEndAllowThreads(__tstate);
52989 if (PyErr_Occurred()) SWIG_fail;
52990 }
52991 resultobj = SWIG_Py_Void();
52992 return resultobj;
52993 fail:
52994 return NULL;
52995 }
52996
52997
52998 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52999 PyObject *resultobj = 0;
53000 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53001 int result;
53002 void *argp1 = 0 ;
53003 int res1 = 0 ;
53004 PyObject *swig_obj[1] ;
53005
53006 if (!args) SWIG_fail;
53007 swig_obj[0] = args;
53008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53009 if (!SWIG_IsOK(res1)) {
53010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53011 }
53012 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53013 {
53014 PyThreadState* __tstate = wxPyBeginAllowThreads();
53015 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53016 wxPyEndAllowThreads(__tstate);
53017 if (PyErr_Occurred()) SWIG_fail;
53018 }
53019 resultobj = SWIG_From_int(static_cast< int >(result));
53020 return resultobj;
53021 fail:
53022 return NULL;
53023 }
53024
53025
53026 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53027 PyObject *resultobj = 0;
53028 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53029 int result;
53030 void *argp1 = 0 ;
53031 int res1 = 0 ;
53032 PyObject *swig_obj[1] ;
53033
53034 if (!args) SWIG_fail;
53035 swig_obj[0] = args;
53036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53037 if (!SWIG_IsOK(res1)) {
53038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53039 }
53040 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53041 {
53042 PyThreadState* __tstate = wxPyBeginAllowThreads();
53043 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53044 wxPyEndAllowThreads(__tstate);
53045 if (PyErr_Occurred()) SWIG_fail;
53046 }
53047 resultobj = SWIG_From_int(static_cast< int >(result));
53048 return resultobj;
53049 fail:
53050 return NULL;
53051 }
53052
53053
53054 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53055 PyObject *resultobj = 0;
53056 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53057 int arg2 ;
53058 void *argp1 = 0 ;
53059 int res1 = 0 ;
53060 int val2 ;
53061 int ecode2 = 0 ;
53062 PyObject * obj0 = 0 ;
53063 PyObject * obj1 = 0 ;
53064 char * kwnames[] = {
53065 (char *) "self",(char *) "rowspan", NULL
53066 };
53067
53068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53070 if (!SWIG_IsOK(res1)) {
53071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53072 }
53073 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53074 ecode2 = SWIG_AsVal_int(obj1, &val2);
53075 if (!SWIG_IsOK(ecode2)) {
53076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53077 }
53078 arg2 = static_cast< int >(val2);
53079 {
53080 PyThreadState* __tstate = wxPyBeginAllowThreads();
53081 (arg1)->SetRowspan(arg2);
53082 wxPyEndAllowThreads(__tstate);
53083 if (PyErr_Occurred()) SWIG_fail;
53084 }
53085 resultobj = SWIG_Py_Void();
53086 return resultobj;
53087 fail:
53088 return NULL;
53089 }
53090
53091
53092 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53093 PyObject *resultobj = 0;
53094 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53095 int arg2 ;
53096 void *argp1 = 0 ;
53097 int res1 = 0 ;
53098 int val2 ;
53099 int ecode2 = 0 ;
53100 PyObject * obj0 = 0 ;
53101 PyObject * obj1 = 0 ;
53102 char * kwnames[] = {
53103 (char *) "self",(char *) "colspan", NULL
53104 };
53105
53106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53108 if (!SWIG_IsOK(res1)) {
53109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53110 }
53111 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53112 ecode2 = SWIG_AsVal_int(obj1, &val2);
53113 if (!SWIG_IsOK(ecode2)) {
53114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53115 }
53116 arg2 = static_cast< int >(val2);
53117 {
53118 PyThreadState* __tstate = wxPyBeginAllowThreads();
53119 (arg1)->SetColspan(arg2);
53120 wxPyEndAllowThreads(__tstate);
53121 if (PyErr_Occurred()) SWIG_fail;
53122 }
53123 resultobj = SWIG_Py_Void();
53124 return resultobj;
53125 fail:
53126 return NULL;
53127 }
53128
53129
53130 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53131 PyObject *resultobj = 0;
53132 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53133 PyObject *arg2 = (PyObject *) 0 ;
53134 bool result;
53135 void *argp1 = 0 ;
53136 int res1 = 0 ;
53137 PyObject * obj0 = 0 ;
53138 PyObject * obj1 = 0 ;
53139 char * kwnames[] = {
53140 (char *) "self",(char *) "other", NULL
53141 };
53142
53143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53145 if (!SWIG_IsOK(res1)) {
53146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53147 }
53148 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53149 arg2 = obj1;
53150 {
53151 result = (bool)wxGBSpan___eq__(arg1,arg2);
53152 if (PyErr_Occurred()) SWIG_fail;
53153 }
53154 {
53155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53156 }
53157 return resultobj;
53158 fail:
53159 return NULL;
53160 }
53161
53162
53163 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53164 PyObject *resultobj = 0;
53165 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53166 PyObject *arg2 = (PyObject *) 0 ;
53167 bool result;
53168 void *argp1 = 0 ;
53169 int res1 = 0 ;
53170 PyObject * obj0 = 0 ;
53171 PyObject * obj1 = 0 ;
53172 char * kwnames[] = {
53173 (char *) "self",(char *) "other", NULL
53174 };
53175
53176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53178 if (!SWIG_IsOK(res1)) {
53179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53180 }
53181 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53182 arg2 = obj1;
53183 {
53184 result = (bool)wxGBSpan___ne__(arg1,arg2);
53185 if (PyErr_Occurred()) SWIG_fail;
53186 }
53187 {
53188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53189 }
53190 return resultobj;
53191 fail:
53192 return NULL;
53193 }
53194
53195
53196 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53197 PyObject *resultobj = 0;
53198 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53199 int arg2 = (int) 1 ;
53200 int arg3 = (int) 1 ;
53201 void *argp1 = 0 ;
53202 int res1 = 0 ;
53203 int val2 ;
53204 int ecode2 = 0 ;
53205 int val3 ;
53206 int ecode3 = 0 ;
53207 PyObject * obj0 = 0 ;
53208 PyObject * obj1 = 0 ;
53209 PyObject * obj2 = 0 ;
53210 char * kwnames[] = {
53211 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53212 };
53213
53214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53216 if (!SWIG_IsOK(res1)) {
53217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53218 }
53219 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53220 if (obj1) {
53221 ecode2 = SWIG_AsVal_int(obj1, &val2);
53222 if (!SWIG_IsOK(ecode2)) {
53223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53224 }
53225 arg2 = static_cast< int >(val2);
53226 }
53227 if (obj2) {
53228 ecode3 = SWIG_AsVal_int(obj2, &val3);
53229 if (!SWIG_IsOK(ecode3)) {
53230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53231 }
53232 arg3 = static_cast< int >(val3);
53233 }
53234 {
53235 PyThreadState* __tstate = wxPyBeginAllowThreads();
53236 wxGBSpan_Set(arg1,arg2,arg3);
53237 wxPyEndAllowThreads(__tstate);
53238 if (PyErr_Occurred()) SWIG_fail;
53239 }
53240 resultobj = SWIG_Py_Void();
53241 return resultobj;
53242 fail:
53243 return NULL;
53244 }
53245
53246
53247 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53248 PyObject *resultobj = 0;
53249 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53250 PyObject *result = 0 ;
53251 void *argp1 = 0 ;
53252 int res1 = 0 ;
53253 PyObject *swig_obj[1] ;
53254
53255 if (!args) SWIG_fail;
53256 swig_obj[0] = args;
53257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53258 if (!SWIG_IsOK(res1)) {
53259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53260 }
53261 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53262 {
53263 PyThreadState* __tstate = wxPyBeginAllowThreads();
53264 result = (PyObject *)wxGBSpan_Get(arg1);
53265 wxPyEndAllowThreads(__tstate);
53266 if (PyErr_Occurred()) SWIG_fail;
53267 }
53268 resultobj = result;
53269 return resultobj;
53270 fail:
53271 return NULL;
53272 }
53273
53274
53275 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53276 PyObject *obj;
53277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53278 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53279 return SWIG_Py_Void();
53280 }
53281
53282 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53283 return SWIG_Python_InitShadowInstance(args);
53284 }
53285
53286 SWIGINTERN int DefaultSpan_set(PyObject *) {
53287 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53288 return 1;
53289 }
53290
53291
53292 SWIGINTERN PyObject *DefaultSpan_get(void) {
53293 PyObject *pyobj = 0;
53294
53295 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53296 return pyobj;
53297 }
53298
53299
53300 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53301 PyObject *resultobj = 0;
53302 wxGBSizerItem *result = 0 ;
53303
53304 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53305 {
53306 PyThreadState* __tstate = wxPyBeginAllowThreads();
53307 result = (wxGBSizerItem *)new wxGBSizerItem();
53308 wxPyEndAllowThreads(__tstate);
53309 if (PyErr_Occurred()) SWIG_fail;
53310 }
53311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53312 return resultobj;
53313 fail:
53314 return NULL;
53315 }
53316
53317
53318 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53319 PyObject *resultobj = 0;
53320 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53321 void *argp1 = 0 ;
53322 int res1 = 0 ;
53323 PyObject *swig_obj[1] ;
53324
53325 if (!args) SWIG_fail;
53326 swig_obj[0] = args;
53327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53328 if (!SWIG_IsOK(res1)) {
53329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53330 }
53331 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53332 {
53333 PyThreadState* __tstate = wxPyBeginAllowThreads();
53334 delete arg1;
53335
53336 wxPyEndAllowThreads(__tstate);
53337 if (PyErr_Occurred()) SWIG_fail;
53338 }
53339 resultobj = SWIG_Py_Void();
53340 return resultobj;
53341 fail:
53342 return NULL;
53343 }
53344
53345
53346 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53347 PyObject *resultobj = 0;
53348 wxWindow *arg1 = (wxWindow *) 0 ;
53349 wxGBPosition *arg2 = 0 ;
53350 wxGBSpan *arg3 = 0 ;
53351 int arg4 ;
53352 int arg5 ;
53353 PyObject *arg6 = (PyObject *) NULL ;
53354 wxGBSizerItem *result = 0 ;
53355 void *argp1 = 0 ;
53356 int res1 = 0 ;
53357 wxGBPosition temp2 ;
53358 wxGBSpan temp3 ;
53359 int val4 ;
53360 int ecode4 = 0 ;
53361 int val5 ;
53362 int ecode5 = 0 ;
53363 PyObject * obj0 = 0 ;
53364 PyObject * obj1 = 0 ;
53365 PyObject * obj2 = 0 ;
53366 PyObject * obj3 = 0 ;
53367 PyObject * obj4 = 0 ;
53368 PyObject * obj5 = 0 ;
53369 char * kwnames[] = {
53370 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53371 };
53372
53373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53375 if (!SWIG_IsOK(res1)) {
53376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53377 }
53378 arg1 = reinterpret_cast< wxWindow * >(argp1);
53379 {
53380 arg2 = &temp2;
53381 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53382 }
53383 {
53384 arg3 = &temp3;
53385 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53386 }
53387 ecode4 = SWIG_AsVal_int(obj3, &val4);
53388 if (!SWIG_IsOK(ecode4)) {
53389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53390 }
53391 arg4 = static_cast< int >(val4);
53392 ecode5 = SWIG_AsVal_int(obj4, &val5);
53393 if (!SWIG_IsOK(ecode5)) {
53394 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53395 }
53396 arg5 = static_cast< int >(val5);
53397 if (obj5) {
53398 arg6 = obj5;
53399 }
53400 {
53401 PyThreadState* __tstate = wxPyBeginAllowThreads();
53402 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53403 wxPyEndAllowThreads(__tstate);
53404 if (PyErr_Occurred()) SWIG_fail;
53405 }
53406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53407 return resultobj;
53408 fail:
53409 return NULL;
53410 }
53411
53412
53413 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53414 PyObject *resultobj = 0;
53415 wxSizer *arg1 = (wxSizer *) 0 ;
53416 wxGBPosition *arg2 = 0 ;
53417 wxGBSpan *arg3 = 0 ;
53418 int arg4 ;
53419 int arg5 ;
53420 PyObject *arg6 = (PyObject *) NULL ;
53421 wxGBSizerItem *result = 0 ;
53422 int res1 = 0 ;
53423 wxGBPosition temp2 ;
53424 wxGBSpan temp3 ;
53425 int val4 ;
53426 int ecode4 = 0 ;
53427 int val5 ;
53428 int ecode5 = 0 ;
53429 PyObject * obj0 = 0 ;
53430 PyObject * obj1 = 0 ;
53431 PyObject * obj2 = 0 ;
53432 PyObject * obj3 = 0 ;
53433 PyObject * obj4 = 0 ;
53434 PyObject * obj5 = 0 ;
53435 char * kwnames[] = {
53436 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53437 };
53438
53439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53440 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53441 if (!SWIG_IsOK(res1)) {
53442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53443 }
53444 {
53445 arg2 = &temp2;
53446 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53447 }
53448 {
53449 arg3 = &temp3;
53450 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53451 }
53452 ecode4 = SWIG_AsVal_int(obj3, &val4);
53453 if (!SWIG_IsOK(ecode4)) {
53454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53455 }
53456 arg4 = static_cast< int >(val4);
53457 ecode5 = SWIG_AsVal_int(obj4, &val5);
53458 if (!SWIG_IsOK(ecode5)) {
53459 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53460 }
53461 arg5 = static_cast< int >(val5);
53462 if (obj5) {
53463 arg6 = obj5;
53464 }
53465 {
53466 PyThreadState* __tstate = wxPyBeginAllowThreads();
53467 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53468 wxPyEndAllowThreads(__tstate);
53469 if (PyErr_Occurred()) SWIG_fail;
53470 }
53471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53472 return resultobj;
53473 fail:
53474 return NULL;
53475 }
53476
53477
53478 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53479 PyObject *resultobj = 0;
53480 int arg1 ;
53481 int arg2 ;
53482 wxGBPosition *arg3 = 0 ;
53483 wxGBSpan *arg4 = 0 ;
53484 int arg5 ;
53485 int arg6 ;
53486 PyObject *arg7 = (PyObject *) NULL ;
53487 wxGBSizerItem *result = 0 ;
53488 int val1 ;
53489 int ecode1 = 0 ;
53490 int val2 ;
53491 int ecode2 = 0 ;
53492 wxGBPosition temp3 ;
53493 wxGBSpan temp4 ;
53494 int val5 ;
53495 int ecode5 = 0 ;
53496 int val6 ;
53497 int ecode6 = 0 ;
53498 PyObject * obj0 = 0 ;
53499 PyObject * obj1 = 0 ;
53500 PyObject * obj2 = 0 ;
53501 PyObject * obj3 = 0 ;
53502 PyObject * obj4 = 0 ;
53503 PyObject * obj5 = 0 ;
53504 PyObject * obj6 = 0 ;
53505 char * kwnames[] = {
53506 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53507 };
53508
53509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53510 ecode1 = SWIG_AsVal_int(obj0, &val1);
53511 if (!SWIG_IsOK(ecode1)) {
53512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53513 }
53514 arg1 = static_cast< int >(val1);
53515 ecode2 = SWIG_AsVal_int(obj1, &val2);
53516 if (!SWIG_IsOK(ecode2)) {
53517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53518 }
53519 arg2 = static_cast< int >(val2);
53520 {
53521 arg3 = &temp3;
53522 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53523 }
53524 {
53525 arg4 = &temp4;
53526 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53527 }
53528 ecode5 = SWIG_AsVal_int(obj4, &val5);
53529 if (!SWIG_IsOK(ecode5)) {
53530 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53531 }
53532 arg5 = static_cast< int >(val5);
53533 ecode6 = SWIG_AsVal_int(obj5, &val6);
53534 if (!SWIG_IsOK(ecode6)) {
53535 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53536 }
53537 arg6 = static_cast< int >(val6);
53538 if (obj6) {
53539 arg7 = obj6;
53540 }
53541 {
53542 PyThreadState* __tstate = wxPyBeginAllowThreads();
53543 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53544 wxPyEndAllowThreads(__tstate);
53545 if (PyErr_Occurred()) SWIG_fail;
53546 }
53547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53548 return resultobj;
53549 fail:
53550 return NULL;
53551 }
53552
53553
53554 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53555 PyObject *resultobj = 0;
53556 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53557 wxGBPosition result;
53558 void *argp1 = 0 ;
53559 int res1 = 0 ;
53560 PyObject *swig_obj[1] ;
53561
53562 if (!args) SWIG_fail;
53563 swig_obj[0] = args;
53564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53565 if (!SWIG_IsOK(res1)) {
53566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53567 }
53568 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53569 {
53570 PyThreadState* __tstate = wxPyBeginAllowThreads();
53571 result = ((wxGBSizerItem const *)arg1)->GetPos();
53572 wxPyEndAllowThreads(__tstate);
53573 if (PyErr_Occurred()) SWIG_fail;
53574 }
53575 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53576 return resultobj;
53577 fail:
53578 return NULL;
53579 }
53580
53581
53582 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53583 PyObject *resultobj = 0;
53584 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53585 wxGBSpan result;
53586 void *argp1 = 0 ;
53587 int res1 = 0 ;
53588 PyObject *swig_obj[1] ;
53589
53590 if (!args) SWIG_fail;
53591 swig_obj[0] = args;
53592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53593 if (!SWIG_IsOK(res1)) {
53594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53595 }
53596 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53597 {
53598 PyThreadState* __tstate = wxPyBeginAllowThreads();
53599 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53600 wxPyEndAllowThreads(__tstate);
53601 if (PyErr_Occurred()) SWIG_fail;
53602 }
53603 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53604 return resultobj;
53605 fail:
53606 return NULL;
53607 }
53608
53609
53610 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53611 PyObject *resultobj = 0;
53612 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53613 wxGBPosition *arg2 = 0 ;
53614 bool result;
53615 void *argp1 = 0 ;
53616 int res1 = 0 ;
53617 wxGBPosition temp2 ;
53618 PyObject * obj0 = 0 ;
53619 PyObject * obj1 = 0 ;
53620 char * kwnames[] = {
53621 (char *) "self",(char *) "pos", NULL
53622 };
53623
53624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53626 if (!SWIG_IsOK(res1)) {
53627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53628 }
53629 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53630 {
53631 arg2 = &temp2;
53632 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53633 }
53634 {
53635 PyThreadState* __tstate = wxPyBeginAllowThreads();
53636 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53637 wxPyEndAllowThreads(__tstate);
53638 if (PyErr_Occurred()) SWIG_fail;
53639 }
53640 {
53641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53642 }
53643 return resultobj;
53644 fail:
53645 return NULL;
53646 }
53647
53648
53649 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53650 PyObject *resultobj = 0;
53651 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53652 wxGBSpan *arg2 = 0 ;
53653 bool result;
53654 void *argp1 = 0 ;
53655 int res1 = 0 ;
53656 wxGBSpan temp2 ;
53657 PyObject * obj0 = 0 ;
53658 PyObject * obj1 = 0 ;
53659 char * kwnames[] = {
53660 (char *) "self",(char *) "span", NULL
53661 };
53662
53663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53665 if (!SWIG_IsOK(res1)) {
53666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53667 }
53668 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53669 {
53670 arg2 = &temp2;
53671 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53672 }
53673 {
53674 PyThreadState* __tstate = wxPyBeginAllowThreads();
53675 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53676 wxPyEndAllowThreads(__tstate);
53677 if (PyErr_Occurred()) SWIG_fail;
53678 }
53679 {
53680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53681 }
53682 return resultobj;
53683 fail:
53684 return NULL;
53685 }
53686
53687
53688 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53689 PyObject *resultobj = 0;
53690 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53691 wxGBSizerItem *arg2 = 0 ;
53692 bool result;
53693 void *argp1 = 0 ;
53694 int res1 = 0 ;
53695 void *argp2 = 0 ;
53696 int res2 = 0 ;
53697 PyObject * obj0 = 0 ;
53698 PyObject * obj1 = 0 ;
53699 char * kwnames[] = {
53700 (char *) "self",(char *) "other", NULL
53701 };
53702
53703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53705 if (!SWIG_IsOK(res1)) {
53706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53707 }
53708 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53710 if (!SWIG_IsOK(res2)) {
53711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53712 }
53713 if (!argp2) {
53714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53715 }
53716 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53717 {
53718 PyThreadState* __tstate = wxPyBeginAllowThreads();
53719 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53720 wxPyEndAllowThreads(__tstate);
53721 if (PyErr_Occurred()) SWIG_fail;
53722 }
53723 {
53724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53725 }
53726 return resultobj;
53727 fail:
53728 return NULL;
53729 }
53730
53731
53732 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53733 PyObject *resultobj = 0;
53734 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53735 wxGBPosition *arg2 = 0 ;
53736 wxGBSpan *arg3 = 0 ;
53737 bool result;
53738 void *argp1 = 0 ;
53739 int res1 = 0 ;
53740 wxGBPosition temp2 ;
53741 wxGBSpan temp3 ;
53742 PyObject * obj0 = 0 ;
53743 PyObject * obj1 = 0 ;
53744 PyObject * obj2 = 0 ;
53745 char * kwnames[] = {
53746 (char *) "self",(char *) "pos",(char *) "span", NULL
53747 };
53748
53749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53751 if (!SWIG_IsOK(res1)) {
53752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53753 }
53754 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53755 {
53756 arg2 = &temp2;
53757 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53758 }
53759 {
53760 arg3 = &temp3;
53761 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53762 }
53763 {
53764 PyThreadState* __tstate = wxPyBeginAllowThreads();
53765 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53766 wxPyEndAllowThreads(__tstate);
53767 if (PyErr_Occurred()) SWIG_fail;
53768 }
53769 {
53770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53771 }
53772 return resultobj;
53773 fail:
53774 return NULL;
53775 }
53776
53777
53778 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53779 PyObject *resultobj = 0;
53780 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53781 wxGBPosition result;
53782 void *argp1 = 0 ;
53783 int res1 = 0 ;
53784 PyObject *swig_obj[1] ;
53785
53786 if (!args) SWIG_fail;
53787 swig_obj[0] = args;
53788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53789 if (!SWIG_IsOK(res1)) {
53790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53791 }
53792 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53793 {
53794 PyThreadState* __tstate = wxPyBeginAllowThreads();
53795 result = wxGBSizerItem_GetEndPos(arg1);
53796 wxPyEndAllowThreads(__tstate);
53797 if (PyErr_Occurred()) SWIG_fail;
53798 }
53799 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53800 return resultobj;
53801 fail:
53802 return NULL;
53803 }
53804
53805
53806 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53807 PyObject *resultobj = 0;
53808 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53809 wxGridBagSizer *result = 0 ;
53810 void *argp1 = 0 ;
53811 int res1 = 0 ;
53812 PyObject *swig_obj[1] ;
53813
53814 if (!args) SWIG_fail;
53815 swig_obj[0] = args;
53816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53817 if (!SWIG_IsOK(res1)) {
53818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53819 }
53820 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53821 {
53822 PyThreadState* __tstate = wxPyBeginAllowThreads();
53823 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53824 wxPyEndAllowThreads(__tstate);
53825 if (PyErr_Occurred()) SWIG_fail;
53826 }
53827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53828 return resultobj;
53829 fail:
53830 return NULL;
53831 }
53832
53833
53834 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53835 PyObject *resultobj = 0;
53836 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53837 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53838 void *argp1 = 0 ;
53839 int res1 = 0 ;
53840 void *argp2 = 0 ;
53841 int res2 = 0 ;
53842 PyObject * obj0 = 0 ;
53843 PyObject * obj1 = 0 ;
53844 char * kwnames[] = {
53845 (char *) "self",(char *) "sizer", NULL
53846 };
53847
53848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53850 if (!SWIG_IsOK(res1)) {
53851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53852 }
53853 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53855 if (!SWIG_IsOK(res2)) {
53856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53857 }
53858 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53859 {
53860 PyThreadState* __tstate = wxPyBeginAllowThreads();
53861 (arg1)->SetGBSizer(arg2);
53862 wxPyEndAllowThreads(__tstate);
53863 if (PyErr_Occurred()) SWIG_fail;
53864 }
53865 resultobj = SWIG_Py_Void();
53866 return resultobj;
53867 fail:
53868 return NULL;
53869 }
53870
53871
53872 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53873 PyObject *obj;
53874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53875 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53876 return SWIG_Py_Void();
53877 }
53878
53879 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53880 return SWIG_Python_InitShadowInstance(args);
53881 }
53882
53883 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53884 PyObject *resultobj = 0;
53885 int arg1 = (int) 0 ;
53886 int arg2 = (int) 0 ;
53887 wxGridBagSizer *result = 0 ;
53888 int val1 ;
53889 int ecode1 = 0 ;
53890 int val2 ;
53891 int ecode2 = 0 ;
53892 PyObject * obj0 = 0 ;
53893 PyObject * obj1 = 0 ;
53894 char * kwnames[] = {
53895 (char *) "vgap",(char *) "hgap", NULL
53896 };
53897
53898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53899 if (obj0) {
53900 ecode1 = SWIG_AsVal_int(obj0, &val1);
53901 if (!SWIG_IsOK(ecode1)) {
53902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53903 }
53904 arg1 = static_cast< int >(val1);
53905 }
53906 if (obj1) {
53907 ecode2 = SWIG_AsVal_int(obj1, &val2);
53908 if (!SWIG_IsOK(ecode2)) {
53909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53910 }
53911 arg2 = static_cast< int >(val2);
53912 }
53913 {
53914 PyThreadState* __tstate = wxPyBeginAllowThreads();
53915 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53916 wxPyEndAllowThreads(__tstate);
53917 if (PyErr_Occurred()) SWIG_fail;
53918 }
53919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53920 return resultobj;
53921 fail:
53922 return NULL;
53923 }
53924
53925
53926 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53927 PyObject *resultobj = 0;
53928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53929 PyObject *arg2 = (PyObject *) 0 ;
53930 wxGBPosition *arg3 = 0 ;
53931 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53932 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53933 int arg5 = (int) 0 ;
53934 int arg6 = (int) 0 ;
53935 PyObject *arg7 = (PyObject *) NULL ;
53936 wxGBSizerItem *result = 0 ;
53937 void *argp1 = 0 ;
53938 int res1 = 0 ;
53939 wxGBPosition temp3 ;
53940 wxGBSpan temp4 ;
53941 int val5 ;
53942 int ecode5 = 0 ;
53943 int val6 ;
53944 int ecode6 = 0 ;
53945 PyObject * obj0 = 0 ;
53946 PyObject * obj1 = 0 ;
53947 PyObject * obj2 = 0 ;
53948 PyObject * obj3 = 0 ;
53949 PyObject * obj4 = 0 ;
53950 PyObject * obj5 = 0 ;
53951 PyObject * obj6 = 0 ;
53952 char * kwnames[] = {
53953 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53954 };
53955
53956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53958 if (!SWIG_IsOK(res1)) {
53959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53960 }
53961 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53962 arg2 = obj1;
53963 {
53964 arg3 = &temp3;
53965 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53966 }
53967 if (obj3) {
53968 {
53969 arg4 = &temp4;
53970 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53971 }
53972 }
53973 if (obj4) {
53974 ecode5 = SWIG_AsVal_int(obj4, &val5);
53975 if (!SWIG_IsOK(ecode5)) {
53976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53977 }
53978 arg5 = static_cast< int >(val5);
53979 }
53980 if (obj5) {
53981 ecode6 = SWIG_AsVal_int(obj5, &val6);
53982 if (!SWIG_IsOK(ecode6)) {
53983 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53984 }
53985 arg6 = static_cast< int >(val6);
53986 }
53987 if (obj6) {
53988 arg7 = obj6;
53989 }
53990 {
53991 PyThreadState* __tstate = wxPyBeginAllowThreads();
53992 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53993 wxPyEndAllowThreads(__tstate);
53994 if (PyErr_Occurred()) SWIG_fail;
53995 }
53996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53997 return resultobj;
53998 fail:
53999 return NULL;
54000 }
54001
54002
54003 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54004 PyObject *resultobj = 0;
54005 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54006 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54007 wxGBSizerItem *result = 0 ;
54008 void *argp1 = 0 ;
54009 int res1 = 0 ;
54010 int res2 = 0 ;
54011 PyObject * obj0 = 0 ;
54012 PyObject * obj1 = 0 ;
54013 char * kwnames[] = {
54014 (char *) "self",(char *) "item", NULL
54015 };
54016
54017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54019 if (!SWIG_IsOK(res1)) {
54020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54021 }
54022 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54023 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54024 if (!SWIG_IsOK(res2)) {
54025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54026 }
54027 {
54028 PyThreadState* __tstate = wxPyBeginAllowThreads();
54029 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54030 wxPyEndAllowThreads(__tstate);
54031 if (PyErr_Occurred()) SWIG_fail;
54032 }
54033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54034 return resultobj;
54035 fail:
54036 return NULL;
54037 }
54038
54039
54040 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54041 PyObject *resultobj = 0;
54042 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54043 int arg2 ;
54044 int arg3 ;
54045 wxSize result;
54046 void *argp1 = 0 ;
54047 int res1 = 0 ;
54048 int val2 ;
54049 int ecode2 = 0 ;
54050 int val3 ;
54051 int ecode3 = 0 ;
54052 PyObject * obj0 = 0 ;
54053 PyObject * obj1 = 0 ;
54054 PyObject * obj2 = 0 ;
54055 char * kwnames[] = {
54056 (char *) "self",(char *) "row",(char *) "col", NULL
54057 };
54058
54059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54061 if (!SWIG_IsOK(res1)) {
54062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54063 }
54064 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54065 ecode2 = SWIG_AsVal_int(obj1, &val2);
54066 if (!SWIG_IsOK(ecode2)) {
54067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54068 }
54069 arg2 = static_cast< int >(val2);
54070 ecode3 = SWIG_AsVal_int(obj2, &val3);
54071 if (!SWIG_IsOK(ecode3)) {
54072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54073 }
54074 arg3 = static_cast< int >(val3);
54075 {
54076 PyThreadState* __tstate = wxPyBeginAllowThreads();
54077 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54078 wxPyEndAllowThreads(__tstate);
54079 if (PyErr_Occurred()) SWIG_fail;
54080 }
54081 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54082 return resultobj;
54083 fail:
54084 return NULL;
54085 }
54086
54087
54088 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54089 PyObject *resultobj = 0;
54090 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54091 wxSize result;
54092 void *argp1 = 0 ;
54093 int res1 = 0 ;
54094 PyObject *swig_obj[1] ;
54095
54096 if (!args) SWIG_fail;
54097 swig_obj[0] = args;
54098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54099 if (!SWIG_IsOK(res1)) {
54100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54101 }
54102 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54103 {
54104 PyThreadState* __tstate = wxPyBeginAllowThreads();
54105 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54106 wxPyEndAllowThreads(__tstate);
54107 if (PyErr_Occurred()) SWIG_fail;
54108 }
54109 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54110 return resultobj;
54111 fail:
54112 return NULL;
54113 }
54114
54115
54116 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54117 PyObject *resultobj = 0;
54118 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54119 wxSize *arg2 = 0 ;
54120 void *argp1 = 0 ;
54121 int res1 = 0 ;
54122 wxSize temp2 ;
54123 PyObject * obj0 = 0 ;
54124 PyObject * obj1 = 0 ;
54125 char * kwnames[] = {
54126 (char *) "self",(char *) "sz", NULL
54127 };
54128
54129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54131 if (!SWIG_IsOK(res1)) {
54132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54133 }
54134 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54135 {
54136 arg2 = &temp2;
54137 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54138 }
54139 {
54140 PyThreadState* __tstate = wxPyBeginAllowThreads();
54141 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54142 wxPyEndAllowThreads(__tstate);
54143 if (PyErr_Occurred()) SWIG_fail;
54144 }
54145 resultobj = SWIG_Py_Void();
54146 return resultobj;
54147 fail:
54148 return NULL;
54149 }
54150
54151
54152 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54153 PyObject *resultobj = 0;
54154 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54155 wxWindow *arg2 = (wxWindow *) 0 ;
54156 wxGBPosition result;
54157 void *argp1 = 0 ;
54158 int res1 = 0 ;
54159 void *argp2 = 0 ;
54160 int res2 = 0 ;
54161
54162 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54164 if (!SWIG_IsOK(res1)) {
54165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54166 }
54167 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54168 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54169 if (!SWIG_IsOK(res2)) {
54170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54171 }
54172 arg2 = reinterpret_cast< wxWindow * >(argp2);
54173 {
54174 PyThreadState* __tstate = wxPyBeginAllowThreads();
54175 result = (arg1)->GetItemPosition(arg2);
54176 wxPyEndAllowThreads(__tstate);
54177 if (PyErr_Occurred()) SWIG_fail;
54178 }
54179 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54180 return resultobj;
54181 fail:
54182 return NULL;
54183 }
54184
54185
54186 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54187 PyObject *resultobj = 0;
54188 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54189 wxSizer *arg2 = (wxSizer *) 0 ;
54190 wxGBPosition result;
54191 void *argp1 = 0 ;
54192 int res1 = 0 ;
54193 void *argp2 = 0 ;
54194 int res2 = 0 ;
54195
54196 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54198 if (!SWIG_IsOK(res1)) {
54199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54200 }
54201 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54202 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54203 if (!SWIG_IsOK(res2)) {
54204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54205 }
54206 arg2 = reinterpret_cast< wxSizer * >(argp2);
54207 {
54208 PyThreadState* __tstate = wxPyBeginAllowThreads();
54209 result = (arg1)->GetItemPosition(arg2);
54210 wxPyEndAllowThreads(__tstate);
54211 if (PyErr_Occurred()) SWIG_fail;
54212 }
54213 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54214 return resultobj;
54215 fail:
54216 return NULL;
54217 }
54218
54219
54220 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54221 PyObject *resultobj = 0;
54222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54223 size_t arg2 ;
54224 wxGBPosition result;
54225 void *argp1 = 0 ;
54226 int res1 = 0 ;
54227 size_t val2 ;
54228 int ecode2 = 0 ;
54229
54230 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54232 if (!SWIG_IsOK(res1)) {
54233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54234 }
54235 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54236 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54237 if (!SWIG_IsOK(ecode2)) {
54238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54239 }
54240 arg2 = static_cast< size_t >(val2);
54241 {
54242 PyThreadState* __tstate = wxPyBeginAllowThreads();
54243 result = (arg1)->GetItemPosition(arg2);
54244 wxPyEndAllowThreads(__tstate);
54245 if (PyErr_Occurred()) SWIG_fail;
54246 }
54247 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54248 return resultobj;
54249 fail:
54250 return NULL;
54251 }
54252
54253
54254 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54255 int argc;
54256 PyObject *argv[3];
54257
54258 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54259 --argc;
54260 if (argc == 2) {
54261 int _v = 0;
54262 {
54263 void *vptr = 0;
54264 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54265 _v = SWIG_CheckState(res);
54266 }
54267 if (!_v) goto check_1;
54268 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54269 }
54270 check_1:
54271
54272 if (argc == 2) {
54273 int _v = 0;
54274 {
54275 void *vptr = 0;
54276 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54277 _v = SWIG_CheckState(res);
54278 }
54279 if (!_v) goto check_2;
54280 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54281 }
54282 check_2:
54283
54284 if (argc == 2) {
54285 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54286 }
54287
54288 fail:
54289 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54290 return NULL;
54291 }
54292
54293
54294 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54295 PyObject *resultobj = 0;
54296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54297 wxWindow *arg2 = (wxWindow *) 0 ;
54298 wxGBPosition *arg3 = 0 ;
54299 bool result;
54300 void *argp1 = 0 ;
54301 int res1 = 0 ;
54302 void *argp2 = 0 ;
54303 int res2 = 0 ;
54304 wxGBPosition temp3 ;
54305
54306 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54308 if (!SWIG_IsOK(res1)) {
54309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54310 }
54311 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54312 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54313 if (!SWIG_IsOK(res2)) {
54314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54315 }
54316 arg2 = reinterpret_cast< wxWindow * >(argp2);
54317 {
54318 arg3 = &temp3;
54319 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54320 }
54321 {
54322 PyThreadState* __tstate = wxPyBeginAllowThreads();
54323 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54324 wxPyEndAllowThreads(__tstate);
54325 if (PyErr_Occurred()) SWIG_fail;
54326 }
54327 {
54328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54329 }
54330 return resultobj;
54331 fail:
54332 return NULL;
54333 }
54334
54335
54336 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54337 PyObject *resultobj = 0;
54338 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54339 wxSizer *arg2 = (wxSizer *) 0 ;
54340 wxGBPosition *arg3 = 0 ;
54341 bool result;
54342 void *argp1 = 0 ;
54343 int res1 = 0 ;
54344 void *argp2 = 0 ;
54345 int res2 = 0 ;
54346 wxGBPosition temp3 ;
54347
54348 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54350 if (!SWIG_IsOK(res1)) {
54351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54352 }
54353 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54354 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54355 if (!SWIG_IsOK(res2)) {
54356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54357 }
54358 arg2 = reinterpret_cast< wxSizer * >(argp2);
54359 {
54360 arg3 = &temp3;
54361 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54362 }
54363 {
54364 PyThreadState* __tstate = wxPyBeginAllowThreads();
54365 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54366 wxPyEndAllowThreads(__tstate);
54367 if (PyErr_Occurred()) SWIG_fail;
54368 }
54369 {
54370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54371 }
54372 return resultobj;
54373 fail:
54374 return NULL;
54375 }
54376
54377
54378 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54379 PyObject *resultobj = 0;
54380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54381 size_t arg2 ;
54382 wxGBPosition *arg3 = 0 ;
54383 bool result;
54384 void *argp1 = 0 ;
54385 int res1 = 0 ;
54386 size_t val2 ;
54387 int ecode2 = 0 ;
54388 wxGBPosition temp3 ;
54389
54390 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54392 if (!SWIG_IsOK(res1)) {
54393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54394 }
54395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54396 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54397 if (!SWIG_IsOK(ecode2)) {
54398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54399 }
54400 arg2 = static_cast< size_t >(val2);
54401 {
54402 arg3 = &temp3;
54403 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54404 }
54405 {
54406 PyThreadState* __tstate = wxPyBeginAllowThreads();
54407 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54408 wxPyEndAllowThreads(__tstate);
54409 if (PyErr_Occurred()) SWIG_fail;
54410 }
54411 {
54412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54413 }
54414 return resultobj;
54415 fail:
54416 return NULL;
54417 }
54418
54419
54420 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54421 int argc;
54422 PyObject *argv[4];
54423
54424 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54425 --argc;
54426 if (argc == 3) {
54427 int _v = 0;
54428 {
54429 void *vptr = 0;
54430 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54431 _v = SWIG_CheckState(res);
54432 }
54433 if (!_v) goto check_1;
54434 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54435 }
54436 check_1:
54437
54438 if (argc == 3) {
54439 int _v = 0;
54440 {
54441 void *vptr = 0;
54442 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54443 _v = SWIG_CheckState(res);
54444 }
54445 if (!_v) goto check_2;
54446 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54447 }
54448 check_2:
54449
54450 if (argc == 3) {
54451 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54452 }
54453
54454 fail:
54455 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54456 return NULL;
54457 }
54458
54459
54460 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54461 PyObject *resultobj = 0;
54462 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54463 wxWindow *arg2 = (wxWindow *) 0 ;
54464 wxGBSpan result;
54465 void *argp1 = 0 ;
54466 int res1 = 0 ;
54467 void *argp2 = 0 ;
54468 int res2 = 0 ;
54469
54470 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54472 if (!SWIG_IsOK(res1)) {
54473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54474 }
54475 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54476 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54477 if (!SWIG_IsOK(res2)) {
54478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54479 }
54480 arg2 = reinterpret_cast< wxWindow * >(argp2);
54481 {
54482 PyThreadState* __tstate = wxPyBeginAllowThreads();
54483 result = (arg1)->GetItemSpan(arg2);
54484 wxPyEndAllowThreads(__tstate);
54485 if (PyErr_Occurred()) SWIG_fail;
54486 }
54487 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54488 return resultobj;
54489 fail:
54490 return NULL;
54491 }
54492
54493
54494 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54495 PyObject *resultobj = 0;
54496 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54497 wxSizer *arg2 = (wxSizer *) 0 ;
54498 wxGBSpan result;
54499 void *argp1 = 0 ;
54500 int res1 = 0 ;
54501 void *argp2 = 0 ;
54502 int res2 = 0 ;
54503
54504 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54506 if (!SWIG_IsOK(res1)) {
54507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54508 }
54509 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54510 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54511 if (!SWIG_IsOK(res2)) {
54512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54513 }
54514 arg2 = reinterpret_cast< wxSizer * >(argp2);
54515 {
54516 PyThreadState* __tstate = wxPyBeginAllowThreads();
54517 result = (arg1)->GetItemSpan(arg2);
54518 wxPyEndAllowThreads(__tstate);
54519 if (PyErr_Occurred()) SWIG_fail;
54520 }
54521 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54522 return resultobj;
54523 fail:
54524 return NULL;
54525 }
54526
54527
54528 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54529 PyObject *resultobj = 0;
54530 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54531 size_t arg2 ;
54532 wxGBSpan result;
54533 void *argp1 = 0 ;
54534 int res1 = 0 ;
54535 size_t val2 ;
54536 int ecode2 = 0 ;
54537
54538 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54540 if (!SWIG_IsOK(res1)) {
54541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54542 }
54543 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54544 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54545 if (!SWIG_IsOK(ecode2)) {
54546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54547 }
54548 arg2 = static_cast< size_t >(val2);
54549 {
54550 PyThreadState* __tstate = wxPyBeginAllowThreads();
54551 result = (arg1)->GetItemSpan(arg2);
54552 wxPyEndAllowThreads(__tstate);
54553 if (PyErr_Occurred()) SWIG_fail;
54554 }
54555 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54556 return resultobj;
54557 fail:
54558 return NULL;
54559 }
54560
54561
54562 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54563 int argc;
54564 PyObject *argv[3];
54565
54566 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54567 --argc;
54568 if (argc == 2) {
54569 int _v = 0;
54570 {
54571 void *vptr = 0;
54572 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54573 _v = SWIG_CheckState(res);
54574 }
54575 if (!_v) goto check_1;
54576 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54577 }
54578 check_1:
54579
54580 if (argc == 2) {
54581 int _v = 0;
54582 {
54583 void *vptr = 0;
54584 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54585 _v = SWIG_CheckState(res);
54586 }
54587 if (!_v) goto check_2;
54588 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54589 }
54590 check_2:
54591
54592 if (argc == 2) {
54593 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54594 }
54595
54596 fail:
54597 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54598 return NULL;
54599 }
54600
54601
54602 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54603 PyObject *resultobj = 0;
54604 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54605 wxWindow *arg2 = (wxWindow *) 0 ;
54606 wxGBSpan *arg3 = 0 ;
54607 bool result;
54608 void *argp1 = 0 ;
54609 int res1 = 0 ;
54610 void *argp2 = 0 ;
54611 int res2 = 0 ;
54612 wxGBSpan temp3 ;
54613
54614 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54616 if (!SWIG_IsOK(res1)) {
54617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54618 }
54619 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54620 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54621 if (!SWIG_IsOK(res2)) {
54622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54623 }
54624 arg2 = reinterpret_cast< wxWindow * >(argp2);
54625 {
54626 arg3 = &temp3;
54627 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54628 }
54629 {
54630 PyThreadState* __tstate = wxPyBeginAllowThreads();
54631 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54632 wxPyEndAllowThreads(__tstate);
54633 if (PyErr_Occurred()) SWIG_fail;
54634 }
54635 {
54636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54637 }
54638 return resultobj;
54639 fail:
54640 return NULL;
54641 }
54642
54643
54644 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54645 PyObject *resultobj = 0;
54646 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54647 wxSizer *arg2 = (wxSizer *) 0 ;
54648 wxGBSpan *arg3 = 0 ;
54649 bool result;
54650 void *argp1 = 0 ;
54651 int res1 = 0 ;
54652 void *argp2 = 0 ;
54653 int res2 = 0 ;
54654 wxGBSpan temp3 ;
54655
54656 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54658 if (!SWIG_IsOK(res1)) {
54659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54660 }
54661 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54662 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54663 if (!SWIG_IsOK(res2)) {
54664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54665 }
54666 arg2 = reinterpret_cast< wxSizer * >(argp2);
54667 {
54668 arg3 = &temp3;
54669 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54670 }
54671 {
54672 PyThreadState* __tstate = wxPyBeginAllowThreads();
54673 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54674 wxPyEndAllowThreads(__tstate);
54675 if (PyErr_Occurred()) SWIG_fail;
54676 }
54677 {
54678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54679 }
54680 return resultobj;
54681 fail:
54682 return NULL;
54683 }
54684
54685
54686 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54687 PyObject *resultobj = 0;
54688 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54689 size_t arg2 ;
54690 wxGBSpan *arg3 = 0 ;
54691 bool result;
54692 void *argp1 = 0 ;
54693 int res1 = 0 ;
54694 size_t val2 ;
54695 int ecode2 = 0 ;
54696 wxGBSpan temp3 ;
54697
54698 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54700 if (!SWIG_IsOK(res1)) {
54701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54702 }
54703 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54704 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54705 if (!SWIG_IsOK(ecode2)) {
54706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54707 }
54708 arg2 = static_cast< size_t >(val2);
54709 {
54710 arg3 = &temp3;
54711 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54712 }
54713 {
54714 PyThreadState* __tstate = wxPyBeginAllowThreads();
54715 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54716 wxPyEndAllowThreads(__tstate);
54717 if (PyErr_Occurred()) SWIG_fail;
54718 }
54719 {
54720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54721 }
54722 return resultobj;
54723 fail:
54724 return NULL;
54725 }
54726
54727
54728 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54729 int argc;
54730 PyObject *argv[4];
54731
54732 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54733 --argc;
54734 if (argc == 3) {
54735 int _v = 0;
54736 {
54737 void *vptr = 0;
54738 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54739 _v = SWIG_CheckState(res);
54740 }
54741 if (!_v) goto check_1;
54742 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54743 }
54744 check_1:
54745
54746 if (argc == 3) {
54747 int _v = 0;
54748 {
54749 void *vptr = 0;
54750 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54751 _v = SWIG_CheckState(res);
54752 }
54753 if (!_v) goto check_2;
54754 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54755 }
54756 check_2:
54757
54758 if (argc == 3) {
54759 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54760 }
54761
54762 fail:
54763 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54764 return NULL;
54765 }
54766
54767
54768 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54769 PyObject *resultobj = 0;
54770 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54771 wxWindow *arg2 = (wxWindow *) 0 ;
54772 wxGBSizerItem *result = 0 ;
54773 void *argp1 = 0 ;
54774 int res1 = 0 ;
54775 void *argp2 = 0 ;
54776 int res2 = 0 ;
54777
54778 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54780 if (!SWIG_IsOK(res1)) {
54781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54782 }
54783 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54784 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54785 if (!SWIG_IsOK(res2)) {
54786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54787 }
54788 arg2 = reinterpret_cast< wxWindow * >(argp2);
54789 {
54790 PyThreadState* __tstate = wxPyBeginAllowThreads();
54791 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54792 wxPyEndAllowThreads(__tstate);
54793 if (PyErr_Occurred()) SWIG_fail;
54794 }
54795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54796 return resultobj;
54797 fail:
54798 return NULL;
54799 }
54800
54801
54802 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54803 PyObject *resultobj = 0;
54804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54805 wxSizer *arg2 = (wxSizer *) 0 ;
54806 wxGBSizerItem *result = 0 ;
54807 void *argp1 = 0 ;
54808 int res1 = 0 ;
54809 void *argp2 = 0 ;
54810 int res2 = 0 ;
54811
54812 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54814 if (!SWIG_IsOK(res1)) {
54815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54816 }
54817 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54818 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54819 if (!SWIG_IsOK(res2)) {
54820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54821 }
54822 arg2 = reinterpret_cast< wxSizer * >(argp2);
54823 {
54824 PyThreadState* __tstate = wxPyBeginAllowThreads();
54825 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54826 wxPyEndAllowThreads(__tstate);
54827 if (PyErr_Occurred()) SWIG_fail;
54828 }
54829 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54830 return resultobj;
54831 fail:
54832 return NULL;
54833 }
54834
54835
54836 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54837 int argc;
54838 PyObject *argv[3];
54839
54840 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54841 --argc;
54842 if (argc == 2) {
54843 int _v = 0;
54844 {
54845 void *vptr = 0;
54846 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54847 _v = SWIG_CheckState(res);
54848 }
54849 if (!_v) goto check_1;
54850 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54851 }
54852 check_1:
54853
54854 if (argc == 2) {
54855 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54856 }
54857
54858 fail:
54859 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54860 return NULL;
54861 }
54862
54863
54864 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54865 PyObject *resultobj = 0;
54866 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54867 wxGBPosition *arg2 = 0 ;
54868 wxGBSizerItem *result = 0 ;
54869 void *argp1 = 0 ;
54870 int res1 = 0 ;
54871 wxGBPosition temp2 ;
54872 PyObject * obj0 = 0 ;
54873 PyObject * obj1 = 0 ;
54874 char * kwnames[] = {
54875 (char *) "self",(char *) "pos", NULL
54876 };
54877
54878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54880 if (!SWIG_IsOK(res1)) {
54881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54882 }
54883 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54884 {
54885 arg2 = &temp2;
54886 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54887 }
54888 {
54889 PyThreadState* __tstate = wxPyBeginAllowThreads();
54890 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54891 wxPyEndAllowThreads(__tstate);
54892 if (PyErr_Occurred()) SWIG_fail;
54893 }
54894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54895 return resultobj;
54896 fail:
54897 return NULL;
54898 }
54899
54900
54901 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54902 PyObject *resultobj = 0;
54903 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54904 wxPoint *arg2 = 0 ;
54905 wxGBSizerItem *result = 0 ;
54906 void *argp1 = 0 ;
54907 int res1 = 0 ;
54908 wxPoint temp2 ;
54909 PyObject * obj0 = 0 ;
54910 PyObject * obj1 = 0 ;
54911 char * kwnames[] = {
54912 (char *) "self",(char *) "pt", NULL
54913 };
54914
54915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54917 if (!SWIG_IsOK(res1)) {
54918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54919 }
54920 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54921 {
54922 arg2 = &temp2;
54923 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54924 }
54925 {
54926 PyThreadState* __tstate = wxPyBeginAllowThreads();
54927 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54928 wxPyEndAllowThreads(__tstate);
54929 if (PyErr_Occurred()) SWIG_fail;
54930 }
54931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54932 return resultobj;
54933 fail:
54934 return NULL;
54935 }
54936
54937
54938 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54939 PyObject *resultobj = 0;
54940 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54941 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54942 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54943 bool result;
54944 void *argp1 = 0 ;
54945 int res1 = 0 ;
54946 void *argp2 = 0 ;
54947 int res2 = 0 ;
54948 void *argp3 = 0 ;
54949 int res3 = 0 ;
54950 PyObject * obj0 = 0 ;
54951 PyObject * obj1 = 0 ;
54952 PyObject * obj2 = 0 ;
54953 char * kwnames[] = {
54954 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54955 };
54956
54957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54959 if (!SWIG_IsOK(res1)) {
54960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54961 }
54962 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54964 if (!SWIG_IsOK(res2)) {
54965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54966 }
54967 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54968 if (obj2) {
54969 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54970 if (!SWIG_IsOK(res3)) {
54971 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54972 }
54973 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54974 }
54975 {
54976 PyThreadState* __tstate = wxPyBeginAllowThreads();
54977 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54978 wxPyEndAllowThreads(__tstate);
54979 if (PyErr_Occurred()) SWIG_fail;
54980 }
54981 {
54982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54983 }
54984 return resultobj;
54985 fail:
54986 return NULL;
54987 }
54988
54989
54990 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54991 PyObject *resultobj = 0;
54992 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54993 wxGBPosition *arg2 = 0 ;
54994 wxGBSpan *arg3 = 0 ;
54995 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54996 bool result;
54997 void *argp1 = 0 ;
54998 int res1 = 0 ;
54999 wxGBPosition temp2 ;
55000 wxGBSpan temp3 ;
55001 void *argp4 = 0 ;
55002 int res4 = 0 ;
55003 PyObject * obj0 = 0 ;
55004 PyObject * obj1 = 0 ;
55005 PyObject * obj2 = 0 ;
55006 PyObject * obj3 = 0 ;
55007 char * kwnames[] = {
55008 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55009 };
55010
55011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55013 if (!SWIG_IsOK(res1)) {
55014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55015 }
55016 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55017 {
55018 arg2 = &temp2;
55019 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55020 }
55021 {
55022 arg3 = &temp3;
55023 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55024 }
55025 if (obj3) {
55026 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55027 if (!SWIG_IsOK(res4)) {
55028 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55029 }
55030 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55031 }
55032 {
55033 PyThreadState* __tstate = wxPyBeginAllowThreads();
55034 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55035 wxPyEndAllowThreads(__tstate);
55036 if (PyErr_Occurred()) SWIG_fail;
55037 }
55038 {
55039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55040 }
55041 return resultobj;
55042 fail:
55043 return NULL;
55044 }
55045
55046
55047 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55048 PyObject *obj;
55049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55050 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55051 return SWIG_Py_Void();
55052 }
55053
55054 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55055 return SWIG_Python_InitShadowInstance(args);
55056 }
55057
55058 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55059 PyObject *resultobj = 0;
55060 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55061 wxRelationship arg2 ;
55062 wxWindow *arg3 = (wxWindow *) 0 ;
55063 wxEdge arg4 ;
55064 int arg5 = (int) 0 ;
55065 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55066 void *argp1 = 0 ;
55067 int res1 = 0 ;
55068 int val2 ;
55069 int ecode2 = 0 ;
55070 void *argp3 = 0 ;
55071 int res3 = 0 ;
55072 int val4 ;
55073 int ecode4 = 0 ;
55074 int val5 ;
55075 int ecode5 = 0 ;
55076 int val6 ;
55077 int ecode6 = 0 ;
55078 PyObject * obj0 = 0 ;
55079 PyObject * obj1 = 0 ;
55080 PyObject * obj2 = 0 ;
55081 PyObject * obj3 = 0 ;
55082 PyObject * obj4 = 0 ;
55083 PyObject * obj5 = 0 ;
55084 char * kwnames[] = {
55085 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55086 };
55087
55088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55090 if (!SWIG_IsOK(res1)) {
55091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55092 }
55093 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55094 ecode2 = SWIG_AsVal_int(obj1, &val2);
55095 if (!SWIG_IsOK(ecode2)) {
55096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55097 }
55098 arg2 = static_cast< wxRelationship >(val2);
55099 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55100 if (!SWIG_IsOK(res3)) {
55101 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55102 }
55103 arg3 = reinterpret_cast< wxWindow * >(argp3);
55104 ecode4 = SWIG_AsVal_int(obj3, &val4);
55105 if (!SWIG_IsOK(ecode4)) {
55106 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55107 }
55108 arg4 = static_cast< wxEdge >(val4);
55109 if (obj4) {
55110 ecode5 = SWIG_AsVal_int(obj4, &val5);
55111 if (!SWIG_IsOK(ecode5)) {
55112 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55113 }
55114 arg5 = static_cast< int >(val5);
55115 }
55116 if (obj5) {
55117 ecode6 = SWIG_AsVal_int(obj5, &val6);
55118 if (!SWIG_IsOK(ecode6)) {
55119 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55120 }
55121 arg6 = static_cast< int >(val6);
55122 }
55123 {
55124 PyThreadState* __tstate = wxPyBeginAllowThreads();
55125 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55126 wxPyEndAllowThreads(__tstate);
55127 if (PyErr_Occurred()) SWIG_fail;
55128 }
55129 resultobj = SWIG_Py_Void();
55130 return resultobj;
55131 fail:
55132 return NULL;
55133 }
55134
55135
55136 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55137 PyObject *resultobj = 0;
55138 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55139 wxWindow *arg2 = (wxWindow *) 0 ;
55140 int arg3 = (int) 0 ;
55141 void *argp1 = 0 ;
55142 int res1 = 0 ;
55143 void *argp2 = 0 ;
55144 int res2 = 0 ;
55145 int val3 ;
55146 int ecode3 = 0 ;
55147 PyObject * obj0 = 0 ;
55148 PyObject * obj1 = 0 ;
55149 PyObject * obj2 = 0 ;
55150 char * kwnames[] = {
55151 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55152 };
55153
55154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55156 if (!SWIG_IsOK(res1)) {
55157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55158 }
55159 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55161 if (!SWIG_IsOK(res2)) {
55162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55163 }
55164 arg2 = reinterpret_cast< wxWindow * >(argp2);
55165 if (obj2) {
55166 ecode3 = SWIG_AsVal_int(obj2, &val3);
55167 if (!SWIG_IsOK(ecode3)) {
55168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55169 }
55170 arg3 = static_cast< int >(val3);
55171 }
55172 {
55173 PyThreadState* __tstate = wxPyBeginAllowThreads();
55174 (arg1)->LeftOf(arg2,arg3);
55175 wxPyEndAllowThreads(__tstate);
55176 if (PyErr_Occurred()) SWIG_fail;
55177 }
55178 resultobj = SWIG_Py_Void();
55179 return resultobj;
55180 fail:
55181 return NULL;
55182 }
55183
55184
55185 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55186 PyObject *resultobj = 0;
55187 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55188 wxWindow *arg2 = (wxWindow *) 0 ;
55189 int arg3 = (int) 0 ;
55190 void *argp1 = 0 ;
55191 int res1 = 0 ;
55192 void *argp2 = 0 ;
55193 int res2 = 0 ;
55194 int val3 ;
55195 int ecode3 = 0 ;
55196 PyObject * obj0 = 0 ;
55197 PyObject * obj1 = 0 ;
55198 PyObject * obj2 = 0 ;
55199 char * kwnames[] = {
55200 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55201 };
55202
55203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55205 if (!SWIG_IsOK(res1)) {
55206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55207 }
55208 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55210 if (!SWIG_IsOK(res2)) {
55211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55212 }
55213 arg2 = reinterpret_cast< wxWindow * >(argp2);
55214 if (obj2) {
55215 ecode3 = SWIG_AsVal_int(obj2, &val3);
55216 if (!SWIG_IsOK(ecode3)) {
55217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55218 }
55219 arg3 = static_cast< int >(val3);
55220 }
55221 {
55222 PyThreadState* __tstate = wxPyBeginAllowThreads();
55223 (arg1)->RightOf(arg2,arg3);
55224 wxPyEndAllowThreads(__tstate);
55225 if (PyErr_Occurred()) SWIG_fail;
55226 }
55227 resultobj = SWIG_Py_Void();
55228 return resultobj;
55229 fail:
55230 return NULL;
55231 }
55232
55233
55234 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55235 PyObject *resultobj = 0;
55236 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55237 wxWindow *arg2 = (wxWindow *) 0 ;
55238 int arg3 = (int) 0 ;
55239 void *argp1 = 0 ;
55240 int res1 = 0 ;
55241 void *argp2 = 0 ;
55242 int res2 = 0 ;
55243 int val3 ;
55244 int ecode3 = 0 ;
55245 PyObject * obj0 = 0 ;
55246 PyObject * obj1 = 0 ;
55247 PyObject * obj2 = 0 ;
55248 char * kwnames[] = {
55249 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55250 };
55251
55252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55254 if (!SWIG_IsOK(res1)) {
55255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55256 }
55257 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55259 if (!SWIG_IsOK(res2)) {
55260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55261 }
55262 arg2 = reinterpret_cast< wxWindow * >(argp2);
55263 if (obj2) {
55264 ecode3 = SWIG_AsVal_int(obj2, &val3);
55265 if (!SWIG_IsOK(ecode3)) {
55266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55267 }
55268 arg3 = static_cast< int >(val3);
55269 }
55270 {
55271 PyThreadState* __tstate = wxPyBeginAllowThreads();
55272 (arg1)->Above(arg2,arg3);
55273 wxPyEndAllowThreads(__tstate);
55274 if (PyErr_Occurred()) SWIG_fail;
55275 }
55276 resultobj = SWIG_Py_Void();
55277 return resultobj;
55278 fail:
55279 return NULL;
55280 }
55281
55282
55283 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55284 PyObject *resultobj = 0;
55285 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55286 wxWindow *arg2 = (wxWindow *) 0 ;
55287 int arg3 = (int) 0 ;
55288 void *argp1 = 0 ;
55289 int res1 = 0 ;
55290 void *argp2 = 0 ;
55291 int res2 = 0 ;
55292 int val3 ;
55293 int ecode3 = 0 ;
55294 PyObject * obj0 = 0 ;
55295 PyObject * obj1 = 0 ;
55296 PyObject * obj2 = 0 ;
55297 char * kwnames[] = {
55298 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55299 };
55300
55301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55303 if (!SWIG_IsOK(res1)) {
55304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55305 }
55306 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55307 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55308 if (!SWIG_IsOK(res2)) {
55309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55310 }
55311 arg2 = reinterpret_cast< wxWindow * >(argp2);
55312 if (obj2) {
55313 ecode3 = SWIG_AsVal_int(obj2, &val3);
55314 if (!SWIG_IsOK(ecode3)) {
55315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55316 }
55317 arg3 = static_cast< int >(val3);
55318 }
55319 {
55320 PyThreadState* __tstate = wxPyBeginAllowThreads();
55321 (arg1)->Below(arg2,arg3);
55322 wxPyEndAllowThreads(__tstate);
55323 if (PyErr_Occurred()) SWIG_fail;
55324 }
55325 resultobj = SWIG_Py_Void();
55326 return resultobj;
55327 fail:
55328 return NULL;
55329 }
55330
55331
55332 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55333 PyObject *resultobj = 0;
55334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55335 wxWindow *arg2 = (wxWindow *) 0 ;
55336 wxEdge arg3 ;
55337 int arg4 = (int) 0 ;
55338 void *argp1 = 0 ;
55339 int res1 = 0 ;
55340 void *argp2 = 0 ;
55341 int res2 = 0 ;
55342 int val3 ;
55343 int ecode3 = 0 ;
55344 int val4 ;
55345 int ecode4 = 0 ;
55346 PyObject * obj0 = 0 ;
55347 PyObject * obj1 = 0 ;
55348 PyObject * obj2 = 0 ;
55349 PyObject * obj3 = 0 ;
55350 char * kwnames[] = {
55351 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55352 };
55353
55354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55356 if (!SWIG_IsOK(res1)) {
55357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55358 }
55359 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55361 if (!SWIG_IsOK(res2)) {
55362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55363 }
55364 arg2 = reinterpret_cast< wxWindow * >(argp2);
55365 ecode3 = SWIG_AsVal_int(obj2, &val3);
55366 if (!SWIG_IsOK(ecode3)) {
55367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55368 }
55369 arg3 = static_cast< wxEdge >(val3);
55370 if (obj3) {
55371 ecode4 = SWIG_AsVal_int(obj3, &val4);
55372 if (!SWIG_IsOK(ecode4)) {
55373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55374 }
55375 arg4 = static_cast< int >(val4);
55376 }
55377 {
55378 PyThreadState* __tstate = wxPyBeginAllowThreads();
55379 (arg1)->SameAs(arg2,arg3,arg4);
55380 wxPyEndAllowThreads(__tstate);
55381 if (PyErr_Occurred()) SWIG_fail;
55382 }
55383 resultobj = SWIG_Py_Void();
55384 return resultobj;
55385 fail:
55386 return NULL;
55387 }
55388
55389
55390 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55391 PyObject *resultobj = 0;
55392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55393 wxWindow *arg2 = (wxWindow *) 0 ;
55394 wxEdge arg3 ;
55395 int arg4 ;
55396 void *argp1 = 0 ;
55397 int res1 = 0 ;
55398 void *argp2 = 0 ;
55399 int res2 = 0 ;
55400 int val3 ;
55401 int ecode3 = 0 ;
55402 int val4 ;
55403 int ecode4 = 0 ;
55404 PyObject * obj0 = 0 ;
55405 PyObject * obj1 = 0 ;
55406 PyObject * obj2 = 0 ;
55407 PyObject * obj3 = 0 ;
55408 char * kwnames[] = {
55409 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55410 };
55411
55412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55414 if (!SWIG_IsOK(res1)) {
55415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55416 }
55417 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55419 if (!SWIG_IsOK(res2)) {
55420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55421 }
55422 arg2 = reinterpret_cast< wxWindow * >(argp2);
55423 ecode3 = SWIG_AsVal_int(obj2, &val3);
55424 if (!SWIG_IsOK(ecode3)) {
55425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55426 }
55427 arg3 = static_cast< wxEdge >(val3);
55428 ecode4 = SWIG_AsVal_int(obj3, &val4);
55429 if (!SWIG_IsOK(ecode4)) {
55430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55431 }
55432 arg4 = static_cast< int >(val4);
55433 {
55434 PyThreadState* __tstate = wxPyBeginAllowThreads();
55435 (arg1)->PercentOf(arg2,arg3,arg4);
55436 wxPyEndAllowThreads(__tstate);
55437 if (PyErr_Occurred()) SWIG_fail;
55438 }
55439 resultobj = SWIG_Py_Void();
55440 return resultobj;
55441 fail:
55442 return NULL;
55443 }
55444
55445
55446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55447 PyObject *resultobj = 0;
55448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55449 int arg2 ;
55450 void *argp1 = 0 ;
55451 int res1 = 0 ;
55452 int val2 ;
55453 int ecode2 = 0 ;
55454 PyObject * obj0 = 0 ;
55455 PyObject * obj1 = 0 ;
55456 char * kwnames[] = {
55457 (char *) "self",(char *) "val", NULL
55458 };
55459
55460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55462 if (!SWIG_IsOK(res1)) {
55463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55464 }
55465 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55466 ecode2 = SWIG_AsVal_int(obj1, &val2);
55467 if (!SWIG_IsOK(ecode2)) {
55468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55469 }
55470 arg2 = static_cast< int >(val2);
55471 {
55472 PyThreadState* __tstate = wxPyBeginAllowThreads();
55473 (arg1)->Absolute(arg2);
55474 wxPyEndAllowThreads(__tstate);
55475 if (PyErr_Occurred()) SWIG_fail;
55476 }
55477 resultobj = SWIG_Py_Void();
55478 return resultobj;
55479 fail:
55480 return NULL;
55481 }
55482
55483
55484 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55485 PyObject *resultobj = 0;
55486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55487 void *argp1 = 0 ;
55488 int res1 = 0 ;
55489 PyObject *swig_obj[1] ;
55490
55491 if (!args) SWIG_fail;
55492 swig_obj[0] = args;
55493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55494 if (!SWIG_IsOK(res1)) {
55495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55496 }
55497 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55498 {
55499 PyThreadState* __tstate = wxPyBeginAllowThreads();
55500 (arg1)->Unconstrained();
55501 wxPyEndAllowThreads(__tstate);
55502 if (PyErr_Occurred()) SWIG_fail;
55503 }
55504 resultobj = SWIG_Py_Void();
55505 return resultobj;
55506 fail:
55507 return NULL;
55508 }
55509
55510
55511 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55512 PyObject *resultobj = 0;
55513 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55514 void *argp1 = 0 ;
55515 int res1 = 0 ;
55516 PyObject *swig_obj[1] ;
55517
55518 if (!args) SWIG_fail;
55519 swig_obj[0] = args;
55520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55521 if (!SWIG_IsOK(res1)) {
55522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55523 }
55524 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55525 {
55526 PyThreadState* __tstate = wxPyBeginAllowThreads();
55527 (arg1)->AsIs();
55528 wxPyEndAllowThreads(__tstate);
55529 if (PyErr_Occurred()) SWIG_fail;
55530 }
55531 resultobj = SWIG_Py_Void();
55532 return resultobj;
55533 fail:
55534 return NULL;
55535 }
55536
55537
55538 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55539 PyObject *resultobj = 0;
55540 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55541 wxWindow *result = 0 ;
55542 void *argp1 = 0 ;
55543 int res1 = 0 ;
55544 PyObject *swig_obj[1] ;
55545
55546 if (!args) SWIG_fail;
55547 swig_obj[0] = args;
55548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55549 if (!SWIG_IsOK(res1)) {
55550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55551 }
55552 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55553 {
55554 PyThreadState* __tstate = wxPyBeginAllowThreads();
55555 result = (wxWindow *)(arg1)->GetOtherWindow();
55556 wxPyEndAllowThreads(__tstate);
55557 if (PyErr_Occurred()) SWIG_fail;
55558 }
55559 {
55560 resultobj = wxPyMake_wxObject(result, 0);
55561 }
55562 return resultobj;
55563 fail:
55564 return NULL;
55565 }
55566
55567
55568 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55569 PyObject *resultobj = 0;
55570 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55571 wxEdge result;
55572 void *argp1 = 0 ;
55573 int res1 = 0 ;
55574 PyObject *swig_obj[1] ;
55575
55576 if (!args) SWIG_fail;
55577 swig_obj[0] = args;
55578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55579 if (!SWIG_IsOK(res1)) {
55580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55581 }
55582 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55583 {
55584 PyThreadState* __tstate = wxPyBeginAllowThreads();
55585 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55586 wxPyEndAllowThreads(__tstate);
55587 if (PyErr_Occurred()) SWIG_fail;
55588 }
55589 resultobj = SWIG_From_int(static_cast< int >(result));
55590 return resultobj;
55591 fail:
55592 return NULL;
55593 }
55594
55595
55596 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55597 PyObject *resultobj = 0;
55598 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55599 wxEdge arg2 ;
55600 void *argp1 = 0 ;
55601 int res1 = 0 ;
55602 int val2 ;
55603 int ecode2 = 0 ;
55604 PyObject * obj0 = 0 ;
55605 PyObject * obj1 = 0 ;
55606 char * kwnames[] = {
55607 (char *) "self",(char *) "which", NULL
55608 };
55609
55610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55612 if (!SWIG_IsOK(res1)) {
55613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55614 }
55615 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55616 ecode2 = SWIG_AsVal_int(obj1, &val2);
55617 if (!SWIG_IsOK(ecode2)) {
55618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55619 }
55620 arg2 = static_cast< wxEdge >(val2);
55621 {
55622 PyThreadState* __tstate = wxPyBeginAllowThreads();
55623 (arg1)->SetEdge(arg2);
55624 wxPyEndAllowThreads(__tstate);
55625 if (PyErr_Occurred()) SWIG_fail;
55626 }
55627 resultobj = SWIG_Py_Void();
55628 return resultobj;
55629 fail:
55630 return NULL;
55631 }
55632
55633
55634 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55635 PyObject *resultobj = 0;
55636 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55637 int arg2 ;
55638 void *argp1 = 0 ;
55639 int res1 = 0 ;
55640 int val2 ;
55641 int ecode2 = 0 ;
55642 PyObject * obj0 = 0 ;
55643 PyObject * obj1 = 0 ;
55644 char * kwnames[] = {
55645 (char *) "self",(char *) "v", NULL
55646 };
55647
55648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55650 if (!SWIG_IsOK(res1)) {
55651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55652 }
55653 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55654 ecode2 = SWIG_AsVal_int(obj1, &val2);
55655 if (!SWIG_IsOK(ecode2)) {
55656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55657 }
55658 arg2 = static_cast< int >(val2);
55659 {
55660 PyThreadState* __tstate = wxPyBeginAllowThreads();
55661 (arg1)->SetValue(arg2);
55662 wxPyEndAllowThreads(__tstate);
55663 if (PyErr_Occurred()) SWIG_fail;
55664 }
55665 resultobj = SWIG_Py_Void();
55666 return resultobj;
55667 fail:
55668 return NULL;
55669 }
55670
55671
55672 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55673 PyObject *resultobj = 0;
55674 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55675 int result;
55676 void *argp1 = 0 ;
55677 int res1 = 0 ;
55678 PyObject *swig_obj[1] ;
55679
55680 if (!args) SWIG_fail;
55681 swig_obj[0] = args;
55682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55683 if (!SWIG_IsOK(res1)) {
55684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55685 }
55686 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55687 {
55688 PyThreadState* __tstate = wxPyBeginAllowThreads();
55689 result = (int)(arg1)->GetMargin();
55690 wxPyEndAllowThreads(__tstate);
55691 if (PyErr_Occurred()) SWIG_fail;
55692 }
55693 resultobj = SWIG_From_int(static_cast< int >(result));
55694 return resultobj;
55695 fail:
55696 return NULL;
55697 }
55698
55699
55700 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55701 PyObject *resultobj = 0;
55702 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55703 int arg2 ;
55704 void *argp1 = 0 ;
55705 int res1 = 0 ;
55706 int val2 ;
55707 int ecode2 = 0 ;
55708 PyObject * obj0 = 0 ;
55709 PyObject * obj1 = 0 ;
55710 char * kwnames[] = {
55711 (char *) "self",(char *) "m", NULL
55712 };
55713
55714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55716 if (!SWIG_IsOK(res1)) {
55717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55718 }
55719 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55720 ecode2 = SWIG_AsVal_int(obj1, &val2);
55721 if (!SWIG_IsOK(ecode2)) {
55722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55723 }
55724 arg2 = static_cast< int >(val2);
55725 {
55726 PyThreadState* __tstate = wxPyBeginAllowThreads();
55727 (arg1)->SetMargin(arg2);
55728 wxPyEndAllowThreads(__tstate);
55729 if (PyErr_Occurred()) SWIG_fail;
55730 }
55731 resultobj = SWIG_Py_Void();
55732 return resultobj;
55733 fail:
55734 return NULL;
55735 }
55736
55737
55738 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55739 PyObject *resultobj = 0;
55740 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55741 int result;
55742 void *argp1 = 0 ;
55743 int res1 = 0 ;
55744 PyObject *swig_obj[1] ;
55745
55746 if (!args) SWIG_fail;
55747 swig_obj[0] = args;
55748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55749 if (!SWIG_IsOK(res1)) {
55750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55751 }
55752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55753 {
55754 PyThreadState* __tstate = wxPyBeginAllowThreads();
55755 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55756 wxPyEndAllowThreads(__tstate);
55757 if (PyErr_Occurred()) SWIG_fail;
55758 }
55759 resultobj = SWIG_From_int(static_cast< int >(result));
55760 return resultobj;
55761 fail:
55762 return NULL;
55763 }
55764
55765
55766 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55767 PyObject *resultobj = 0;
55768 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55769 int result;
55770 void *argp1 = 0 ;
55771 int res1 = 0 ;
55772 PyObject *swig_obj[1] ;
55773
55774 if (!args) SWIG_fail;
55775 swig_obj[0] = args;
55776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55777 if (!SWIG_IsOK(res1)) {
55778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55779 }
55780 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55781 {
55782 PyThreadState* __tstate = wxPyBeginAllowThreads();
55783 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55784 wxPyEndAllowThreads(__tstate);
55785 if (PyErr_Occurred()) SWIG_fail;
55786 }
55787 resultobj = SWIG_From_int(static_cast< int >(result));
55788 return resultobj;
55789 fail:
55790 return NULL;
55791 }
55792
55793
55794 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55795 PyObject *resultobj = 0;
55796 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55797 int result;
55798 void *argp1 = 0 ;
55799 int res1 = 0 ;
55800 PyObject *swig_obj[1] ;
55801
55802 if (!args) SWIG_fail;
55803 swig_obj[0] = args;
55804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55805 if (!SWIG_IsOK(res1)) {
55806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55807 }
55808 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55809 {
55810 PyThreadState* __tstate = wxPyBeginAllowThreads();
55811 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55812 wxPyEndAllowThreads(__tstate);
55813 if (PyErr_Occurred()) SWIG_fail;
55814 }
55815 resultobj = SWIG_From_int(static_cast< int >(result));
55816 return resultobj;
55817 fail:
55818 return NULL;
55819 }
55820
55821
55822 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55823 PyObject *resultobj = 0;
55824 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55825 bool result;
55826 void *argp1 = 0 ;
55827 int res1 = 0 ;
55828 PyObject *swig_obj[1] ;
55829
55830 if (!args) SWIG_fail;
55831 swig_obj[0] = args;
55832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55833 if (!SWIG_IsOK(res1)) {
55834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55835 }
55836 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55837 {
55838 PyThreadState* __tstate = wxPyBeginAllowThreads();
55839 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55840 wxPyEndAllowThreads(__tstate);
55841 if (PyErr_Occurred()) SWIG_fail;
55842 }
55843 {
55844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55845 }
55846 return resultobj;
55847 fail:
55848 return NULL;
55849 }
55850
55851
55852 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55853 PyObject *resultobj = 0;
55854 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55855 bool arg2 ;
55856 void *argp1 = 0 ;
55857 int res1 = 0 ;
55858 bool val2 ;
55859 int ecode2 = 0 ;
55860 PyObject * obj0 = 0 ;
55861 PyObject * obj1 = 0 ;
55862 char * kwnames[] = {
55863 (char *) "self",(char *) "d", NULL
55864 };
55865
55866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55868 if (!SWIG_IsOK(res1)) {
55869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55870 }
55871 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55873 if (!SWIG_IsOK(ecode2)) {
55874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55875 }
55876 arg2 = static_cast< bool >(val2);
55877 {
55878 PyThreadState* __tstate = wxPyBeginAllowThreads();
55879 (arg1)->SetDone(arg2);
55880 wxPyEndAllowThreads(__tstate);
55881 if (PyErr_Occurred()) SWIG_fail;
55882 }
55883 resultobj = SWIG_Py_Void();
55884 return resultobj;
55885 fail:
55886 return NULL;
55887 }
55888
55889
55890 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55891 PyObject *resultobj = 0;
55892 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55893 wxRelationship result;
55894 void *argp1 = 0 ;
55895 int res1 = 0 ;
55896 PyObject *swig_obj[1] ;
55897
55898 if (!args) SWIG_fail;
55899 swig_obj[0] = args;
55900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55901 if (!SWIG_IsOK(res1)) {
55902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55903 }
55904 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55905 {
55906 PyThreadState* __tstate = wxPyBeginAllowThreads();
55907 result = (wxRelationship)(arg1)->GetRelationship();
55908 wxPyEndAllowThreads(__tstate);
55909 if (PyErr_Occurred()) SWIG_fail;
55910 }
55911 resultobj = SWIG_From_int(static_cast< int >(result));
55912 return resultobj;
55913 fail:
55914 return NULL;
55915 }
55916
55917
55918 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55919 PyObject *resultobj = 0;
55920 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55921 wxRelationship arg2 ;
55922 void *argp1 = 0 ;
55923 int res1 = 0 ;
55924 int val2 ;
55925 int ecode2 = 0 ;
55926 PyObject * obj0 = 0 ;
55927 PyObject * obj1 = 0 ;
55928 char * kwnames[] = {
55929 (char *) "self",(char *) "r", NULL
55930 };
55931
55932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55934 if (!SWIG_IsOK(res1)) {
55935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55936 }
55937 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55938 ecode2 = SWIG_AsVal_int(obj1, &val2);
55939 if (!SWIG_IsOK(ecode2)) {
55940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55941 }
55942 arg2 = static_cast< wxRelationship >(val2);
55943 {
55944 PyThreadState* __tstate = wxPyBeginAllowThreads();
55945 (arg1)->SetRelationship(arg2);
55946 wxPyEndAllowThreads(__tstate);
55947 if (PyErr_Occurred()) SWIG_fail;
55948 }
55949 resultobj = SWIG_Py_Void();
55950 return resultobj;
55951 fail:
55952 return NULL;
55953 }
55954
55955
55956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55957 PyObject *resultobj = 0;
55958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55959 wxWindow *arg2 = (wxWindow *) 0 ;
55960 bool result;
55961 void *argp1 = 0 ;
55962 int res1 = 0 ;
55963 void *argp2 = 0 ;
55964 int res2 = 0 ;
55965 PyObject * obj0 = 0 ;
55966 PyObject * obj1 = 0 ;
55967 char * kwnames[] = {
55968 (char *) "self",(char *) "otherW", NULL
55969 };
55970
55971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55973 if (!SWIG_IsOK(res1)) {
55974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55975 }
55976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55978 if (!SWIG_IsOK(res2)) {
55979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55980 }
55981 arg2 = reinterpret_cast< wxWindow * >(argp2);
55982 {
55983 PyThreadState* __tstate = wxPyBeginAllowThreads();
55984 result = (bool)(arg1)->ResetIfWin(arg2);
55985 wxPyEndAllowThreads(__tstate);
55986 if (PyErr_Occurred()) SWIG_fail;
55987 }
55988 {
55989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55990 }
55991 return resultobj;
55992 fail:
55993 return NULL;
55994 }
55995
55996
55997 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55998 PyObject *resultobj = 0;
55999 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56000 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56001 wxWindow *arg3 = (wxWindow *) 0 ;
56002 bool result;
56003 void *argp1 = 0 ;
56004 int res1 = 0 ;
56005 void *argp2 = 0 ;
56006 int res2 = 0 ;
56007 void *argp3 = 0 ;
56008 int res3 = 0 ;
56009 PyObject * obj0 = 0 ;
56010 PyObject * obj1 = 0 ;
56011 PyObject * obj2 = 0 ;
56012 char * kwnames[] = {
56013 (char *) "self",(char *) "constraints",(char *) "win", NULL
56014 };
56015
56016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56018 if (!SWIG_IsOK(res1)) {
56019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56020 }
56021 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56023 if (!SWIG_IsOK(res2)) {
56024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56025 }
56026 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56027 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56028 if (!SWIG_IsOK(res3)) {
56029 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56030 }
56031 arg3 = reinterpret_cast< wxWindow * >(argp3);
56032 {
56033 PyThreadState* __tstate = wxPyBeginAllowThreads();
56034 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56035 wxPyEndAllowThreads(__tstate);
56036 if (PyErr_Occurred()) SWIG_fail;
56037 }
56038 {
56039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56040 }
56041 return resultobj;
56042 fail:
56043 return NULL;
56044 }
56045
56046
56047 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56048 PyObject *resultobj = 0;
56049 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56050 wxEdge arg2 ;
56051 wxWindow *arg3 = (wxWindow *) 0 ;
56052 wxWindow *arg4 = (wxWindow *) 0 ;
56053 int result;
56054 void *argp1 = 0 ;
56055 int res1 = 0 ;
56056 int val2 ;
56057 int ecode2 = 0 ;
56058 void *argp3 = 0 ;
56059 int res3 = 0 ;
56060 void *argp4 = 0 ;
56061 int res4 = 0 ;
56062 PyObject * obj0 = 0 ;
56063 PyObject * obj1 = 0 ;
56064 PyObject * obj2 = 0 ;
56065 PyObject * obj3 = 0 ;
56066 char * kwnames[] = {
56067 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56068 };
56069
56070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56072 if (!SWIG_IsOK(res1)) {
56073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56074 }
56075 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56076 ecode2 = SWIG_AsVal_int(obj1, &val2);
56077 if (!SWIG_IsOK(ecode2)) {
56078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56079 }
56080 arg2 = static_cast< wxEdge >(val2);
56081 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56082 if (!SWIG_IsOK(res3)) {
56083 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56084 }
56085 arg3 = reinterpret_cast< wxWindow * >(argp3);
56086 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56087 if (!SWIG_IsOK(res4)) {
56088 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56089 }
56090 arg4 = reinterpret_cast< wxWindow * >(argp4);
56091 {
56092 PyThreadState* __tstate = wxPyBeginAllowThreads();
56093 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56094 wxPyEndAllowThreads(__tstate);
56095 if (PyErr_Occurred()) SWIG_fail;
56096 }
56097 resultobj = SWIG_From_int(static_cast< int >(result));
56098 return resultobj;
56099 fail:
56100 return NULL;
56101 }
56102
56103
56104 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56105 PyObject *obj;
56106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56107 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56108 return SWIG_Py_Void();
56109 }
56110
56111 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56112 PyObject *resultobj = 0;
56113 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56114 wxIndividualLayoutConstraint *result = 0 ;
56115 void *argp1 = 0 ;
56116 int res1 = 0 ;
56117 PyObject *swig_obj[1] ;
56118
56119 if (!args) SWIG_fail;
56120 swig_obj[0] = args;
56121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56122 if (!SWIG_IsOK(res1)) {
56123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56124 }
56125 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56126 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56128 return resultobj;
56129 fail:
56130 return NULL;
56131 }
56132
56133
56134 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56135 PyObject *resultobj = 0;
56136 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56137 wxIndividualLayoutConstraint *result = 0 ;
56138 void *argp1 = 0 ;
56139 int res1 = 0 ;
56140 PyObject *swig_obj[1] ;
56141
56142 if (!args) SWIG_fail;
56143 swig_obj[0] = args;
56144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56145 if (!SWIG_IsOK(res1)) {
56146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56147 }
56148 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56149 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56151 return resultobj;
56152 fail:
56153 return NULL;
56154 }
56155
56156
56157 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56158 PyObject *resultobj = 0;
56159 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56160 wxIndividualLayoutConstraint *result = 0 ;
56161 void *argp1 = 0 ;
56162 int res1 = 0 ;
56163 PyObject *swig_obj[1] ;
56164
56165 if (!args) SWIG_fail;
56166 swig_obj[0] = args;
56167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56168 if (!SWIG_IsOK(res1)) {
56169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56170 }
56171 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56172 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56174 return resultobj;
56175 fail:
56176 return NULL;
56177 }
56178
56179
56180 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56181 PyObject *resultobj = 0;
56182 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56183 wxIndividualLayoutConstraint *result = 0 ;
56184 void *argp1 = 0 ;
56185 int res1 = 0 ;
56186 PyObject *swig_obj[1] ;
56187
56188 if (!args) SWIG_fail;
56189 swig_obj[0] = args;
56190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56191 if (!SWIG_IsOK(res1)) {
56192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56193 }
56194 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56195 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56197 return resultobj;
56198 fail:
56199 return NULL;
56200 }
56201
56202
56203 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56204 PyObject *resultobj = 0;
56205 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56206 wxIndividualLayoutConstraint *result = 0 ;
56207 void *argp1 = 0 ;
56208 int res1 = 0 ;
56209 PyObject *swig_obj[1] ;
56210
56211 if (!args) SWIG_fail;
56212 swig_obj[0] = args;
56213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56214 if (!SWIG_IsOK(res1)) {
56215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56216 }
56217 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56218 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56220 return resultobj;
56221 fail:
56222 return NULL;
56223 }
56224
56225
56226 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56227 PyObject *resultobj = 0;
56228 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56229 wxIndividualLayoutConstraint *result = 0 ;
56230 void *argp1 = 0 ;
56231 int res1 = 0 ;
56232 PyObject *swig_obj[1] ;
56233
56234 if (!args) SWIG_fail;
56235 swig_obj[0] = args;
56236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56237 if (!SWIG_IsOK(res1)) {
56238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56239 }
56240 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56241 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56243 return resultobj;
56244 fail:
56245 return NULL;
56246 }
56247
56248
56249 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56250 PyObject *resultobj = 0;
56251 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56252 wxIndividualLayoutConstraint *result = 0 ;
56253 void *argp1 = 0 ;
56254 int res1 = 0 ;
56255 PyObject *swig_obj[1] ;
56256
56257 if (!args) SWIG_fail;
56258 swig_obj[0] = args;
56259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56260 if (!SWIG_IsOK(res1)) {
56261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56262 }
56263 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56264 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56266 return resultobj;
56267 fail:
56268 return NULL;
56269 }
56270
56271
56272 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56273 PyObject *resultobj = 0;
56274 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56275 wxIndividualLayoutConstraint *result = 0 ;
56276 void *argp1 = 0 ;
56277 int res1 = 0 ;
56278 PyObject *swig_obj[1] ;
56279
56280 if (!args) SWIG_fail;
56281 swig_obj[0] = args;
56282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56283 if (!SWIG_IsOK(res1)) {
56284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56285 }
56286 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56287 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56289 return resultobj;
56290 fail:
56291 return NULL;
56292 }
56293
56294
56295 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56296 PyObject *resultobj = 0;
56297 wxLayoutConstraints *result = 0 ;
56298
56299 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56300 {
56301 PyThreadState* __tstate = wxPyBeginAllowThreads();
56302 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56303 wxPyEndAllowThreads(__tstate);
56304 if (PyErr_Occurred()) SWIG_fail;
56305 }
56306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56307 return resultobj;
56308 fail:
56309 return NULL;
56310 }
56311
56312
56313 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56314 PyObject *resultobj = 0;
56315 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56316 void *argp1 = 0 ;
56317 int res1 = 0 ;
56318 PyObject *swig_obj[1] ;
56319
56320 if (!args) SWIG_fail;
56321 swig_obj[0] = args;
56322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56323 if (!SWIG_IsOK(res1)) {
56324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56325 }
56326 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56327 {
56328 PyThreadState* __tstate = wxPyBeginAllowThreads();
56329 delete arg1;
56330
56331 wxPyEndAllowThreads(__tstate);
56332 if (PyErr_Occurred()) SWIG_fail;
56333 }
56334 resultobj = SWIG_Py_Void();
56335 return resultobj;
56336 fail:
56337 return NULL;
56338 }
56339
56340
56341 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56342 PyObject *resultobj = 0;
56343 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56344 wxWindow *arg2 = (wxWindow *) 0 ;
56345 int *arg3 = (int *) 0 ;
56346 bool result;
56347 void *argp1 = 0 ;
56348 int res1 = 0 ;
56349 void *argp2 = 0 ;
56350 int res2 = 0 ;
56351 int temp3 ;
56352 int res3 = SWIG_TMPOBJ ;
56353 PyObject * obj0 = 0 ;
56354 PyObject * obj1 = 0 ;
56355 char * kwnames[] = {
56356 (char *) "self",(char *) "win", NULL
56357 };
56358
56359 arg3 = &temp3;
56360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56362 if (!SWIG_IsOK(res1)) {
56363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56364 }
56365 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56367 if (!SWIG_IsOK(res2)) {
56368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56369 }
56370 arg2 = reinterpret_cast< wxWindow * >(argp2);
56371 {
56372 PyThreadState* __tstate = wxPyBeginAllowThreads();
56373 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56374 wxPyEndAllowThreads(__tstate);
56375 if (PyErr_Occurred()) SWIG_fail;
56376 }
56377 {
56378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56379 }
56380 if (SWIG_IsTmpObj(res3)) {
56381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56382 } else {
56383 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56385 }
56386 return resultobj;
56387 fail:
56388 return NULL;
56389 }
56390
56391
56392 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56393 PyObject *resultobj = 0;
56394 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56395 bool result;
56396 void *argp1 = 0 ;
56397 int res1 = 0 ;
56398 PyObject *swig_obj[1] ;
56399
56400 if (!args) SWIG_fail;
56401 swig_obj[0] = args;
56402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56403 if (!SWIG_IsOK(res1)) {
56404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56405 }
56406 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56407 {
56408 PyThreadState* __tstate = wxPyBeginAllowThreads();
56409 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56410 wxPyEndAllowThreads(__tstate);
56411 if (PyErr_Occurred()) SWIG_fail;
56412 }
56413 {
56414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56415 }
56416 return resultobj;
56417 fail:
56418 return NULL;
56419 }
56420
56421
56422 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56423 PyObject *obj;
56424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56425 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56426 return SWIG_Py_Void();
56427 }
56428
56429 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56430 return SWIG_Python_InitShadowInstance(args);
56431 }
56432
56433 static PyMethodDef SwigMethods[] = {
56434 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56435 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56436 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56437 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56439 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56440 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56441 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56442 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56443 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56445 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56448 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56450 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56452 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56458 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56459 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56460 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56462 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56463 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56464 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56465 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56466 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56467 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56468 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56470 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56476 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56477 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56478 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56479 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56480 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56481 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56482 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56484 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56492 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56493 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56494 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56499 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56500 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56502 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56504 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56506 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56508 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56510 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56512 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56513 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56515 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56517 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56519 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56521 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56522 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56523 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56524 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56544 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56545 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56546 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56547 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56548 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56549 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56550 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56551 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56553 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56554 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56555 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56560 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56561 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56562 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56563 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56564 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56570 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56571 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56578 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56579 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56580 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56581 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56583 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56584 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56585 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56587 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56588 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56589 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56590 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56593 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56596 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56597 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56599 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56602 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56605 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56608 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56611 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56614 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56620 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56622 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56631 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56634 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56635 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56636 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56637 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56638 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56639 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56640 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56641 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56643 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56644 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56645 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56647 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56648 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56649 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56650 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56652 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56653 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56655 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56656 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56657 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56658 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56659 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56660 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56663 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56664 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56665 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56667 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56668 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56670 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56671 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56672 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56673 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56674 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56675 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56676 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56677 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56678 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56679 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56680 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56681 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56686 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56692 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56693 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56694 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56695 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56697 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56700 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56703 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56706 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56707 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56708 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56711 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56712 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56713 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56717 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56718 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56719 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56723 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56728 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56729 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56730 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56731 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56732 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56733 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56734 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56741 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56742 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56744 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56745 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56746 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56752 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56753 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56755 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56756 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56757 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56758 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56759 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56760 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56761 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56762 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56764 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56765 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56766 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56767 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56768 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56769 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56770 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56771 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56773 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56782 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56799 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56800 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56815 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56816 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56817 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56818 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56821 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56823 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56825 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56827 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56829 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56832 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56833 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56834 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56835 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56837 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56854 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56855 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56861 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56862 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56864 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56865 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56866 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56867 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56868 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56869 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56870 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56871 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56872 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56873 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56874 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56875 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56876 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56877 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56878 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56879 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56880 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56881 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56882 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56883 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56884 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56885 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56886 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56887 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56888 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56889 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56890 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56891 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56892 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56893 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56894 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56895 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56896 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56898 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56899 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56900 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56901 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56902 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56904 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56905 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56906 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56908 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56910 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56911 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56912 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56915 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56916 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56917 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56918 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56920 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56921 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56923 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56925 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56927 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56929 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56930 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56931 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56933 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56934 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56935 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56936 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56937 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56938 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56940 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56941 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56942 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56944 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56946 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56947 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56948 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56950 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56951 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56952 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56953 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56955 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56956 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56957 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56959 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56960 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56961 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56962 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56963 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56965 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56966 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56968 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56969 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56970 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56972 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56973 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56975 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56976 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56977 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56978 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56979 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56981 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56982 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56985 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56986 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56987 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56988 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56989 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56990 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56991 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56992 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56993 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56994 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56995 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56996 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56997 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56998 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56999 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57000 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57001 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57002 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57003 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57004 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57005 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57006 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57007 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57008 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57009 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57010 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57011 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57012 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57013 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57014 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57015 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57016 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57017 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57018 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57019 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57020 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57021 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57022 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57023 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57024 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57025 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57026 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57027 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57028 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57029 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57030 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57031 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57032 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57033 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57034 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57035 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57036 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57037 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57038 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57039 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57040 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57041 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57042 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57043 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57044 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57045 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57046 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57047 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57048 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57049 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57051 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57052 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57053 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57054 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57055 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57056 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57057 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57058 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57059 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57061 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57062 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57063 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57064 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57065 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57066 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57067 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57068 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57069 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57070 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57071 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57072 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57073 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57074 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57075 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57076 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57077 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57078 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57079 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57080 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57081 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57082 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57083 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57084 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57085 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57086 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57087 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57088 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57089 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57090 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57091 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57092 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57093 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57094 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57095 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57096 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57097 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57099 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57101 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57102 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57103 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57104 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57105 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57106 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57108 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57109 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57110 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57111 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57112 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57113 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57114 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57115 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57116 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57117 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57118 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57120 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57121 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57122 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57123 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57124 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57125 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57126 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57127 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57128 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57129 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57130 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57131 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57132 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57134 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57135 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57136 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57137 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57138 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57139 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57141 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57142 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57143 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57145 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57146 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57147 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57150 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57151 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57152 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57154 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57155 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57156 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57158 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57159 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57160 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57161 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57162 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57163 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57165 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57166 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57167 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57168 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57169 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57170 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57171 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57172 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57174 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57176 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57178 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57180 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57181 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57182 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57183 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57184 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57185 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57186 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57187 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57189 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57190 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57191 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57193 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57194 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57195 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57196 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57197 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57199 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57200 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57201 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57202 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57205 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57206 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57207 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57208 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57209 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57211 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57212 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57213 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57215 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57216 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57217 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57218 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57219 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57221 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57222 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57223 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57225 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57226 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57227 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57229 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57231 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57232 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57233 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57235 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57236 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57237 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57239 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57240 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57241 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57242 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57243 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57245 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57247 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57248 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57249 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57251 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57253 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57254 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57255 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57257 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57258 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57259 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57260 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57261 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57262 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57263 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57264 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57266 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57268 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57270 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57271 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57273 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57274 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57275 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57276 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57277 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57278 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57279 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57280 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57281 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57283 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57285 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57287 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57289 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57290 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57291 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57293 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57294 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57295 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57296 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57297 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57298 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57304 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57305 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57306 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57307 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57308 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57309 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57310 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57311 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57313 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57315 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57316 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57318 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57319 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57320 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57321 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57323 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57324 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57325 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57326 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57328 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57329 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57330 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57331 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57332 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57333 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57334 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57335 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57338 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57339 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57340 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57341 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57342 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57344 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57345 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57347 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57348 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57349 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57350 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57352 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57353 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57354 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57355 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57356 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57357 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57358 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57359 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57360 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57361 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57363 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57366 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57367 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57368 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57370 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57372 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57374 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57376 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57377 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57380 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57383 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57390 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57391 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57395 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57396 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57397 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57398 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57399 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57400 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57401 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57402 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57403 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57404 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57405 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57406 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57407 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57408 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57409 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57410 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
57411 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57414 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57415 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57420 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57421 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57424 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57425 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57426 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57427 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57430 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57431 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57432 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57434 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57436 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57437 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57438 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57439 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57441 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57443 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57445 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57447 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57448 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57449 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57450 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57451 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57452 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57453 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57457 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57458 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57459 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57460 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57467 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57473 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57474 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57475 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57476 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57477 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57479 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57489 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57490 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57491 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57492 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57495 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57496 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57497 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57498 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57499 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57501 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57502 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57503 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57507 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57513 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57514 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57515 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57516 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57518 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57519 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57521 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57524 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57526 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57527 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57528 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57537 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57541 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57542 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57544 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57555 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57556 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57557 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57558 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57562 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57565 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57567 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57570 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57572 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57573 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57576 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57578 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57579 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57580 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57581 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57583 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57584 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57589 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57590 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57591 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57593 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57594 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57595 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57597 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57599 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57600 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57601 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57603 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57604 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57607 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57615 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57617 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57622 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57630 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57633 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57634 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57647 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57649 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57651 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57652 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57654 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57656 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57657 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57659 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57660 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57661 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57665 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57684 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57685 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57687 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57688 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57690 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57691 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57692 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57694 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57695 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57698 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57699 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57701 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57702 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57704 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57707 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57708 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57710 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57712 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57714 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57715 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57717 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57718 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57721 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57723 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57725 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57727 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57730 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57732 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57733 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57734 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57736 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57737 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57738 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57740 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57742 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57743 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57746 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57747 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57751 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57755 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57756 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57758 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57762 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57764 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57766 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57767 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57768 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57769 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57773 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57774 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57775 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57776 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57778 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57779 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57784 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57785 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57786 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57787 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57788 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57790 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57792 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57794 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57795 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57797 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57799 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57802 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57803 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57804 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57806 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57807 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57808 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57821 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57827 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57828 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57829 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57830 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57831 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57832 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57838 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57839 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57843 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57844 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57846 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57847 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57849 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57851 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57852 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57854 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57855 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57856 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57862 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57863 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57864 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57865 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57866 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57867 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57874 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57876 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57877 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57878 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57879 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57880 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57881 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57883 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57887 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57888 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57889 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57890 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57891 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57892 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57893 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57895 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57896 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57897 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57898 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57903 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57904 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57905 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57907 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57908 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57909 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57915 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57916 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57917 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57918 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57919 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57923 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57924 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57926 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57929 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57930 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57932 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57933 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57938 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57940 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57941 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57942 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57943 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57944 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57949 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57950 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57959 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57960 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57961 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57962 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57965 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57967 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57968 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57969 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57970 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57972 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57977 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57978 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57979 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57980 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57981 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57982 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57983 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57984 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57985 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57986 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57987 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57989 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57990 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57991 { NULL, NULL, 0, NULL }
57992 };
57993
57994
57995 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57996
57997 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57998 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57999 }
58000 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58001 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58002 }
58003 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58004 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58005 }
58006 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58007 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58008 }
58009 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58010 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58011 }
58012 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58013 return (void *)((wxSizer *) ((wxGridSizer *) x));
58014 }
58015 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58016 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58017 }
58018 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58019 return (void *)((wxSizer *) ((wxPySizer *) x));
58020 }
58021 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58022 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58023 }
58024 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58025 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58026 }
58027 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58028 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58029 }
58030 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58031 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58032 }
58033 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58034 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58035 }
58036 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58037 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58038 }
58039 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58040 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58041 }
58042 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58043 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58044 }
58045 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58047 }
58048 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58050 }
58051 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58053 }
58054 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58056 }
58057 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) ((wxPyEvent *) x));
58059 }
58060 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58061 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58062 }
58063 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58065 }
58066 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58068 }
58069 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58071 }
58072 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58074 }
58075 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58077 }
58078 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58080 }
58081 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58083 }
58084 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58086 }
58087 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58089 }
58090 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58092 }
58093 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58095 }
58096 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58098 }
58099 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58100 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58101 }
58102 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58103 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58104 }
58105 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58106 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58107 }
58108 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58109 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58110 }
58111 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58112 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58113 }
58114 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58115 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58116 }
58117 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58118 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58119 }
58120 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58121 return (void *)((wxEvent *) ((wxShowEvent *) x));
58122 }
58123 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58124 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58125 }
58126 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58127 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58128 }
58129 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58130 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58131 }
58132 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58133 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58134 }
58135 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58136 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58137 }
58138 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58139 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58140 }
58141 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58142 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58143 }
58144 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58145 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58146 }
58147 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58148 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58149 }
58150 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58151 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58152 }
58153 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58154 return (void *)((wxControl *) ((wxControlWithItems *) x));
58155 }
58156 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58157 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58158 }
58159 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58160 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58161 }
58162 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58163 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58164 }
58165 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58166 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58167 }
58168 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58169 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58170 }
58171 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58172 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58173 }
58174 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58175 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58176 }
58177 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58178 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58179 }
58180 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58181 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58182 }
58183 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58184 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58185 }
58186 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58187 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58188 }
58189 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58190 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58191 }
58192 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58193 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58194 }
58195 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58196 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58197 }
58198 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58199 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58200 }
58201 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58202 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58203 }
58204 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58205 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58206 }
58207 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58208 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58209 }
58210 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58211 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58212 }
58213 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58214 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58215 }
58216 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58217 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58218 }
58219 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58220 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58221 }
58222 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58223 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58224 }
58225 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58226 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58227 }
58228 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58229 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58230 }
58231 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58232 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58233 }
58234 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58235 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58236 }
58237 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58238 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58239 }
58240 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58241 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58242 }
58243 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58244 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58245 }
58246 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58247 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58248 }
58249 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58250 return (void *)((wxObject *) ((wxSizerItem *) x));
58251 }
58252 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58253 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58254 }
58255 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58256 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58257 }
58258 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58259 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58260 }
58261 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58262 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58263 }
58264 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58265 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58266 }
58267 static void *_p_wxSizerTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) ((wxSizer *) x));
58269 }
58270 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58272 }
58273 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58275 }
58276 static void *_p_wxEventTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) ((wxEvent *) x));
58278 }
58279 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58281 }
58282 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58284 }
58285 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58287 }
58288 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58290 }
58291 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58293 }
58294 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58296 }
58297 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58299 }
58300 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58302 }
58303 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58305 }
58306 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58308 }
58309 static void *_p_wxControlTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58311 }
58312 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58314 }
58315 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) ((wxFSFile *) x));
58317 }
58318 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58320 }
58321 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58323 }
58324 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58326 }
58327 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58329 }
58330 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) ((wxMenuItem *) x));
58332 }
58333 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58335 }
58336 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58338 }
58339 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58341 }
58342 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58344 }
58345 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58347 }
58348 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58350 }
58351 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58353 }
58354 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58356 }
58357 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58359 }
58360 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58362 }
58363 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58365 }
58366 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58368 }
58369 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58371 }
58372 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58374 }
58375 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58377 }
58378 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58380 }
58381 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58383 }
58384 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58386 }
58387 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58389 }
58390 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) ((wxImageHandler *) x));
58392 }
58393 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58395 }
58396 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58398 }
58399 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) ((wxEvtHandler *) x));
58401 }
58402 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58404 }
58405 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58407 }
58408 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58410 }
58411 static void *_p_wxImageTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) ((wxImage *) x));
58413 }
58414 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58416 }
58417 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58419 }
58420 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58422 }
58423 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58425 }
58426 static void *_p_wxWindowTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58428 }
58429 static void *_p_wxMenuTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58431 }
58432 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58434 }
58435 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) ((wxFileSystem *) x));
58437 }
58438 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58440 }
58441 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58443 }
58444 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58446 }
58447 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58449 }
58450 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58452 }
58453 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58455 }
58456 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58458 }
58459 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58461 }
58462 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58464 }
58465 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58467 }
58468 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58470 }
58471 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58473 }
58474 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58476 }
58477 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58478 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58479 }
58480 static void *_p_wxControlTo_p_wxWindow(void *x) {
58481 return (void *)((wxWindow *) ((wxControl *) x));
58482 }
58483 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58484 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58485 }
58486 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58487 return (void *)((wxWindow *) ((wxMenuBar *) x));
58488 }
58489 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58490 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58491 }
58492 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58493 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58494 }
58495 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58496 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58497 }
58498 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58499 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58500 }
58501 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58502 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58503 }
58504 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58505 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58506 }
58507 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58508 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58509 }
58510 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58511 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58512 }
58513 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58514 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58515 }
58516 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58517 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58518 }
58519 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58520 return (void *)((wxValidator *) ((wxPyValidator *) x));
58521 }
58522 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58524 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};
58525 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58654 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58655 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58656
58657 static swig_type_info *swig_type_initial[] = {
58658 &_swigt__p_buffer,
58659 &_swigt__p_char,
58660 &_swigt__p_form_ops_t,
58661 &_swigt__p_int,
58662 &_swigt__p_long,
58663 &_swigt__p_unsigned_char,
58664 &_swigt__p_unsigned_int,
58665 &_swigt__p_unsigned_long,
58666 &_swigt__p_wxANIHandler,
58667 &_swigt__p_wxAcceleratorEntry,
58668 &_swigt__p_wxAcceleratorTable,
58669 &_swigt__p_wxActivateEvent,
58670 &_swigt__p_wxAppTraits,
58671 &_swigt__p_wxArrayString,
58672 &_swigt__p_wxBMPHandler,
58673 &_swigt__p_wxBitmap,
58674 &_swigt__p_wxBoxSizer,
58675 &_swigt__p_wxButton,
58676 &_swigt__p_wxCURHandler,
58677 &_swigt__p_wxCaret,
58678 &_swigt__p_wxChildFocusEvent,
58679 &_swigt__p_wxClipboardTextEvent,
58680 &_swigt__p_wxCloseEvent,
58681 &_swigt__p_wxColour,
58682 &_swigt__p_wxCommandEvent,
58683 &_swigt__p_wxContextMenuEvent,
58684 &_swigt__p_wxControl,
58685 &_swigt__p_wxControlWithItems,
58686 &_swigt__p_wxCursor,
58687 &_swigt__p_wxDC,
58688 &_swigt__p_wxDateEvent,
58689 &_swigt__p_wxDateTime,
58690 &_swigt__p_wxDisplayChangedEvent,
58691 &_swigt__p_wxDouble,
58692 &_swigt__p_wxDropFilesEvent,
58693 &_swigt__p_wxDuplexMode,
58694 &_swigt__p_wxEraseEvent,
58695 &_swigt__p_wxEvent,
58696 &_swigt__p_wxEventLoop,
58697 &_swigt__p_wxEventLoopActivator,
58698 &_swigt__p_wxEvtHandler,
58699 &_swigt__p_wxFSFile,
58700 &_swigt__p_wxFileSystem,
58701 &_swigt__p_wxFileSystemHandler,
58702 &_swigt__p_wxFlexGridSizer,
58703 &_swigt__p_wxFocusEvent,
58704 &_swigt__p_wxFont,
58705 &_swigt__p_wxFrame,
58706 &_swigt__p_wxGBPosition,
58707 &_swigt__p_wxGBSizerItem,
58708 &_swigt__p_wxGBSpan,
58709 &_swigt__p_wxGIFHandler,
58710 &_swigt__p_wxGridBagSizer,
58711 &_swigt__p_wxGridSizer,
58712 &_swigt__p_wxHelpEvent__Origin,
58713 &_swigt__p_wxICOHandler,
58714 &_swigt__p_wxIconizeEvent,
58715 &_swigt__p_wxIdleEvent,
58716 &_swigt__p_wxImage,
58717 &_swigt__p_wxImageHandler,
58718 &_swigt__p_wxImageHistogram,
58719 &_swigt__p_wxImage_HSVValue,
58720 &_swigt__p_wxImage_RGBValue,
58721 &_swigt__p_wxIndividualLayoutConstraint,
58722 &_swigt__p_wxInitDialogEvent,
58723 &_swigt__p_wxInputStream,
58724 &_swigt__p_wxInternetFSHandler,
58725 &_swigt__p_wxItemContainer,
58726 &_swigt__p_wxJPEGHandler,
58727 &_swigt__p_wxKeyEvent,
58728 &_swigt__p_wxLayoutConstraints,
58729 &_swigt__p_wxMaximizeEvent,
58730 &_swigt__p_wxMemoryFSHandler,
58731 &_swigt__p_wxMenu,
58732 &_swigt__p_wxMenuBar,
58733 &_swigt__p_wxMenuBarBase,
58734 &_swigt__p_wxMenuEvent,
58735 &_swigt__p_wxMenuItem,
58736 &_swigt__p_wxMouseCaptureChangedEvent,
58737 &_swigt__p_wxMouseCaptureLostEvent,
58738 &_swigt__p_wxMouseEvent,
58739 &_swigt__p_wxMoveEvent,
58740 &_swigt__p_wxNavigationKeyEvent,
58741 &_swigt__p_wxNcPaintEvent,
58742 &_swigt__p_wxNotifyEvent,
58743 &_swigt__p_wxObject,
58744 &_swigt__p_wxOutputStream,
58745 &_swigt__p_wxPCXHandler,
58746 &_swigt__p_wxPNGHandler,
58747 &_swigt__p_wxPNMHandler,
58748 &_swigt__p_wxPaintEvent,
58749 &_swigt__p_wxPaletteChangedEvent,
58750 &_swigt__p_wxPaperSize,
58751 &_swigt__p_wxPoint,
58752 &_swigt__p_wxPoint2D,
58753 &_swigt__p_wxPropagateOnce,
58754 &_swigt__p_wxPropagationDisabler,
58755 &_swigt__p_wxPyApp,
58756 &_swigt__p_wxPyCommandEvent,
58757 &_swigt__p_wxPyDropTarget,
58758 &_swigt__p_wxPyEvent,
58759 &_swigt__p_wxPyFileSystemHandler,
58760 &_swigt__p_wxPyImageHandler,
58761 &_swigt__p_wxPyInputStream,
58762 &_swigt__p_wxPySizer,
58763 &_swigt__p_wxPyValidator,
58764 &_swigt__p_wxQuantize,
58765 &_swigt__p_wxQueryNewPaletteEvent,
58766 &_swigt__p_wxRealPoint,
58767 &_swigt__p_wxRect,
58768 &_swigt__p_wxRect2D,
58769 &_swigt__p_wxRegion,
58770 &_swigt__p_wxScrollEvent,
58771 &_swigt__p_wxScrollWinEvent,
58772 &_swigt__p_wxSetCursorEvent,
58773 &_swigt__p_wxShowEvent,
58774 &_swigt__p_wxSize,
58775 &_swigt__p_wxSizeEvent,
58776 &_swigt__p_wxSizer,
58777 &_swigt__p_wxSizerItem,
58778 &_swigt__p_wxStaticBox,
58779 &_swigt__p_wxStaticBoxSizer,
58780 &_swigt__p_wxStdDialogButtonSizer,
58781 &_swigt__p_wxSysColourChangedEvent,
58782 &_swigt__p_wxTIFFHandler,
58783 &_swigt__p_wxToolTip,
58784 &_swigt__p_wxUpdateUIEvent,
58785 &_swigt__p_wxValidator,
58786 &_swigt__p_wxVisualAttributes,
58787 &_swigt__p_wxWindow,
58788 &_swigt__p_wxWindowCreateEvent,
58789 &_swigt__p_wxWindowDestroyEvent,
58790 &_swigt__p_wxXPMHandler,
58791 &_swigt__p_wxZipFSHandler,
58792 };
58793
58794 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58795 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58802 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58803 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58808 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}};
58809 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58810 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}};
58811 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58812 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}};
58813 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58818 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}};
58819 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58820 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}};
58821 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58831 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}};
58832 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58834 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}};
58835 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58837 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}};
58838 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}};
58839 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58847 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}};
58848 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58849 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}};
58850 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58853 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}};
58854 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58861 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}};
58862 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58865 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58879 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}};
58880 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58887 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58896 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58897 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58898 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58905 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58906 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58912 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}};
58913 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}};
58914 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58921 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}};
58922 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58923 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}};
58924 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58928
58929 static swig_cast_info *swig_cast_initial[] = {
58930 _swigc__p_buffer,
58931 _swigc__p_char,
58932 _swigc__p_form_ops_t,
58933 _swigc__p_int,
58934 _swigc__p_long,
58935 _swigc__p_unsigned_char,
58936 _swigc__p_unsigned_int,
58937 _swigc__p_unsigned_long,
58938 _swigc__p_wxANIHandler,
58939 _swigc__p_wxAcceleratorEntry,
58940 _swigc__p_wxAcceleratorTable,
58941 _swigc__p_wxActivateEvent,
58942 _swigc__p_wxAppTraits,
58943 _swigc__p_wxArrayString,
58944 _swigc__p_wxBMPHandler,
58945 _swigc__p_wxBitmap,
58946 _swigc__p_wxBoxSizer,
58947 _swigc__p_wxButton,
58948 _swigc__p_wxCURHandler,
58949 _swigc__p_wxCaret,
58950 _swigc__p_wxChildFocusEvent,
58951 _swigc__p_wxClipboardTextEvent,
58952 _swigc__p_wxCloseEvent,
58953 _swigc__p_wxColour,
58954 _swigc__p_wxCommandEvent,
58955 _swigc__p_wxContextMenuEvent,
58956 _swigc__p_wxControl,
58957 _swigc__p_wxControlWithItems,
58958 _swigc__p_wxCursor,
58959 _swigc__p_wxDC,
58960 _swigc__p_wxDateEvent,
58961 _swigc__p_wxDateTime,
58962 _swigc__p_wxDisplayChangedEvent,
58963 _swigc__p_wxDouble,
58964 _swigc__p_wxDropFilesEvent,
58965 _swigc__p_wxDuplexMode,
58966 _swigc__p_wxEraseEvent,
58967 _swigc__p_wxEvent,
58968 _swigc__p_wxEventLoop,
58969 _swigc__p_wxEventLoopActivator,
58970 _swigc__p_wxEvtHandler,
58971 _swigc__p_wxFSFile,
58972 _swigc__p_wxFileSystem,
58973 _swigc__p_wxFileSystemHandler,
58974 _swigc__p_wxFlexGridSizer,
58975 _swigc__p_wxFocusEvent,
58976 _swigc__p_wxFont,
58977 _swigc__p_wxFrame,
58978 _swigc__p_wxGBPosition,
58979 _swigc__p_wxGBSizerItem,
58980 _swigc__p_wxGBSpan,
58981 _swigc__p_wxGIFHandler,
58982 _swigc__p_wxGridBagSizer,
58983 _swigc__p_wxGridSizer,
58984 _swigc__p_wxHelpEvent__Origin,
58985 _swigc__p_wxICOHandler,
58986 _swigc__p_wxIconizeEvent,
58987 _swigc__p_wxIdleEvent,
58988 _swigc__p_wxImage,
58989 _swigc__p_wxImageHandler,
58990 _swigc__p_wxImageHistogram,
58991 _swigc__p_wxImage_HSVValue,
58992 _swigc__p_wxImage_RGBValue,
58993 _swigc__p_wxIndividualLayoutConstraint,
58994 _swigc__p_wxInitDialogEvent,
58995 _swigc__p_wxInputStream,
58996 _swigc__p_wxInternetFSHandler,
58997 _swigc__p_wxItemContainer,
58998 _swigc__p_wxJPEGHandler,
58999 _swigc__p_wxKeyEvent,
59000 _swigc__p_wxLayoutConstraints,
59001 _swigc__p_wxMaximizeEvent,
59002 _swigc__p_wxMemoryFSHandler,
59003 _swigc__p_wxMenu,
59004 _swigc__p_wxMenuBar,
59005 _swigc__p_wxMenuBarBase,
59006 _swigc__p_wxMenuEvent,
59007 _swigc__p_wxMenuItem,
59008 _swigc__p_wxMouseCaptureChangedEvent,
59009 _swigc__p_wxMouseCaptureLostEvent,
59010 _swigc__p_wxMouseEvent,
59011 _swigc__p_wxMoveEvent,
59012 _swigc__p_wxNavigationKeyEvent,
59013 _swigc__p_wxNcPaintEvent,
59014 _swigc__p_wxNotifyEvent,
59015 _swigc__p_wxObject,
59016 _swigc__p_wxOutputStream,
59017 _swigc__p_wxPCXHandler,
59018 _swigc__p_wxPNGHandler,
59019 _swigc__p_wxPNMHandler,
59020 _swigc__p_wxPaintEvent,
59021 _swigc__p_wxPaletteChangedEvent,
59022 _swigc__p_wxPaperSize,
59023 _swigc__p_wxPoint,
59024 _swigc__p_wxPoint2D,
59025 _swigc__p_wxPropagateOnce,
59026 _swigc__p_wxPropagationDisabler,
59027 _swigc__p_wxPyApp,
59028 _swigc__p_wxPyCommandEvent,
59029 _swigc__p_wxPyDropTarget,
59030 _swigc__p_wxPyEvent,
59031 _swigc__p_wxPyFileSystemHandler,
59032 _swigc__p_wxPyImageHandler,
59033 _swigc__p_wxPyInputStream,
59034 _swigc__p_wxPySizer,
59035 _swigc__p_wxPyValidator,
59036 _swigc__p_wxQuantize,
59037 _swigc__p_wxQueryNewPaletteEvent,
59038 _swigc__p_wxRealPoint,
59039 _swigc__p_wxRect,
59040 _swigc__p_wxRect2D,
59041 _swigc__p_wxRegion,
59042 _swigc__p_wxScrollEvent,
59043 _swigc__p_wxScrollWinEvent,
59044 _swigc__p_wxSetCursorEvent,
59045 _swigc__p_wxShowEvent,
59046 _swigc__p_wxSize,
59047 _swigc__p_wxSizeEvent,
59048 _swigc__p_wxSizer,
59049 _swigc__p_wxSizerItem,
59050 _swigc__p_wxStaticBox,
59051 _swigc__p_wxStaticBoxSizer,
59052 _swigc__p_wxStdDialogButtonSizer,
59053 _swigc__p_wxSysColourChangedEvent,
59054 _swigc__p_wxTIFFHandler,
59055 _swigc__p_wxToolTip,
59056 _swigc__p_wxUpdateUIEvent,
59057 _swigc__p_wxValidator,
59058 _swigc__p_wxVisualAttributes,
59059 _swigc__p_wxWindow,
59060 _swigc__p_wxWindowCreateEvent,
59061 _swigc__p_wxWindowDestroyEvent,
59062 _swigc__p_wxXPMHandler,
59063 _swigc__p_wxZipFSHandler,
59064 };
59065
59066
59067 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59068
59069 static swig_const_info swig_const_table[] = {
59070 {0, 0, 0, 0.0, 0, 0}};
59071
59072 #ifdef __cplusplus
59073 }
59074 #endif
59075 /* -----------------------------------------------------------------------------
59076 * Type initialization:
59077 * This problem is tough by the requirement that no dynamic
59078 * memory is used. Also, since swig_type_info structures store pointers to
59079 * swig_cast_info structures and swig_cast_info structures store pointers back
59080 * to swig_type_info structures, we need some lookup code at initialization.
59081 * The idea is that swig generates all the structures that are needed.
59082 * The runtime then collects these partially filled structures.
59083 * The SWIG_InitializeModule function takes these initial arrays out of
59084 * swig_module, and does all the lookup, filling in the swig_module.types
59085 * array with the correct data and linking the correct swig_cast_info
59086 * structures together.
59087 *
59088 * The generated swig_type_info structures are assigned staticly to an initial
59089 * array. We just loop though that array, and handle each type individually.
59090 * First we lookup if this type has been already loaded, and if so, use the
59091 * loaded structure instead of the generated one. Then we have to fill in the
59092 * cast linked list. The cast data is initially stored in something like a
59093 * two-dimensional array. Each row corresponds to a type (there are the same
59094 * number of rows as there are in the swig_type_initial array). Each entry in
59095 * a column is one of the swig_cast_info structures for that type.
59096 * The cast_initial array is actually an array of arrays, because each row has
59097 * a variable number of columns. So to actually build the cast linked list,
59098 * we find the array of casts associated with the type, and loop through it
59099 * adding the casts to the list. The one last trick we need to do is making
59100 * sure the type pointer in the swig_cast_info struct is correct.
59101 *
59102 * First off, we lookup the cast->type name to see if it is already loaded.
59103 * There are three cases to handle:
59104 * 1) If the cast->type has already been loaded AND the type we are adding
59105 * casting info to has not been loaded (it is in this module), THEN we
59106 * replace the cast->type pointer with the type pointer that has already
59107 * been loaded.
59108 * 2) If BOTH types (the one we are adding casting info to, and the
59109 * cast->type) are loaded, THEN the cast info has already been loaded by
59110 * the previous module so we just ignore it.
59111 * 3) Finally, if cast->type has not already been loaded, then we add that
59112 * swig_cast_info to the linked list (because the cast->type) pointer will
59113 * be correct.
59114 * ----------------------------------------------------------------------------- */
59115
59116 #ifdef __cplusplus
59117 extern "C" {
59118 #if 0
59119 } /* c-mode */
59120 #endif
59121 #endif
59122
59123 #if 0
59124 #define SWIGRUNTIME_DEBUG
59125 #endif
59126
59127 SWIGRUNTIME void
59128 SWIG_InitializeModule(void *clientdata) {
59129 size_t i;
59130 swig_module_info *module_head;
59131 static int init_run = 0;
59132
59133 clientdata = clientdata;
59134
59135 if (init_run) return;
59136 init_run = 1;
59137
59138 /* Initialize the swig_module */
59139 swig_module.type_initial = swig_type_initial;
59140 swig_module.cast_initial = swig_cast_initial;
59141
59142 /* Try and load any already created modules */
59143 module_head = SWIG_GetModule(clientdata);
59144 if (module_head) {
59145 swig_module.next = module_head->next;
59146 module_head->next = &swig_module;
59147 } else {
59148 /* This is the first module loaded */
59149 swig_module.next = &swig_module;
59150 SWIG_SetModule(clientdata, &swig_module);
59151 }
59152
59153 /* Now work on filling in swig_module.types */
59154 #ifdef SWIGRUNTIME_DEBUG
59155 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59156 #endif
59157 for (i = 0; i < swig_module.size; ++i) {
59158 swig_type_info *type = 0;
59159 swig_type_info *ret;
59160 swig_cast_info *cast;
59161
59162 #ifdef SWIGRUNTIME_DEBUG
59163 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59164 #endif
59165
59166 /* if there is another module already loaded */
59167 if (swig_module.next != &swig_module) {
59168 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59169 }
59170 if (type) {
59171 /* Overwrite clientdata field */
59172 #ifdef SWIGRUNTIME_DEBUG
59173 printf("SWIG_InitializeModule: found type %s\n", type->name);
59174 #endif
59175 if (swig_module.type_initial[i]->clientdata) {
59176 type->clientdata = swig_module.type_initial[i]->clientdata;
59177 #ifdef SWIGRUNTIME_DEBUG
59178 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59179 #endif
59180 }
59181 } else {
59182 type = swig_module.type_initial[i];
59183 }
59184
59185 /* Insert casting types */
59186 cast = swig_module.cast_initial[i];
59187 while (cast->type) {
59188 /* Don't need to add information already in the list */
59189 ret = 0;
59190 #ifdef SWIGRUNTIME_DEBUG
59191 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59192 #endif
59193 if (swig_module.next != &swig_module) {
59194 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59195 #ifdef SWIGRUNTIME_DEBUG
59196 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59197 #endif
59198 }
59199 if (ret) {
59200 if (type == swig_module.type_initial[i]) {
59201 #ifdef SWIGRUNTIME_DEBUG
59202 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59203 #endif
59204 cast->type = ret;
59205 ret = 0;
59206 } else {
59207 /* Check for casting already in the list */
59208 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59209 #ifdef SWIGRUNTIME_DEBUG
59210 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59211 #endif
59212 if (!ocast) ret = 0;
59213 }
59214 }
59215
59216 if (!ret) {
59217 #ifdef SWIGRUNTIME_DEBUG
59218 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59219 #endif
59220 if (type->cast) {
59221 type->cast->prev = cast;
59222 cast->next = type->cast;
59223 }
59224 type->cast = cast;
59225 }
59226 cast++;
59227 }
59228 /* Set entry in modules->types array equal to the type */
59229 swig_module.types[i] = type;
59230 }
59231 swig_module.types[i] = 0;
59232
59233 #ifdef SWIGRUNTIME_DEBUG
59234 printf("**** SWIG_InitializeModule: Cast List ******\n");
59235 for (i = 0; i < swig_module.size; ++i) {
59236 int j = 0;
59237 swig_cast_info *cast = swig_module.cast_initial[i];
59238 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59239 while (cast->type) {
59240 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59241 cast++;
59242 ++j;
59243 }
59244 printf("---- Total casts: %d\n",j);
59245 }
59246 printf("**** SWIG_InitializeModule: Cast List ******\n");
59247 #endif
59248 }
59249
59250 /* This function will propagate the clientdata field of type to
59251 * any new swig_type_info structures that have been added into the list
59252 * of equivalent types. It is like calling
59253 * SWIG_TypeClientData(type, clientdata) a second time.
59254 */
59255 SWIGRUNTIME void
59256 SWIG_PropagateClientData(void) {
59257 size_t i;
59258 swig_cast_info *equiv;
59259 static int init_run = 0;
59260
59261 if (init_run) return;
59262 init_run = 1;
59263
59264 for (i = 0; i < swig_module.size; i++) {
59265 if (swig_module.types[i]->clientdata) {
59266 equiv = swig_module.types[i]->cast;
59267 while (equiv) {
59268 if (!equiv->converter) {
59269 if (equiv->type && !equiv->type->clientdata)
59270 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59271 }
59272 equiv = equiv->next;
59273 }
59274 }
59275 }
59276 }
59277
59278 #ifdef __cplusplus
59279 #if 0
59280 {
59281 /* c-mode */
59282 #endif
59283 }
59284 #endif
59285
59286
59287
59288 #ifdef __cplusplus
59289 extern "C" {
59290 #endif
59291
59292 /* Python-specific SWIG API */
59293 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59294 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59295 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59296
59297 /* -----------------------------------------------------------------------------
59298 * global variable support code.
59299 * ----------------------------------------------------------------------------- */
59300
59301 typedef struct swig_globalvar {
59302 char *name; /* Name of global variable */
59303 PyObject *(*get_attr)(void); /* Return the current value */
59304 int (*set_attr)(PyObject *); /* Set the value */
59305 struct swig_globalvar *next;
59306 } swig_globalvar;
59307
59308 typedef struct swig_varlinkobject {
59309 PyObject_HEAD
59310 swig_globalvar *vars;
59311 } swig_varlinkobject;
59312
59313 SWIGINTERN PyObject *
59314 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59315 return PyString_FromString("<Swig global variables>");
59316 }
59317
59318 SWIGINTERN PyObject *
59319 swig_varlink_str(swig_varlinkobject *v) {
59320 PyObject *str = PyString_FromString("(");
59321 swig_globalvar *var;
59322 for (var = v->vars; var; var=var->next) {
59323 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59324 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59325 }
59326 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59327 return str;
59328 }
59329
59330 SWIGINTERN int
59331 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59332 PyObject *str = swig_varlink_str(v);
59333 fprintf(fp,"Swig global variables ");
59334 fprintf(fp,"%s\n", PyString_AsString(str));
59335 Py_DECREF(str);
59336 return 0;
59337 }
59338
59339 SWIGINTERN void
59340 swig_varlink_dealloc(swig_varlinkobject *v) {
59341 swig_globalvar *var = v->vars;
59342 while (var) {
59343 swig_globalvar *n = var->next;
59344 free(var->name);
59345 free(var);
59346 var = n;
59347 }
59348 }
59349
59350 SWIGINTERN PyObject *
59351 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59352 PyObject *res = NULL;
59353 swig_globalvar *var = v->vars;
59354 while (var) {
59355 if (strcmp(var->name,n) == 0) {
59356 res = (*var->get_attr)();
59357 break;
59358 }
59359 var = var->next;
59360 }
59361 if (res == NULL && !PyErr_Occurred()) {
59362 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59363 }
59364 return res;
59365 }
59366
59367 SWIGINTERN int
59368 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59369 int res = 1;
59370 swig_globalvar *var = v->vars;
59371 while (var) {
59372 if (strcmp(var->name,n) == 0) {
59373 res = (*var->set_attr)(p);
59374 break;
59375 }
59376 var = var->next;
59377 }
59378 if (res == 1 && !PyErr_Occurred()) {
59379 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59380 }
59381 return res;
59382 }
59383
59384 SWIGINTERN PyTypeObject*
59385 swig_varlink_type(void) {
59386 static char varlink__doc__[] = "Swig var link object";
59387 static PyTypeObject varlink_type;
59388 static int type_init = 0;
59389 if (!type_init) {
59390 const PyTypeObject tmp
59391 = {
59392 PyObject_HEAD_INIT(NULL)
59393 0, /* Number of items in variable part (ob_size) */
59394 (char *)"swigvarlink", /* Type name (tp_name) */
59395 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59396 0, /* Itemsize (tp_itemsize) */
59397 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59398 (printfunc) swig_varlink_print, /* Print (tp_print) */
59399 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59400 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59401 0, /* tp_compare */
59402 (reprfunc) swig_varlink_repr, /* tp_repr */
59403 0, /* tp_as_number */
59404 0, /* tp_as_sequence */
59405 0, /* tp_as_mapping */
59406 0, /* tp_hash */
59407 0, /* tp_call */
59408 (reprfunc)swig_varlink_str, /* tp_str */
59409 0, /* tp_getattro */
59410 0, /* tp_setattro */
59411 0, /* tp_as_buffer */
59412 0, /* tp_flags */
59413 varlink__doc__, /* tp_doc */
59414 0, /* tp_traverse */
59415 0, /* tp_clear */
59416 0, /* tp_richcompare */
59417 0, /* tp_weaklistoffset */
59418 #if PY_VERSION_HEX >= 0x02020000
59419 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59420 #endif
59421 #if PY_VERSION_HEX >= 0x02030000
59422 0, /* tp_del */
59423 #endif
59424 #ifdef COUNT_ALLOCS
59425 0,0,0,0 /* tp_alloc -> tp_next */
59426 #endif
59427 };
59428 varlink_type = tmp;
59429 varlink_type.ob_type = &PyType_Type;
59430 type_init = 1;
59431 }
59432 return &varlink_type;
59433 }
59434
59435 /* Create a variable linking object for use later */
59436 SWIGINTERN PyObject *
59437 SWIG_Python_newvarlink(void) {
59438 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59439 if (result) {
59440 result->vars = 0;
59441 }
59442 return ((PyObject*) result);
59443 }
59444
59445 SWIGINTERN void
59446 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59447 swig_varlinkobject *v = (swig_varlinkobject *) p;
59448 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59449 if (gv) {
59450 size_t size = strlen(name)+1;
59451 gv->name = (char *)malloc(size);
59452 if (gv->name) {
59453 strncpy(gv->name,name,size);
59454 gv->get_attr = get_attr;
59455 gv->set_attr = set_attr;
59456 gv->next = v->vars;
59457 }
59458 }
59459 v->vars = gv;
59460 }
59461
59462 SWIGINTERN PyObject *
59463 SWIG_globals() {
59464 static PyObject *_SWIG_globals = 0;
59465 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59466 return _SWIG_globals;
59467 }
59468
59469 /* -----------------------------------------------------------------------------
59470 * constants/methods manipulation
59471 * ----------------------------------------------------------------------------- */
59472
59473 /* Install Constants */
59474 SWIGINTERN void
59475 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59476 PyObject *obj = 0;
59477 size_t i;
59478 for (i = 0; constants[i].type; ++i) {
59479 switch(constants[i].type) {
59480 case SWIG_PY_POINTER:
59481 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59482 break;
59483 case SWIG_PY_BINARY:
59484 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59485 break;
59486 default:
59487 obj = 0;
59488 break;
59489 }
59490 if (obj) {
59491 PyDict_SetItemString(d, constants[i].name, obj);
59492 Py_DECREF(obj);
59493 }
59494 }
59495 }
59496
59497 /* -----------------------------------------------------------------------------*/
59498 /* Fix SwigMethods to carry the callback ptrs when needed */
59499 /* -----------------------------------------------------------------------------*/
59500
59501 SWIGINTERN void
59502 SWIG_Python_FixMethods(PyMethodDef *methods,
59503 swig_const_info *const_table,
59504 swig_type_info **types,
59505 swig_type_info **types_initial) {
59506 size_t i;
59507 for (i = 0; methods[i].ml_name; ++i) {
59508 const char *c = methods[i].ml_doc;
59509 if (c && (c = strstr(c, "swig_ptr: "))) {
59510 int j;
59511 swig_const_info *ci = 0;
59512 const char *name = c + 10;
59513 for (j = 0; const_table[j].type; ++j) {
59514 if (strncmp(const_table[j].name, name,
59515 strlen(const_table[j].name)) == 0) {
59516 ci = &(const_table[j]);
59517 break;
59518 }
59519 }
59520 if (ci) {
59521 size_t shift = (ci->ptype) - types;
59522 swig_type_info *ty = types_initial[shift];
59523 size_t ldoc = (c - methods[i].ml_doc);
59524 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59525 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59526 if (ndoc) {
59527 char *buff = ndoc;
59528 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59529 if (ptr) {
59530 strncpy(buff, methods[i].ml_doc, ldoc);
59531 buff += ldoc;
59532 strncpy(buff, "swig_ptr: ", 10);
59533 buff += 10;
59534 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59535 methods[i].ml_doc = ndoc;
59536 }
59537 }
59538 }
59539 }
59540 }
59541 }
59542
59543 #ifdef __cplusplus
59544 }
59545 #endif
59546
59547 /* -----------------------------------------------------------------------------*
59548 * Partial Init method
59549 * -----------------------------------------------------------------------------*/
59550
59551 #ifdef __cplusplus
59552 extern "C"
59553 #endif
59554 SWIGEXPORT void SWIG_init(void) {
59555 PyObject *m, *d;
59556
59557 /* Fix SwigMethods to carry the callback ptrs when needed */
59558 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59559
59560 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59561 d = PyModule_GetDict(m);
59562
59563 SWIG_InitializeModule(0);
59564 SWIG_InstallConstants(d,swig_const_table);
59565
59566
59567
59568 #ifndef wxPyUSE_EXPORT
59569 // Make our API structure a CObject so other modules can import it
59570 // from this module.
59571 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59572 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59573 Py_XDECREF(cobj);
59574 #endif
59575
59576 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59577 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59578 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59579 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59580 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59581 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59582 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59583 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59584 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59585 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59586 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59587 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59588 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59589 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59590 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59591 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59592 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59593 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59594 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59595 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59596 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59597 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59598 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59599 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59600 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59601 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59602 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59603 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59604 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59605 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59606 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59607 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59608 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59609 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59610 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59611 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59612 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59613 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59614 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59615 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59616 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59617 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59618 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59619 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59620 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59621 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59622 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59623 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59624 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59625 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59626 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59627 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59628 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59629 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59630 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59631 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59632 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59633 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59634 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59635 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59636 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59637 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59638 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59639 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59640 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59641 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59642 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59643 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59644 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59645 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59646 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59647 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59648 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59649 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59650 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59651 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59652 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59653 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59654 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59655 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59656 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59657 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59658 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59659 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59660 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59661 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59662 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59663 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59664 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59665 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59666 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59667 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59668 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59669 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59670 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59671 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59672 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59673 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59674 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59675 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59676 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59677 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59678 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59679 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59680 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59681 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59682 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59683 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59684 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59685 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59686 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59687 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59688 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59689 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59690 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59691 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59692 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59693 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59694 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59695 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59696 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59697 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59698 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59699 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59700 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59701 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59702 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59703 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59704 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59705 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59706 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59707 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59708 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59709 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59710 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59711 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59712 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59713 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59714 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59715 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59716 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59717 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59718 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59719 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59720 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59721 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59722 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59723 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59724 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59725 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59726 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59727 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59728 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59729 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59730 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59731 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59732 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59733 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59734 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59735 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59736 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59737 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59738 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59739 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59740 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59741 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59742 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59743 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59744 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59745 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59746 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59747 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59748 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59749 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59750 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59751 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59752 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59753 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59754 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59755 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59756 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59757 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59758 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59759 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59760 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59761 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59762 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59763 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59764 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59765 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59766 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59767 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59768 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59769 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59770 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59771 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59772 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59773 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59774 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59775 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59776 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59777 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59778 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59779 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59780 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59781 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59782 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59783 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59784 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59785 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59786 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59787 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59788 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59789 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59790 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59791 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59792 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59793 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59794 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59795 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59796 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59797 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59798 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59799 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59800 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59801 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59802 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59803 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59804 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59805 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59806 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59807 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59808 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59809 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59810 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59811 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59812 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59813 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59814 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59815 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59816 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59817 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59818 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59819 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59820 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59821 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59822 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59823 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59824 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59825 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59826 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59827 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59828 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59829 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59830 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59831 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59832 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59833 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59834 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59835 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59836 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59837 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59838 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59839 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59840 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59841 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59842 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59843 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59844 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59845 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59846 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59847 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59848 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59849 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59850 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59851 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59852 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59853 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59854 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59855 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59856 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59857 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59858 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59859 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59860 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59861 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59862 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59863 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59864 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59865 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59866 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59867 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59868 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59869 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59870 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59871 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59872 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59873 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59874 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59875 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59876 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59877 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59878 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59879 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59880 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59881 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59882 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59883 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59884 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59885 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59886 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59887 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59888 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59889 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59890 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59891 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59892 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59893 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59894 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59895 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59896 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59897 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59898 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59899 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59900 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59901 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59902 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59903 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59904 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59905 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59906 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59907 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59908 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59909 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59910 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59911 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59912 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59913 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59914 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59915 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59916 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59917 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59918 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59919 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59920 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59921 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59922 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59923 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59924 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59925 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59926 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59927 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59928 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59929 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59930 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59931 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59932 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59933 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59934 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59935 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59936 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59937 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59938 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59939 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59940 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59941 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59942 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59943 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59944 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59945 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59946 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59947 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59948 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59949 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59950 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59951 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59952 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59953 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59954 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59955 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59956 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59957 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59958 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59959 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59960 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59961 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59962 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59963 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59964 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59965 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59966 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59967 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59968 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59969 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59986 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59997 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59998 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59999 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60000 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60001 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60002 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60003 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60004 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60005 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60006 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60007 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60008 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60009 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60010 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60011 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60012 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60013 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60014 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60015 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60016 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60017 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60018 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60019 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60020 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60021 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60022 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60023 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60024 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60025 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60026 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60027 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60028 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60029 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60030 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60031 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60032 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60033 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60034 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60035 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60036 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60037 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60038 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60039 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60040 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60041 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60042 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60043 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60044 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60045 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60046 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60047 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60048 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60049 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60050 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60051 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60052 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60053 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60054 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60055 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60056 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60057 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60058 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60059 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60060 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60061 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60062 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60063 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60064 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60065 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60066 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60067 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60068 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60069 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60070 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60071 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60072 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60073 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60074 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60075 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60076 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60077 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60078 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60079 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60080 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60081 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60082 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60083 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60084 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60085 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60086 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60087 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60088 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60089 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60090 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60091 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60092 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60093 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60094 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60095 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60096 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60097 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60098 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60099 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60100 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60101 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60102 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60103 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60104 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60105 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60106 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60107 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60108 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60109 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60110 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60111 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60112 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60113 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60114 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60115 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60116 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60117 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60118 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60119 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60120 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60121 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60122 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60123 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60124 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60125 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60126 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60127 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60128 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60129 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60130 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60131 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60132 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60133 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60134 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60135 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60136 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60137 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60138 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60139 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60140 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60141 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60142 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60143 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60144 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60145 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60146 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60147 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60148 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60149 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60150 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60151 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60152 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60153 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60154 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60155 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60156 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60157 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60158 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60159 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60160 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60161 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60162 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60163 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60164 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60165 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60166 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60167 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60168 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60169 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60170 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60171 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60172 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60173 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60174 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60175 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60176 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60177 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60178 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60179 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60180 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60181 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60183 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60184 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60189 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60190 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60191 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60192 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60193 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60200 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60201 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60202 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60203 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60204 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60205 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60206 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60207 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60208 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60209 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60210 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60211 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60212 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60213 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60214 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60215 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60216 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60217 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60218 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60219 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60220 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60221 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60222 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60223 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60224 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60225 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60226 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60227 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60228 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60229 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60230 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60231 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60232 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60233 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60234 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60235 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60236 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60237 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60238 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60239 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60240 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60241
60242 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60243
60244
60245 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60246
60247 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60248 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60249 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60250 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60251 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60252 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60258 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60259 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60260 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60261 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60262 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60263 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60264 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60265 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60266 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60267 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60268 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60269 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60270 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60271 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60272 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60273 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60274 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60275 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60276 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60277 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60278 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60279 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60280 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60281 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60282 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60283 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60284 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60285 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60286 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60287 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60288 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60289 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60290 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60291 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60292 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60293 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60294 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60295 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60296 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60297 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60298 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60299 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60300 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60301 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60302 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60303 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60304 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60305 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60306 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60307 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60308 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60309 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60310 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60311 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60312 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60313 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60314 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60315 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60316 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60317 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60318 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60319 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60320 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60321 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60322 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60323 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60324 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60325 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60326 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60327 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60328 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60329 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60330 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60331 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60332 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60333 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60334 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60335 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60336 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60337 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60338 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60339 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60340 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60341 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60342 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60343 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60344 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60345 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60346 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60347 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60348 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60349 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60355 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60356 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60357 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60358 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60359 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60360 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60361 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60362 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60363 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60364 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60365 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60366 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60367 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60368 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60369 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60370 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60371 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60372 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60373 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60374 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60375 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60376 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60377 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60378 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60379 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60380 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60381 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60382 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60383 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60384 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60385 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60386 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60387 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60388 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60389 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60390 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60391 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60392 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60393 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60394 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60395 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60396 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60397 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60398 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60399 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60400 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60401 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60402 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60403 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60404 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60405 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60406 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60407 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60408 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60409 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60410 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60411 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60412 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60413 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60414 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60415 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60416 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60417 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60418 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60419 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60420 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60421 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60422 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60423 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60424 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60425 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60426 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60427 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60428 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60429 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60430 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60431 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60432 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60433 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60434 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60435 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60436 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60437 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60438 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60439 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60440 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60441 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60442 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60443 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60444 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60445 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60446 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60447 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60448 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60449 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60450 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60451 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60452 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60453 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60454 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60455 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60456 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60457 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60458 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60459 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60460 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60461
60462 // Initialize threading, some globals and such
60463 __wxPyPreStart(d);
60464
60465
60466 // Although these are defined in __version__ they need to be here too so
60467 // that an assert can be done to ensure that the wxPython and the wxWindows
60468 // versions match.
60469 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60470 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60471 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60472
60473 }
60474
wxWidgets (Impactor)