]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Forward declare new wxPy classes
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPosition swig_types[96]
2563 #define SWIGTYPE_p_wxPropagateOnce swig_types[97]
2564 #define SWIGTYPE_p_wxPropagationDisabler swig_types[98]
2565 #define SWIGTYPE_p_wxPyApp swig_types[99]
2566 #define SWIGTYPE_p_wxPyCommandEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyDropTarget swig_types[101]
2568 #define SWIGTYPE_p_wxPyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyImageHandler swig_types[104]
2571 #define SWIGTYPE_p_wxPyInputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPySizer swig_types[106]
2573 #define SWIGTYPE_p_wxPyValidator swig_types[107]
2574 #define SWIGTYPE_p_wxQuantize swig_types[108]
2575 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[109]
2576 #define SWIGTYPE_p_wxRealPoint swig_types[110]
2577 #define SWIGTYPE_p_wxRect swig_types[111]
2578 #define SWIGTYPE_p_wxRect2D swig_types[112]
2579 #define SWIGTYPE_p_wxRegion swig_types[113]
2580 #define SWIGTYPE_p_wxScrollEvent swig_types[114]
2581 #define SWIGTYPE_p_wxScrollWinEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSetCursorEvent swig_types[116]
2583 #define SWIGTYPE_p_wxShowEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSize swig_types[118]
2585 #define SWIGTYPE_p_wxSizeEvent swig_types[119]
2586 #define SWIGTYPE_p_wxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSizerFlags swig_types[121]
2588 #define SWIGTYPE_p_wxSizerItem swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBox swig_types[123]
2590 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[124]
2591 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[125]
2592 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[126]
2593 #define SWIGTYPE_p_wxTGAHandler swig_types[127]
2594 #define SWIGTYPE_p_wxTIFFHandler swig_types[128]
2595 #define SWIGTYPE_p_wxToolTip swig_types[129]
2596 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[130]
2597 #define SWIGTYPE_p_wxValidator swig_types[131]
2598 #define SWIGTYPE_p_wxVisualAttributes swig_types[132]
2599 #define SWIGTYPE_p_wxWindow swig_types[133]
2600 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[134]
2601 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[135]
2602 #define SWIGTYPE_p_wxXPMHandler swig_types[136]
2603 #define SWIGTYPE_p_wxZipFSHandler swig_types[137]
2604 static swig_type_info *swig_types[139];
2605 static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
2606 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2607 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2608
2609 /* -------- TYPES TABLE (END) -------- */
2610
2611 #if (PY_VERSION_HEX <= 0x02000000)
2612 # if !defined(SWIG_PYTHON_CLASSIC)
2613 # error "This python version requires to use swig with the '-classic' option"
2614 # endif
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodern' option"
2618 #endif
2619 #if (PY_VERSION_HEX <= 0x02020000)
2620 # error "This python version requires to use swig with the '-nomodernargs' option"
2621 #endif
2622 #ifndef METH_O
2623 # error "This python version requires to use swig with the '-nofastunpack' option"
2624 #endif
2625
2626 /*-----------------------------------------------
2627 @(target):= _core_.so
2628 ------------------------------------------------*/
2629 #define SWIG_init init_core_
2630
2631 #define SWIG_name "_core_"
2632
2633 #define SWIGVERSION 0x010329
2634
2635
2636 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2637 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2638
2639
2640 #include <stdexcept>
2641
2642
2643 namespace swig {
2644 class PyObject_ptr {
2645 protected:
2646 PyObject *_obj;
2647
2648 public:
2649 PyObject_ptr() :_obj(0)
2650 {
2651 }
2652
2653 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2654 {
2655 Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2659 {
2660 if (initial_ref) Py_XINCREF(_obj);
2661 }
2662
2663 PyObject_ptr & operator=(const PyObject_ptr& item)
2664 {
2665 Py_XINCREF(item._obj);
2666 Py_XDECREF(_obj);
2667 _obj = item._obj;
2668 return *this;
2669 }
2670
2671 ~PyObject_ptr()
2672 {
2673 Py_XDECREF(_obj);
2674 }
2675
2676 operator PyObject *() const
2677 {
2678 return _obj;
2679 }
2680
2681 PyObject *operator->() const
2682 {
2683 return _obj;
2684 }
2685 };
2686 }
2687
2688
2689 namespace swig {
2690 struct PyObject_var : PyObject_ptr {
2691 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2692
2693 PyObject_var & operator = (PyObject* obj)
2694 {
2695 Py_XDECREF(_obj);
2696 _obj = obj;
2697 return *this;
2698 }
2699 };
2700 }
2701
2702
2703 #include "wx/wxPython/wxPython_int.h"
2704 #include "wx/wxPython/pyclasses.h"
2705 #include "wx/wxPython/twoitem.h"
2706
2707
2708 #ifndef wxPyUSE_EXPORT
2709 // Helper functions for dealing with SWIG objects and such. These are
2710 // located here so they know about the SWIG types and functions declared
2711 // in the wrapper code.
2712
2713 #include <wx/hashmap.h>
2714 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2715
2716
2717 // Maintains a hashmap of className to swig_type_info pointers. Given the
2718 // name of a class either looks up the type info in the cache, or scans the
2719 // SWIG tables for it.
2720 extern PyObject* wxPyPtrTypeMap;
2721 static
2722 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2723
2724 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2725
2726 if (typeInfoCache == NULL)
2727 typeInfoCache = new wxPyTypeInfoHashMap;
2728
2729 wxString name(className);
2730 swig_type_info* swigType = (*typeInfoCache)[name];
2731
2732 if (! swigType) {
2733 // it wasn't in the cache, so look it up from SWIG
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736
2737 // if it still wasn't found, try looking for a mapped name
2738 if (!swigType) {
2739 PyObject* item;
2740 name = className;
2741
2742 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2743 (char*)(const char*)name.mbc_str())) != NULL) {
2744 name = wxString(PyString_AsString(item), *wxConvCurrent);
2745 name.Append(wxT(" *"));
2746 swigType = SWIG_TypeQuery(name.mb_str());
2747 }
2748 }
2749 if (swigType) {
2750 // and add it to the map if found
2751 (*typeInfoCache)[className] = swigType;
2752 }
2753 }
2754 return swigType;
2755 }
2756
2757
2758 // Check if a class name is a type known to SWIG
2759 bool wxPyCheckSwigType(const wxChar* className) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 return swigType != NULL;
2763 }
2764
2765
2766 // Given a pointer to a C++ object and a class name, construct a Python proxy
2767 // object for it.
2768 PyObject* wxPyConstructObject(void* ptr,
2769 const wxChar* className,
2770 int setThisOwn) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2774
2775 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2776 }
2777
2778
2779 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2780 // Ensures that the proxy object is of the specified (or derived) type. If
2781 // not able to perform the conversion then a Python exception is set and the
2782 // error should be handled properly in the caller. Returns True on success.
2783 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2784 const wxChar* className) {
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2788
2789 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2790 }
2791
2792
2793
2794 // Make a SWIGified pointer object suitable for a .this attribute
2795 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2796
2797 PyObject* robj = NULL;
2798
2799 swig_type_info* swigType = wxPyFindSwigType(className);
2800 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2801
2802 robj = PySwigObject_New(ptr, swigType, 0);
2803 return robj;
2804 }
2805
2806
2807 // Python's PyInstance_Check does not return True for instances of new-style
2808 // classes. This should get close enough for both new and old classes but I
2809 // should re-evaluate the need for doing instance checks...
2810 bool wxPyInstance_Check(PyObject* obj) {
2811 return PyObject_HasAttrString(obj, "__class__") != 0;
2812 }
2813
2814
2815 // This one checks if the object is an instance of a SWIG proxy class (it has
2816 // a .this attribute, and the .this attribute is a PySwigObject.)
2817 bool wxPySwigInstance_Check(PyObject* obj) {
2818 static PyObject* this_str = NULL;
2819 if (this_str == NULL)
2820 this_str = PyString_FromString("this");
2821
2822 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2823 if (this_attr) {
2824 bool retval = (PySwigObject_Check(this_attr) != 0);
2825 Py_DECREF(this_attr);
2826 return retval;
2827 }
2828
2829 PyErr_Clear();
2830 return false;
2831 }
2832
2833
2834 // Export a C API in a struct. Other modules will be able to load this from
2835 // the wx._core_ module and will then have safe access to these functions,
2836 // even if they are located in another shared library.
2837 static wxPyCoreAPI API = {
2838
2839 wxPyCheckSwigType,
2840 wxPyConstructObject,
2841 wxPyConvertSwigPtr,
2842 wxPyMakeSwigPtr,
2843
2844 wxPyBeginAllowThreads,
2845 wxPyEndAllowThreads,
2846 wxPyBeginBlockThreads,
2847 wxPyEndBlockThreads,
2848
2849 wxPy_ConvertList,
2850
2851 wxString_in_helper,
2852 Py2wxString,
2853 wx2PyString,
2854
2855 byte_LIST_helper,
2856 int_LIST_helper,
2857 long_LIST_helper,
2858 string_LIST_helper,
2859 wxPoint_LIST_helper,
2860 wxBitmap_LIST_helper,
2861 wxString_LIST_helper,
2862 wxAcceleratorEntry_LIST_helper,
2863
2864 wxSize_helper,
2865 wxPoint_helper,
2866 wxRealPoint_helper,
2867 wxRect_helper,
2868 wxColour_helper,
2869 wxPoint2D_helper,
2870
2871 wxPySimple_typecheck,
2872 wxColour_typecheck,
2873
2874 wxPyCBH_setCallbackInfo,
2875 wxPyCBH_findCallback,
2876 wxPyCBH_callCallback,
2877 wxPyCBH_callCallbackObj,
2878 wxPyCBH_delete,
2879
2880 wxPyMake_wxObject,
2881 wxPyMake_wxSizer,
2882 wxPyPtrTypeMap_Add,
2883 wxPy2int_seq_helper,
2884 wxPy4int_seq_helper,
2885 wxArrayString2PyList_helper,
2886 wxArrayInt2PyList_helper,
2887
2888 wxPyClientData_dtor,
2889 wxPyUserData_dtor,
2890 wxPyOORClientData_dtor,
2891
2892 wxPyCBInputStream_create,
2893 wxPyCBInputStream_copy,
2894
2895 wxPyInstance_Check,
2896 wxPySwigInstance_Check,
2897
2898 wxPyCheckForApp,
2899
2900 wxArrayDouble2PyList_helper,
2901 wxPoint2D_LIST_helper,
2902 wxRect2D_helper,
2903 wxPosition_helper,
2904
2905 };
2906
2907 #endif
2908
2909
2910 #if !WXWIN_COMPATIBILITY_2_4
2911 #define wxHIDE_READONLY 0
2912 #endif
2913
2914
2915 #define SWIG_From_long PyInt_FromLong
2916
2917
2918 SWIGINTERNINLINE PyObject *
2919 SWIG_From_int (int value)
2920 {
2921 return SWIG_From_long (value);
2922 }
2923
2924 static const wxString wxPyEmptyString(wxEmptyString);
2925 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2926 return self->GetClassInfo()->GetClassName();
2927 }
2928 SWIGINTERN void wxObject_Destroy(wxObject *self){
2929 delete self;
2930 }
2931
2932 #ifndef __WXMAC__
2933 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2934 #endif
2935
2936
2937 #include <limits.h>
2938 #ifndef LLONG_MIN
2939 # define LLONG_MIN LONG_LONG_MIN
2940 #endif
2941 #ifndef LLONG_MAX
2942 # define LLONG_MAX LONG_LONG_MAX
2943 #endif
2944 #ifndef ULLONG_MAX
2945 # define ULLONG_MAX ULONG_LONG_MAX
2946 #endif
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_long (PyObject* obj, long* val)
2951 {
2952 if (PyNumber_Check(obj)) {
2953 if (val) *val = PyInt_AsLong(obj);
2954 return SWIG_OK;
2955 }
2956 return SWIG_TypeError;
2957 }
2958
2959
2960 SWIGINTERN int
2961 SWIG_AsVal_int (PyObject * obj, int *val)
2962 {
2963 long v;
2964 int res = SWIG_AsVal_long (obj, &v);
2965 if (SWIG_IsOK(res)) {
2966 if ((v < INT_MIN || v > INT_MAX)) {
2967 return SWIG_OverflowError;
2968 } else {
2969 if (val) *val = static_cast< int >(v);
2970 }
2971 }
2972 return res;
2973 }
2974
2975 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return false;
2978 if ( ! wxSize_helper(other, &obj) ) {
2979 PyErr_Clear();
2980 return false;
2981 }
2982 return self->operator==(*obj);
2983 }
2984 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2985 wxSize temp, *obj = &temp;
2986 if ( other == Py_None ) return true;
2987 if ( ! wxSize_helper(other, &obj)) {
2988 PyErr_Clear();
2989 return true;
2990 }
2991 return self->operator!=(*obj);
2992 }
2993
2994 #include <float.h>
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_double (PyObject *obj, double* val)
2999 {
3000 if (PyNumber_Check(obj)) {
3001 if (val) *val = PyFloat_AsDouble(obj);
3002 return SWIG_OK;
3003 }
3004 return SWIG_TypeError;
3005 }
3006
3007
3008 SWIGINTERN int
3009 SWIG_AsVal_float (PyObject * obj, float *val)
3010 {
3011 double v;
3012 int res = SWIG_AsVal_double (obj, &v);
3013 if (SWIG_IsOK(res)) {
3014 if ((v < -FLT_MAX || v > FLT_MAX)) {
3015 return SWIG_OverflowError;
3016 } else {
3017 if (val) *val = static_cast< float >(v);
3018 }
3019 }
3020 return res;
3021 }
3022
3023 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3024 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3025 PyObject* tup = PyTuple_New(2);
3026 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3027 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3028 //wxPyEndBlockThreads(blocked);
3029 return tup;
3030 }
3031
3032 #define SWIG_From_double PyFloat_FromDouble
3033
3034 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return false;
3037 if ( ! wxRealPoint_helper(other, &obj) ) {
3038 PyErr_Clear();
3039 return false;
3040 }
3041 return self->operator==(*obj);
3042 }
3043 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3044 wxRealPoint temp, *obj = &temp;
3045 if ( other == Py_None ) return true;
3046 if ( ! wxRealPoint_helper(other, &obj)) {
3047 PyErr_Clear();
3048 return true;
3049 }
3050 return self->operator!=(*obj);
3051 }
3052 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3053 self->x = x;
3054 self->y = y;
3055 }
3056 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3057 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 PyObject* tup = PyTuple_New(2);
3059 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3060 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3061 //PyEndBlockThreads(blocked);
3062 return tup;
3063 }
3064 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return false;
3067 if ( ! wxPoint_helper(other, &obj) ) {
3068 PyErr_Clear();
3069 return false;
3070 }
3071 return self->operator==(*obj);
3072 }
3073 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3074 wxPoint temp, *obj = &temp;
3075 if ( other == Py_None ) return true;
3076 if ( ! wxPoint_helper(other, &obj)) {
3077 PyErr_Clear();
3078 return true;
3079 }
3080 return self->operator!=(*obj);
3081 }
3082 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3083 self->x = x;
3084 self->y = y;
3085 }
3086 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3087 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 PyObject* tup = PyTuple_New(2);
3089 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3090 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3091 //wxPyEndBlockThreads(blocked);
3092 return tup;
3093 }
3094 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return false;
3097 if ( ! wxRect_helper(other, &obj) ) {
3098 PyErr_Clear();
3099 return false;
3100 }
3101 return self->operator==(*obj);
3102 }
3103 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3104 wxRect temp, *obj = &temp;
3105 if ( other == Py_None ) return true;
3106 if ( ! wxRect_helper(other, &obj)) {
3107 PyErr_Clear();
3108 return true;
3109 }
3110 return self->operator!=(*obj);
3111 }
3112 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3113 self->x = x;
3114 self->y = y;
3115 self->width = width;
3116 self->height = height;
3117 }
3118 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3119 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3120 PyObject* tup = PyTuple_New(4);
3121 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3122 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3123 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3124 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3125 //wxPyEndBlockThreads(blocked);
3126 return tup;
3127 }
3128
3129 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3130 wxRegion reg1(*r1);
3131 wxRegion reg2(*r2);
3132 wxRect dest(0,0,0,0);
3133 PyObject* obj;
3134
3135 reg1.Intersect(reg2);
3136 dest = reg1.GetBox();
3137
3138 if (dest != wxRect(0,0,0,0)) {
3139 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3140 wxRect* newRect = new wxRect(dest);
3141 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3142 //wxPyEndBlockThreads(blocked);
3143 return obj;
3144 }
3145 Py_INCREF(Py_None);
3146 return Py_None;
3147 }
3148
3149 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return false;
3152 if ( ! wxPoint2D_helper(other, &obj) ) {
3153 PyErr_Clear();
3154 return false;
3155 }
3156 return self->operator==(*obj);
3157 }
3158 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3159 wxPoint2D temp, *obj = &temp;
3160 if ( other == Py_None ) return true;
3161 if ( ! wxPoint2D_helper(other, &obj)) {
3162 PyErr_Clear();
3163 return true;
3164 }
3165 return self->operator!=(*obj);
3166 }
3167 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3168 self->m_x = x;
3169 self->m_y = y;
3170 }
3171 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3172 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3175 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3176 //wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3180 wxRect2D temp, *obj = &temp;
3181 if ( other == Py_None ) return false;
3182 if ( ! wxRect2D_helper(other, &obj) ) {
3183 PyErr_Clear();
3184 return false;
3185 }
3186 return self->operator==(*obj);
3187 }
3188 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3189 wxRect2D temp, *obj = &temp;
3190 if ( other == Py_None ) return true;
3191 if ( ! wxRect2D_helper(other, &obj)) {
3192 PyErr_Clear();
3193 return true;
3194 }
3195 return self->operator!=(*obj);
3196 }
3197 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3198 self->m_x = x;
3199 self->m_y = y;
3200 self->m_width = width;
3201 self->m_height = height;
3202 }
3203 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3204 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 PyObject* tup = PyTuple_New(4);
3206 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3207 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3208 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3209 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3210 //wxPyEndBlockThreads(blocked);
3211 return tup;
3212 }
3213 SWIGINTERN bool wxPosition___eq__(wxPosition *self,PyObject *other){
3214 wxPosition temp, *obj = &temp;
3215 if ( other == Py_None ) return false;
3216 if ( ! wxPosition_helper(other, &obj) ) {
3217 PyErr_Clear();
3218 return false;
3219 }
3220 return self->operator==(*obj);
3221 }
3222 SWIGINTERN bool wxPosition___ne__(wxPosition *self,PyObject *other){
3223 wxPosition temp, *obj = &temp;
3224 if ( other == Py_None ) return true;
3225 if ( ! wxPosition_helper(other, &obj)) {
3226 PyErr_Clear();
3227 return true;
3228 }
3229 return self->operator!=(*obj);
3230 }
3231
3232 #include "wx/wxPython/pyistream.h"
3233
3234 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3235 wxInputStream* wxis = wxPyCBInputStream::create(p);
3236 if (wxis)
3237 return new wxPyInputStream(wxis);
3238 else
3239 return NULL;
3240 }
3241
3242 SWIGINTERN swig_type_info*
3243 SWIG_pchar_descriptor()
3244 {
3245 static int init = 0;
3246 static swig_type_info* info = 0;
3247 if (!init) {
3248 info = SWIG_TypeQuery("_p_char");
3249 init = 1;
3250 }
3251 return info;
3252 }
3253
3254
3255 SWIGINTERNINLINE PyObject *
3256 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3257 {
3258 if (carray) {
3259 if (size > INT_MAX) {
3260 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3261 return pchar_descriptor ?
3262 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3263 } else {
3264 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3265 }
3266 } else {
3267 return SWIG_Py_Void();
3268 }
3269 }
3270
3271
3272 SWIGINTERNINLINE PyObject *
3273 SWIG_From_char (char c)
3274 {
3275 return SWIG_FromCharPtrAndSize(&c,1);
3276 }
3277
3278
3279 SWIGINTERNINLINE PyObject*
3280 SWIG_From_unsigned_SS_long (unsigned long value)
3281 {
3282 return (value > LONG_MAX) ?
3283 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3284 }
3285
3286
3287 SWIGINTERNINLINE PyObject *
3288 SWIG_From_size_t (size_t value)
3289 {
3290 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3291 }
3292
3293
3294 SWIGINTERN int
3295 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3296 {
3297 if (PyString_Check(obj)) {
3298 char *cstr; Py_ssize_t len;
3299 PyString_AsStringAndSize(obj, &cstr, &len);
3300 if (cptr) {
3301 if (alloc) {
3302 /*
3303 In python the user should not be able to modify the inner
3304 string representation. To warranty that, if you define
3305 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3306 buffer is always returned.
3307
3308 The default behavior is just to return the pointer value,
3309 so, be careful.
3310 */
3311 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3312 if (*alloc != SWIG_OLDOBJ)
3313 #else
3314 if (*alloc == SWIG_NEWOBJ)
3315 #endif
3316 {
3317 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3318 *alloc = SWIG_NEWOBJ;
3319 }
3320 else {
3321 *cptr = cstr;
3322 *alloc = SWIG_OLDOBJ;
3323 }
3324 } else {
3325 *cptr = PyString_AsString(obj);
3326 }
3327 }
3328 if (psize) *psize = len + 1;
3329 return SWIG_OK;
3330 } else {
3331 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3332 if (pchar_descriptor) {
3333 void* vptr = 0;
3334 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3335 if (cptr) *cptr = (char *) vptr;
3336 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3337 if (alloc) *alloc = SWIG_OLDOBJ;
3338 return SWIG_OK;
3339 }
3340 }
3341 }
3342 return SWIG_TypeError;
3343 }
3344
3345
3346 SWIGINTERN int
3347 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3348 {
3349 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3350 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3351 if (SWIG_IsOK(res)) {
3352 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3353 if (csize <= size) {
3354 if (val) {
3355 if (csize) memcpy(val, cptr, csize*sizeof(char));
3356 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3357 }
3358 if (alloc == SWIG_NEWOBJ) {
3359 delete[] cptr;
3360 res = SWIG_DelNewMask(res);
3361 }
3362 return res;
3363 }
3364 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3365 }
3366 return SWIG_TypeError;
3367 }
3368
3369
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373 int res = SWIG_AsCharArray(obj, val, 1);
3374 if (!SWIG_IsOK(res)) {
3375 long v;
3376 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377 if (SWIG_IsOK(res)) {
3378 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379 if (val) *val = static_cast< char >(v);
3380 } else {
3381 res = SWIG_OverflowError;
3382 }
3383 }
3384 }
3385 return res;
3386 }
3387
3388 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3389 // We use only strings for the streams, not unicode
3390 PyObject* str = PyObject_Str(obj);
3391 if (! str) {
3392 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3393 return;
3394 }
3395 self->Write(PyString_AS_STRING(str),
3396 PyString_GET_SIZE(str));
3397 Py_DECREF(str);
3398 }
3399
3400 #include "wx/wxPython/pyistream.h"
3401
3402
3403 class wxPyFileSystemHandler : public wxFileSystemHandler
3404 {
3405 public:
3406 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3407
3408 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3409 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3410 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3411 DEC_PYCALLBACK_STRING__pure(FindNext);
3412
3413 wxString GetProtocol(const wxString& location) {
3414 return wxFileSystemHandler::GetProtocol(location);
3415 }
3416
3417 wxString GetLeftLocation(const wxString& location) {
3418 return wxFileSystemHandler::GetLeftLocation(location);
3419 }
3420
3421 wxString GetAnchor(const wxString& location) {
3422 return wxFileSystemHandler::GetAnchor(location);
3423 }
3424
3425 wxString GetRightLocation(const wxString& location) {
3426 return wxFileSystemHandler::GetRightLocation(location);
3427 }
3428
3429 wxString GetMimeTypeFromExt(const wxString& location) {
3430 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3431 }
3432
3433 PYPRIVATE;
3434 };
3435
3436
3437 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3438 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3439 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3440 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3441
3442
3443 SWIGINTERN int
3444 SWIG_AsVal_bool (PyObject *obj, bool *val)
3445 {
3446 if (obj == Py_True) {
3447 if (val) *val = true;
3448 return SWIG_OK;
3449 } else if (obj == Py_False) {
3450 if (val) *val = false;
3451 return SWIG_OK;
3452 } else {
3453 long v = 0;
3454 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3455 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3456 return res;
3457 }
3458 }
3459
3460 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3461 wxFileName fname = wxFileSystem::URLToFileName(url);
3462 return fname.GetFullPath();
3463 }
3464
3465 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3466 wxImage& image,
3467 long type) {
3468 wxMemoryFSHandler::AddFile(filename, image, type);
3469 }
3470
3471 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3472 const wxBitmap& bitmap,
3473 long type) {
3474 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3475 }
3476
3477 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3478 PyObject* data) {
3479 if (! PyString_Check(data)) {
3480 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3481 "Expected string object"));
3482 return;
3483 }
3484
3485 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3486 void* ptr = (void*)PyString_AsString(data);
3487 size_t size = PyString_Size(data);
3488 wxPyEndBlockThreads(blocked);
3489
3490 wxMemoryFSHandler::AddFile(filename, ptr, size);
3491 }
3492
3493
3494 #include "wx/wxPython/pyistream.h"
3495
3496
3497 SWIGINTERN int
3498 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3499 {
3500 long v = 0;
3501 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3502 return SWIG_TypeError;
3503 }
3504 else if (val)
3505 *val = (unsigned long)v;
3506 return SWIG_OK;
3507 }
3508
3509
3510 SWIGINTERN int
3511 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3512 {
3513 unsigned long v;
3514 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3515 if (SWIG_IsOK(res)) {
3516 if ((v > UCHAR_MAX)) {
3517 return SWIG_OverflowError;
3518 } else {
3519 if (val) *val = static_cast< unsigned char >(v);
3520 }
3521 }
3522 return res;
3523 }
3524
3525
3526 SWIGINTERNINLINE PyObject *
3527 SWIG_From_unsigned_SS_char (unsigned char value)
3528 {
3529 return SWIG_From_unsigned_SS_long (value);
3530 }
3531
3532 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3533 wxImageHistogramEntry e = (*self)[key];
3534 return e.value;
3535 }
3536 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3537 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3538 wxImageHistogramEntry e = (*self)[key];
3539 return e.value;
3540 }
3541 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3542 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3543 colour.Green(),
3544 colour.Blue());
3545 wxImageHistogramEntry e = (*self)[key];
3546 return e.value;
3547 }
3548
3549 // Pull the nested class out to the top level for SWIG's sake
3550 #define wxImage_RGBValue wxImage::RGBValue
3551 #define wxImage_HSVValue wxImage::HSVValue
3552
3553 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3554 if (width > 0 && height > 0)
3555 return new wxImage(width, height, clear);
3556 else
3557 return new wxImage;
3558 }
3559 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3560 return new wxImage(bitmap.ConvertToImage());
3561 }
3562 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3563 if (DATASIZE != width*height*3) {
3564 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3565 return NULL;
3566 }
3567
3568 // Copy the source data so the wxImage can clean it up later
3569 buffer copy = (buffer)malloc(DATASIZE);
3570 if (copy == NULL) {
3571 wxPyBLOCK_THREADS(PyErr_NoMemory());
3572 return NULL;
3573 }
3574 memcpy(copy, data, DATASIZE);
3575 return new wxImage(width, height, copy, false);
3576 }
3577 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3578 if (DATASIZE != width*height*3) {
3579 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3580 return NULL;
3581 }
3582 if (ALPHASIZE != width*height) {
3583 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3584 return NULL;
3585 }
3586
3587 // Copy the source data so the wxImage can clean it up later
3588 buffer dcopy = (buffer)malloc(DATASIZE);
3589 if (dcopy == NULL) {
3590 wxPyBLOCK_THREADS(PyErr_NoMemory());
3591 return NULL;
3592 }
3593 memcpy(dcopy, data, DATASIZE);
3594
3595 buffer acopy = (buffer)malloc(ALPHASIZE);
3596 if (acopy == NULL) {
3597 wxPyBLOCK_THREADS(PyErr_NoMemory());
3598 return NULL;
3599 }
3600 memcpy(acopy, alpha, ALPHASIZE);
3601
3602 return new wxImage(width, height, dcopy, acopy, false);
3603 }
3604 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3605 wxSize size(self->GetWidth(), self->GetHeight());
3606 return size;
3607 }
3608 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 buffer copy = (buffer)malloc(DATASIZE);
3621 if (copy == NULL) {
3622 wxPyBLOCK_THREADS(PyErr_NoMemory());
3623 return;
3624 }
3625 memcpy(copy, data, DATASIZE);
3626 self->SetData(copy, false);
3627 // wxImage takes ownership of copy...
3628 }
3629 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3630 buffer data = self->GetData();
3631 int len = self->GetWidth() * self->GetHeight() * 3;
3632 PyObject* rv;
3633 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3634 return rv;
3635 }
3636 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3637 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return;
3640 }
3641 self->SetData(data, true);
3642 }
3643 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3644 buffer data = self->GetAlpha();
3645 if (! data) {
3646 RETURN_NONE();
3647 } else {
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3651 return rv;
3652 }
3653 }
3654 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 buffer acopy = (buffer)malloc(ALPHASIZE);
3660 if (acopy == NULL) {
3661 wxPyBLOCK_THREADS(PyErr_NoMemory());
3662 return;
3663 }
3664 memcpy(acopy, alpha, ALPHASIZE);
3665 self->SetAlpha(acopy, false);
3666 // wxImage takes ownership of acopy...
3667 }
3668 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3669 buffer data = self->GetAlpha();
3670 int len = self->GetWidth() * self->GetHeight();
3671 PyObject* rv;
3672 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3673 return rv;
3674 }
3675 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3676 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3677 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3678 return;
3679 }
3680 self->SetAlpha(alpha, true);
3681 }
3682 SWIGINTERN PyObject *wxImage_GetHandlers(){
3683 wxList& list = wxImage::GetHandlers();
3684 return wxPy_ConvertList(&list);
3685 }
3686 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3687 wxBitmap bitmap(*self, depth);
3688 return bitmap;
3689 }
3690 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3691 wxImage mono = self->ConvertToMono( red, green, blue );
3692 wxBitmap bitmap( mono, 1 );
3693 return bitmap;
3694 }
3695
3696 wxImage* _ImageFromBuffer(int width, int height,
3697 buffer data, int DATASIZE,
3698 buffer alpha=NULL, int ALPHASIZE=0)
3699 {
3700 if (DATASIZE != width*height*3) {
3701 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3702 return NULL;
3703 }
3704 if (alpha != NULL) {
3705 if (ALPHASIZE != width*height) {
3706 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3707 return NULL;
3708 }
3709 return new wxImage(width, height, data, alpha, true);
3710 }
3711 return new wxImage(width, height, data, true);
3712 }
3713
3714 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3715 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3716 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3717 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3718 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3719 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3720 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3721 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3722 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3723 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3724 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3725 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3726 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3727 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3728 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3729
3730 #include <wx/imagtga.h>
3731
3732
3733 #include <wx/quantize.h>
3734
3735 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3736 return wxQuantize::Quantize(src, dest,
3737 //NULL, // palette
3738 desiredNoColours,
3739 NULL, // eightBitData
3740 flags);
3741 }
3742 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3743 if (PyCallable_Check(func)) {
3744 self->Connect(id, lastId, eventType,
3745 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3746 new wxPyCallback(func));
3747 }
3748 else if (func == Py_None) {
3749 self->Disconnect(id, lastId, eventType,
3750 (wxObjectEventFunction)
3751 &wxPyCallback::EventThunker);
3752 }
3753 else {
3754 wxPyBLOCK_THREADS(
3755 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3756 }
3757 }
3758 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3759 return self->Disconnect(id, lastId, eventType,
3760 (wxObjectEventFunction)
3761 &wxPyCallback::EventThunker);
3762 }
3763 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3764 if (_self && _self != Py_None) {
3765 self->SetClientObject(new wxPyOORClientData(_self, incref));
3766 }
3767 else {
3768 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3769 if (data) {
3770 self->SetClientObject(NULL); // This will delete it too
3771 }
3772 }
3773 }
3774
3775 #if ! wxUSE_HOTKEY
3776 #define wxEVT_HOTKEY -9999
3777 #endif
3778
3779 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3780 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3781 if (data) {
3782 Py_INCREF(data->m_obj);
3783 return data->m_obj;
3784 } else {
3785 Py_INCREF(Py_None);
3786 return Py_None;
3787 }
3788 }
3789 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3790 wxPyClientData* data = new wxPyClientData(clientData);
3791 self->SetClientObject(data);
3792 }
3793 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3794 #if wxUSE_UNICODE
3795 return self->GetUnicodeKey();
3796 #else
3797 return 0;
3798 #endif
3799 }
3800 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3801 #if wxUSE_UNICODE
3802 self->m_uniChar = uniChar;
3803 #endif
3804 }
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_From_unsigned_SS_int (unsigned int value)
3808 {
3809 return SWIG_From_unsigned_SS_long (value);
3810 }
3811
3812
3813 SWIGINTERN int
3814 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3815 {
3816 unsigned long v;
3817 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3818 if (SWIG_IsOK(res)) {
3819 if ((v > UINT_MAX)) {
3820 return SWIG_OverflowError;
3821 } else {
3822 if (val) *val = static_cast< unsigned int >(v);
3823 }
3824 }
3825 return res;
3826 }
3827
3828 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3829 self->m_size = size;
3830 }
3831 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3832 int count = self->GetNumberOfFiles();
3833 wxString* files = self->GetFiles();
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 PyObject* list = PyList_New(count);
3836
3837 if (!list) {
3838 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3839 wxPyEndBlockThreads(blocked);
3840 return NULL;
3841 }
3842
3843 for (int i=0; i<count; i++) {
3844 PyList_SetItem(list, i, wx2PyString(files[i]));
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return list;
3848 }
3849
3850
3851 SWIGINTERN wxPyApp *new_wxPyApp(){
3852 wxPythonApp = new wxPyApp();
3853 return wxPythonApp;
3854 }
3855 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3856 return wxPyTestDisplayAvailable();
3857 }
3858
3859 void wxApp_CleanUp() {
3860 __wxPyCleanup();
3861 }
3862
3863
3864 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3865
3866
3867
3868
3869
3870 SWIGINTERNINLINE PyObject *
3871 SWIG_FromCharPtr(const char *cptr)
3872 {
3873 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3874 }
3875
3876
3877 #if 0 // #ifdef __WXMAC__
3878
3879 // A dummy class that raises an exception if used...
3880 class wxEventLoop
3881 {
3882 public:
3883 wxEventLoop() { wxPyRaiseNotImplemented(); }
3884 int Run() { return 0; }
3885 void Exit(int rc = 0) {}
3886 bool Pending() const { return false; }
3887 bool Dispatch() { return false; }
3888 bool IsRunning() const { return false; }
3889 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3890 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3891 };
3892
3893 #else
3894
3895 #include <wx/evtloop.h>
3896
3897 #endif
3898
3899
3900
3901 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3902 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3903 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3904 SWIGINTERN wxFont wxVisualAttributes__get_font(wxVisualAttributes *self){ return self->font; }
3905 SWIGINTERN wxColour wxVisualAttributes__get_colFg(wxVisualAttributes *self){ return self->colFg; }
3906 SWIGINTERN wxColour wxVisualAttributes__get_colBg(wxVisualAttributes *self){ return self->colBg; }
3907 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3908 wxWindowList& list = self->GetChildren();
3909 return wxPy_ConvertList(&list);
3910 }
3911 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3912 return wxGetTopLevelParent(self);
3913 }
3914 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3915 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3916 #if wxUSE_HOTKEY
3917 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3918 #else
3919 return false;
3920 #endif
3921 }
3922 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3923
3924
3925
3926 return false;
3927
3928 }
3929 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3930 return wxPyGetWinHandle(self);
3931 }
3932 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3933 self->AssociateHandle((WXWidget)handle);
3934 }
3935
3936 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3937 return wxWindow::FindWindowById(id, parent);
3938 }
3939
3940 wxWindow* wxFindWindowByName( const wxString& name,
3941 const wxWindow *parent = NULL ) {
3942 return wxWindow::FindWindowByName(name, parent);
3943 }
3944
3945 wxWindow* wxFindWindowByLabel( const wxString& label,
3946 const wxWindow *parent = NULL ) {
3947 return wxWindow::FindWindowByLabel(label, parent);
3948 }
3949
3950
3951 #ifdef __WXMSW__
3952 #include <wx/msw/private.h> // to get wxGetWindowId
3953 #endif
3954
3955
3956 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3957 #ifdef __WXMSW__
3958 WXHWND hWnd = (WXHWND)_hWnd;
3959 long id = wxGetWindowId(hWnd);
3960 wxWindow* win = new wxWindow;
3961 if (parent)
3962 parent->AddChild(win);
3963 win->SetEventHandler(win);
3964 win->SetHWND(hWnd);
3965 win->SetId(id);
3966 win->SubclassWin(hWnd);
3967 win->AdoptAttributesFromHWND();
3968 win->SetupColours();
3969 return win;
3970 #else
3971 wxPyRaiseNotImplemented();
3972 return NULL;
3973 #endif
3974 }
3975
3976
3977 PyObject* GetTopLevelWindows() {
3978 return wxPy_ConvertList(&wxTopLevelWindows);
3979 }
3980
3981
3982 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3983 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3984 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3985
3986 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3987
3988
3989 SWIGINTERNINLINE int
3990 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3991 {
3992 unsigned long v;
3993 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3994 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3995 return res;
3996 }
3997
3998 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3999 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
4000 wxMenuItemList& list = self->GetMenuItems();
4001 return wxPy_ConvertList(&list);
4002 }
4003 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
4004 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
4005 static const wxString wxPyControlNameStr(wxControlNameStr);
4006 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4007 if (clientData) {
4008 wxPyClientData* data = new wxPyClientData(clientData);
4009 return self->Append(item, data);
4010 } else
4011 return self->Append(item);
4012 }
4013 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4014 if (clientData) {
4015 wxPyClientData* data = new wxPyClientData(clientData);
4016 return self->Insert(item, pos, data);
4017 } else
4018 return self->Insert(item, pos);
4019 }
4020 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4021 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4022 if (data) {
4023 Py_INCREF(data->m_obj);
4024 return data->m_obj;
4025 } else {
4026 Py_INCREF(Py_None);
4027 return Py_None;
4028 }
4029 }
4030 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4031 wxPyClientData* data = new wxPyClientData(clientData);
4032 self->SetClientObject(n, data);
4033 }
4034
4035
4036 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4037 if (borderInPixels == -1)
4038 return self->Border(direction);
4039 else
4040 return self->Border(direction, borderInPixels);
4041 }
4042 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4043 wxPyUserData* data = NULL;
4044 if ( userData ) {
4045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4046 data = new wxPyUserData(userData);
4047 wxPyEndBlockThreads(blocked);
4048 }
4049 return new wxSizerItem(window, proportion, flag, border, data);
4050 }
4051 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4052 wxPyUserData* data = NULL;
4053 if ( userData ) {
4054 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4055 data = new wxPyUserData(userData);
4056 wxPyEndBlockThreads(blocked);
4057 }
4058 return new wxSizerItem(width, height, proportion, flag, border, data);
4059 }
4060 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4061 wxPyUserData* data = NULL;
4062 if ( userData ) {
4063 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4064 data = new wxPyUserData(userData);
4065 wxPyEndBlockThreads(blocked);
4066 }
4067 return new wxSizerItem(sizer, proportion, flag, border, data);
4068 }
4069
4070 SWIGINTERNINLINE PyObject *
4071 SWIG_From_float (float value)
4072 {
4073 return SWIG_From_double (value);
4074 }
4075
4076 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4077 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4078 if (data) {
4079 Py_INCREF(data->m_obj);
4080 return data->m_obj;
4081 } else {
4082 Py_INCREF(Py_None);
4083 return Py_None;
4084 }
4085 }
4086 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4087 wxPyUserData* data = NULL;
4088 if ( userData ) {
4089 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4090 data = new wxPyUserData(userData);
4091 wxPyEndBlockThreads(blocked);
4092 }
4093 self->SetUserData(data);
4094 }
4095
4096 // Figure out the type of the sizer item
4097
4098 struct wxPySizerItemInfo {
4099 wxPySizerItemInfo()
4100 : window(NULL), sizer(NULL), gotSize(false),
4101 size(wxDefaultSize), gotPos(false), pos(-1)
4102 {}
4103
4104 wxWindow* window;
4105 wxSizer* sizer;
4106 bool gotSize;
4107 wxSize size;
4108 bool gotPos;
4109 int pos;
4110 };
4111
4112 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4113
4114 wxPySizerItemInfo info;
4115 wxSize size;
4116 wxSize* sizePtr = &size;
4117
4118 // Find out what the type of the item is
4119 // try wxWindow
4120 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4121 PyErr_Clear();
4122 info.window = NULL;
4123
4124 // try wxSizer
4125 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4126 PyErr_Clear();
4127 info.sizer = NULL;
4128
4129 // try wxSize or (w,h)
4130 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4131 info.size = *sizePtr;
4132 info.gotSize = true;
4133 }
4134
4135 // or a single int
4136 if (checkIdx && PyInt_Check(item)) {
4137 info.pos = PyInt_AsLong(item);
4138 info.gotPos = true;
4139 }
4140 }
4141 }
4142
4143 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4144 // no expected type, figure out what kind of error message to generate
4145 if ( !checkSize && !checkIdx )
4146 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4147 else if ( checkSize && !checkIdx )
4148 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4149 else if ( !checkSize && checkIdx)
4150 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4151 else
4152 // can this one happen?
4153 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4154 }
4155
4156 return info;
4157 }
4158
4159 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4160 if (!self->GetClientObject())
4161 self->SetClientObject(new wxPyOORClientData(_self));
4162 }
4163 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4164
4165 wxPyUserData* data = NULL;
4166 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4167 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4168 if ( userData && (info.window || info.sizer || info.gotSize) )
4169 data = new wxPyUserData(userData);
4170 if ( info.sizer )
4171 PyObject_SetAttrString(item,"thisown",Py_False);
4172 wxPyEndBlockThreads(blocked);
4173
4174 // Now call the real Add method if a valid item type was found
4175 if ( info.window )
4176 return self->Add(info.window, proportion, flag, border, data);
4177 else if ( info.sizer )
4178 return self->Add(info.sizer, proportion, flag, border, data);
4179 else if (info.gotSize)
4180 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4181 proportion, flag, border, data);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4186
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4189 if ( info.sizer )
4190 PyObject_SetAttrString(item,"thisown",Py_False);
4191 wxPyEndBlockThreads(blocked);
4192
4193 // Now call the real Add method if a valid item type was found
4194 if ( info.window )
4195 return self->Add(info.window, flags);
4196 else if ( info.sizer )
4197 return self->Add(info.sizer, flags);
4198 else if (info.gotSize)
4199 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4200 flags.GetProportion(),
4201 flags.GetFlags(),
4202 flags.GetBorderInPixels());
4203 else
4204 return NULL;
4205 }
4206 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4207
4208 wxPyUserData* data = NULL;
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4211 if ( userData && (info.window || info.sizer || info.gotSize) )
4212 data = new wxPyUserData(userData);
4213 if ( info.sizer )
4214 PyObject_SetAttrString(item,"thisown",Py_False);
4215 wxPyEndBlockThreads(blocked);
4216
4217 // Now call the real Insert method if a valid item type was found
4218 if ( info.window )
4219 return self->Insert(before, info.window, proportion, flag, border, data);
4220 else if ( info.sizer )
4221 return self->Insert(before, info.sizer, proportion, flag, border, data);
4222 else if (info.gotSize)
4223 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4224 proportion, flag, border, data);
4225 else
4226 return NULL;
4227 }
4228 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4229
4230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4231 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4232 if ( info.sizer )
4233 PyObject_SetAttrString(item,"thisown",Py_False);
4234 wxPyEndBlockThreads(blocked);
4235
4236 // Now call the real Insert method if a valid item type was found
4237 if ( info.window )
4238 return self->Insert(before, info.window, flags);
4239 else if ( info.sizer )
4240 return self->Insert(before, info.sizer, flags);
4241 else if (info.gotSize)
4242 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4243 flags.GetProportion(),
4244 flags.GetFlags(),
4245 flags.GetBorderInPixels());
4246 else
4247 return NULL;
4248 }
4249 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4250
4251 wxPyUserData* data = NULL;
4252 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4253 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4254 if ( userData && (info.window || info.sizer || info.gotSize) )
4255 data = new wxPyUserData(userData);
4256 if ( info.sizer )
4257 PyObject_SetAttrString(item,"thisown",Py_False);
4258 wxPyEndBlockThreads(blocked);
4259
4260 // Now call the real Prepend method if a valid item type was found
4261 if ( info.window )
4262 return self->Prepend(info.window, proportion, flag, border, data);
4263 else if ( info.sizer )
4264 return self->Prepend(info.sizer, proportion, flag, border, data);
4265 else if (info.gotSize)
4266 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4267 proportion, flag, border, data);
4268 else
4269 return NULL;
4270 }
4271 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4272
4273 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4274 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4275 if ( info.sizer )
4276 PyObject_SetAttrString(item,"thisown",Py_False);
4277 wxPyEndBlockThreads(blocked);
4278
4279 // Now call the real Add method if a valid item type was found
4280 if ( info.window )
4281 return self->Prepend(info.window, flags);
4282 else if ( info.sizer )
4283 return self->Prepend(info.sizer, flags);
4284 else if (info.gotSize)
4285 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4286 flags.GetProportion(),
4287 flags.GetFlags(),
4288 flags.GetBorderInPixels());
4289 else
4290 return NULL;
4291 }
4292 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4294 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4295 wxPyEndBlockThreads(blocked);
4296 if ( info.window )
4297 return false; //self->Remove(info.window);
4298 else if ( info.sizer )
4299 return self->Remove(info.sizer);
4300 else if ( info.gotPos )
4301 return self->Remove(info.pos);
4302 else
4303 return false;
4304 }
4305 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4306 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4307 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4308 wxPyEndBlockThreads(blocked);
4309 if ( info.window )
4310 return self->Detach(info.window);
4311 else if ( info.sizer )
4312 return self->Detach(info.sizer);
4313 else if ( info.gotPos )
4314 return self->Detach(info.pos);
4315 else
4316 return false;
4317 }
4318 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4320 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4321 wxPyEndBlockThreads(blocked);
4322 if ( info.window )
4323 return self->GetItem(info.window, recursive);
4324 else if ( info.sizer )
4325 return self->GetItem(info.sizer, recursive);
4326 else if ( info.gotPos )
4327 return self->GetItem(info.pos);
4328 else
4329 return NULL;
4330 }
4331 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4333 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4334 wxPyEndBlockThreads(blocked);
4335 if ( info.window )
4336 self->SetItemMinSize(info.window, size);
4337 else if ( info.sizer )
4338 self->SetItemMinSize(info.sizer, size);
4339 else if ( info.gotPos )
4340 self->SetItemMinSize(info.pos, size);
4341 }
4342 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4343 wxSizerItemList& list = self->GetChildren();
4344 return wxPy_ConvertList(&list);
4345 }
4346 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4349 wxPyEndBlockThreads(blocked);
4350 if ( info.window )
4351 return self->Show(info.window, show, recursive);
4352 else if ( info.sizer )
4353 return self->Show(info.sizer, show, recursive);
4354 else if ( info.gotPos )
4355 return self->Show(info.pos, show);
4356 else
4357 return false;
4358 }
4359 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4360 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4361 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4362 wxPyEndBlockThreads(blocked);
4363 if ( info.window )
4364 return self->IsShown(info.window);
4365 else if ( info.sizer )
4366 return self->IsShown(info.sizer);
4367 else if ( info.gotPos )
4368 return self->IsShown(info.pos);
4369 else
4370 return false;
4371 }
4372
4373 // See pyclasses.h
4374 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4375 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4376 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4377
4378
4379
4380
4381 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4382 {
4383 if (source == Py_None) {
4384 **obj = wxGBPosition(-1,-1);
4385 return true;
4386 }
4387 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4388 }
4389
4390 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4391 {
4392 if (source == Py_None) {
4393 **obj = wxGBSpan(-1,-1);
4394 return true;
4395 }
4396 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4397 }
4398
4399
4400 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4401 wxGBPosition temp, *obj = &temp;
4402 if ( other == Py_None ) return false;
4403 if ( ! wxGBPosition_helper(other, &obj) ) {
4404 PyErr_Clear();
4405 return false;
4406 }
4407 return self->operator==(*obj);
4408 }
4409 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4410 wxGBPosition temp, *obj = &temp;
4411 if ( other == Py_None ) return true;
4412 if ( ! wxGBPosition_helper(other, &obj)) {
4413 PyErr_Clear();
4414 return true;
4415 }
4416 return self->operator!=(*obj);
4417 }
4418 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4419 self->SetRow(row);
4420 self->SetCol(col);
4421 }
4422 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4424 PyObject* tup = PyTuple_New(2);
4425 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4426 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4427 wxPyEndBlockThreads(blocked);
4428 return tup;
4429 }
4430 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4431 wxGBSpan temp, *obj = &temp;
4432 if ( other == Py_None ) return false;
4433 if ( ! wxGBSpan_helper(other, &obj) ) {
4434 PyErr_Clear();
4435 return false;
4436 }
4437 return self->operator==(*obj);
4438 }
4439 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4440 wxGBSpan temp, *obj = &temp;
4441 if ( other == Py_None ) return true;
4442 if ( ! wxGBSpan_helper(other, &obj)) {
4443 PyErr_Clear();
4444 return true;
4445 }
4446 return self->operator!=(*obj);
4447 }
4448 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4449 self->SetRowspan(rowspan);
4450 self->SetColspan(colspan);
4451 }
4452 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4453 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4454 PyObject* tup = PyTuple_New(2);
4455 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4456 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4457 wxPyEndBlockThreads(blocked);
4458 return tup;
4459 }
4460 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4461 wxPyUserData* data = NULL;
4462 if ( userData ) {
4463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4464 data = new wxPyUserData(userData);
4465 wxPyEndBlockThreads(blocked);
4466 }
4467 return new wxGBSizerItem(window, pos, span, flag, border, data);
4468 }
4469 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4470 wxPyUserData* data = NULL;
4471 if ( userData ) {
4472 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4473 data = new wxPyUserData(userData);
4474 wxPyEndBlockThreads(blocked);
4475 }
4476 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4477 }
4478 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4479 wxPyUserData* data = NULL;
4480 if ( userData ) {
4481 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4482 data = new wxPyUserData(userData);
4483 wxPyEndBlockThreads(blocked);
4484 }
4485 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4486 }
4487 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4488 int row, col;
4489 self->GetEndPos(row, col);
4490 return wxGBPosition(row, col);
4491 }
4492 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4493
4494 wxPyUserData* data = NULL;
4495 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4496 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4497 if ( userData && (info.window || info.sizer || info.gotSize) )
4498 data = new wxPyUserData(userData);
4499 if ( info.sizer )
4500 PyObject_SetAttrString(item,"thisown",Py_False);
4501 wxPyEndBlockThreads(blocked);
4502
4503 // Now call the real Add method if a valid item type was found
4504 if ( info.window )
4505 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4506 else if ( info.sizer )
4507 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4508 else if (info.gotSize)
4509 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4510 pos, span, flag, border, data);
4511 return NULL;
4512 }
4513
4514
4515 #ifdef __cplusplus
4516 extern "C" {
4517 #endif
4518 SWIGINTERN int EmptyString_set(PyObject *) {
4519 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4520 return 1;
4521 }
4522
4523
4524 SWIGINTERN PyObject *EmptyString_get(void) {
4525 PyObject *pyobj = 0;
4526
4527 {
4528 #if wxUSE_UNICODE
4529 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4530 #else
4531 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4532 #endif
4533 }
4534 return pyobj;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4539 PyObject *resultobj = 0;
4540 wxObject *arg1 = (wxObject *) 0 ;
4541 wxString result;
4542 void *argp1 = 0 ;
4543 int res1 = 0 ;
4544 PyObject *swig_obj[1] ;
4545
4546 if (!args) SWIG_fail;
4547 swig_obj[0] = args;
4548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4549 if (!SWIG_IsOK(res1)) {
4550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4551 }
4552 arg1 = reinterpret_cast< wxObject * >(argp1);
4553 {
4554 PyThreadState* __tstate = wxPyBeginAllowThreads();
4555 result = wxObject_GetClassName(arg1);
4556 wxPyEndAllowThreads(__tstate);
4557 if (PyErr_Occurred()) SWIG_fail;
4558 }
4559 {
4560 #if wxUSE_UNICODE
4561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4562 #else
4563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4564 #endif
4565 }
4566 return resultobj;
4567 fail:
4568 return NULL;
4569 }
4570
4571
4572 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4573 PyObject *resultobj = 0;
4574 wxObject *arg1 = (wxObject *) 0 ;
4575 void *argp1 = 0 ;
4576 int res1 = 0 ;
4577 PyObject *swig_obj[1] ;
4578
4579 if (!args) SWIG_fail;
4580 swig_obj[0] = args;
4581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4582 if (!SWIG_IsOK(res1)) {
4583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4584 }
4585 arg1 = reinterpret_cast< wxObject * >(argp1);
4586 {
4587 PyThreadState* __tstate = wxPyBeginAllowThreads();
4588 wxObject_Destroy(arg1);
4589 wxPyEndAllowThreads(__tstate);
4590 if (PyErr_Occurred()) SWIG_fail;
4591 }
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4600 PyObject *resultobj = 0;
4601 wxObject *arg1 = (wxObject *) 0 ;
4602 wxObject *arg2 = 0 ;
4603 bool result;
4604 void *argp1 = 0 ;
4605 int res1 = 0 ;
4606 void *argp2 = 0 ;
4607 int res2 = 0 ;
4608 PyObject * obj0 = 0 ;
4609 PyObject * obj1 = 0 ;
4610 char * kwnames[] = {
4611 (char *) "self",(char *) "p", NULL
4612 };
4613
4614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4616 if (!SWIG_IsOK(res1)) {
4617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4618 }
4619 arg1 = reinterpret_cast< wxObject * >(argp1);
4620 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4621 if (!SWIG_IsOK(res2)) {
4622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4623 }
4624 if (!argp2) {
4625 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4626 }
4627 arg2 = reinterpret_cast< wxObject * >(argp2);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4631 wxPyEndAllowThreads(__tstate);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4636 }
4637 return resultobj;
4638 fail:
4639 return NULL;
4640 }
4641
4642
4643 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *obj;
4645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4646 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4647 return SWIG_Py_Void();
4648 }
4649
4650 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4651 PyObject *resultobj = 0;
4652 wxSize *arg1 = (wxSize *) 0 ;
4653 int arg2 ;
4654 void *argp1 = 0 ;
4655 int res1 = 0 ;
4656 int val2 ;
4657 int ecode2 = 0 ;
4658 PyObject *swig_obj[2] ;
4659
4660 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4662 if (!SWIG_IsOK(res1)) {
4663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4664 }
4665 arg1 = reinterpret_cast< wxSize * >(argp1);
4666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4667 if (!SWIG_IsOK(ecode2)) {
4668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4669 }
4670 arg2 = static_cast< int >(val2);
4671 if (arg1) (arg1)->x = arg2;
4672
4673 resultobj = SWIG_Py_Void();
4674 return resultobj;
4675 fail:
4676 return NULL;
4677 }
4678
4679
4680 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4681 PyObject *resultobj = 0;
4682 wxSize *arg1 = (wxSize *) 0 ;
4683 int result;
4684 void *argp1 = 0 ;
4685 int res1 = 0 ;
4686 PyObject *swig_obj[1] ;
4687
4688 if (!args) SWIG_fail;
4689 swig_obj[0] = args;
4690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4691 if (!SWIG_IsOK(res1)) {
4692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4693 }
4694 arg1 = reinterpret_cast< wxSize * >(argp1);
4695 result = (int) ((arg1)->x);
4696 resultobj = SWIG_From_int(static_cast< int >(result));
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4704 PyObject *resultobj = 0;
4705 wxSize *arg1 = (wxSize *) 0 ;
4706 int arg2 ;
4707 void *argp1 = 0 ;
4708 int res1 = 0 ;
4709 int val2 ;
4710 int ecode2 = 0 ;
4711 PyObject *swig_obj[2] ;
4712
4713 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4715 if (!SWIG_IsOK(res1)) {
4716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4717 }
4718 arg1 = reinterpret_cast< wxSize * >(argp1);
4719 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4720 if (!SWIG_IsOK(ecode2)) {
4721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4722 }
4723 arg2 = static_cast< int >(val2);
4724 if (arg1) (arg1)->y = arg2;
4725
4726 resultobj = SWIG_Py_Void();
4727 return resultobj;
4728 fail:
4729 return NULL;
4730 }
4731
4732
4733 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4734 PyObject *resultobj = 0;
4735 wxSize *arg1 = (wxSize *) 0 ;
4736 int result;
4737 void *argp1 = 0 ;
4738 int res1 = 0 ;
4739 PyObject *swig_obj[1] ;
4740
4741 if (!args) SWIG_fail;
4742 swig_obj[0] = args;
4743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4744 if (!SWIG_IsOK(res1)) {
4745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4746 }
4747 arg1 = reinterpret_cast< wxSize * >(argp1);
4748 result = (int) ((arg1)->y);
4749 resultobj = SWIG_From_int(static_cast< int >(result));
4750 return resultobj;
4751 fail:
4752 return NULL;
4753 }
4754
4755
4756 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4757 PyObject *resultobj = 0;
4758 int arg1 = (int) 0 ;
4759 int arg2 = (int) 0 ;
4760 wxSize *result = 0 ;
4761 int val1 ;
4762 int ecode1 = 0 ;
4763 int val2 ;
4764 int ecode2 = 0 ;
4765 PyObject * obj0 = 0 ;
4766 PyObject * obj1 = 0 ;
4767 char * kwnames[] = {
4768 (char *) "w",(char *) "h", NULL
4769 };
4770
4771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4772 if (obj0) {
4773 ecode1 = SWIG_AsVal_int(obj0, &val1);
4774 if (!SWIG_IsOK(ecode1)) {
4775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4776 }
4777 arg1 = static_cast< int >(val1);
4778 }
4779 if (obj1) {
4780 ecode2 = SWIG_AsVal_int(obj1, &val2);
4781 if (!SWIG_IsOK(ecode2)) {
4782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4783 }
4784 arg2 = static_cast< int >(val2);
4785 }
4786 {
4787 result = (wxSize *)new wxSize(arg1,arg2);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 void *argp1 = 0 ;
4801 int res1 = 0 ;
4802 PyObject *swig_obj[1] ;
4803
4804 if (!args) SWIG_fail;
4805 swig_obj[0] = args;
4806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4807 if (!SWIG_IsOK(res1)) {
4808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4809 }
4810 arg1 = reinterpret_cast< wxSize * >(argp1);
4811 {
4812 delete arg1;
4813
4814 if (PyErr_Occurred()) SWIG_fail;
4815 }
4816 resultobj = SWIG_Py_Void();
4817 return resultobj;
4818 fail:
4819 return NULL;
4820 }
4821
4822
4823 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4824 PyObject *resultobj = 0;
4825 wxSize *arg1 = (wxSize *) 0 ;
4826 PyObject *arg2 = (PyObject *) 0 ;
4827 bool result;
4828 void *argp1 = 0 ;
4829 int res1 = 0 ;
4830 PyObject * obj0 = 0 ;
4831 PyObject * obj1 = 0 ;
4832 char * kwnames[] = {
4833 (char *) "self",(char *) "other", NULL
4834 };
4835
4836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4838 if (!SWIG_IsOK(res1)) {
4839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4840 }
4841 arg1 = reinterpret_cast< wxSize * >(argp1);
4842 arg2 = obj1;
4843 {
4844 result = (bool)wxSize___eq__(arg1,arg2);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 {
4848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4849 }
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 wxSize *arg1 = (wxSize *) 0 ;
4859 PyObject *arg2 = (PyObject *) 0 ;
4860 bool result;
4861 void *argp1 = 0 ;
4862 int res1 = 0 ;
4863 PyObject * obj0 = 0 ;
4864 PyObject * obj1 = 0 ;
4865 char * kwnames[] = {
4866 (char *) "self",(char *) "other", NULL
4867 };
4868
4869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4871 if (!SWIG_IsOK(res1)) {
4872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4873 }
4874 arg1 = reinterpret_cast< wxSize * >(argp1);
4875 arg2 = obj1;
4876 {
4877 result = (bool)wxSize___ne__(arg1,arg2);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 {
4881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4882 }
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = 0;
4891 wxSize *arg1 = (wxSize *) 0 ;
4892 wxSize *arg2 = 0 ;
4893 wxSize result;
4894 void *argp1 = 0 ;
4895 int res1 = 0 ;
4896 wxSize temp2 ;
4897 PyObject * obj0 = 0 ;
4898 PyObject * obj1 = 0 ;
4899 char * kwnames[] = {
4900 (char *) "self",(char *) "sz", NULL
4901 };
4902
4903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4905 if (!SWIG_IsOK(res1)) {
4906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4907 }
4908 arg1 = reinterpret_cast< wxSize * >(argp1);
4909 {
4910 arg2 = &temp2;
4911 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4912 }
4913 {
4914 result = (arg1)->operator +((wxSize const &)*arg2);
4915 if (PyErr_Occurred()) SWIG_fail;
4916 }
4917 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj = 0;
4926 wxSize *arg1 = (wxSize *) 0 ;
4927 wxSize *arg2 = 0 ;
4928 wxSize result;
4929 void *argp1 = 0 ;
4930 int res1 = 0 ;
4931 wxSize temp2 ;
4932 PyObject * obj0 = 0 ;
4933 PyObject * obj1 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "self",(char *) "sz", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4940 if (!SWIG_IsOK(res1)) {
4941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4942 }
4943 arg1 = reinterpret_cast< wxSize * >(argp1);
4944 {
4945 arg2 = &temp2;
4946 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4947 }
4948 {
4949 result = (arg1)->operator -((wxSize const &)*arg2);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4960 PyObject *resultobj = 0;
4961 wxSize *arg1 = (wxSize *) 0 ;
4962 wxSize *arg2 = 0 ;
4963 void *argp1 = 0 ;
4964 int res1 = 0 ;
4965 wxSize temp2 ;
4966 PyObject * obj0 = 0 ;
4967 PyObject * obj1 = 0 ;
4968 char * kwnames[] = {
4969 (char *) "self",(char *) "sz", NULL
4970 };
4971
4972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4974 if (!SWIG_IsOK(res1)) {
4975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4976 }
4977 arg1 = reinterpret_cast< wxSize * >(argp1);
4978 {
4979 arg2 = &temp2;
4980 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4981 }
4982 {
4983 (arg1)->IncTo((wxSize const &)*arg2);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 resultobj = SWIG_Py_Void();
4987 return resultobj;
4988 fail:
4989 return NULL;
4990 }
4991
4992
4993 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4994 PyObject *resultobj = 0;
4995 wxSize *arg1 = (wxSize *) 0 ;
4996 wxSize *arg2 = 0 ;
4997 void *argp1 = 0 ;
4998 int res1 = 0 ;
4999 wxSize temp2 ;
5000 PyObject * obj0 = 0 ;
5001 PyObject * obj1 = 0 ;
5002 char * kwnames[] = {
5003 (char *) "self",(char *) "sz", NULL
5004 };
5005
5006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5008 if (!SWIG_IsOK(res1)) {
5009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5010 }
5011 arg1 = reinterpret_cast< wxSize * >(argp1);
5012 {
5013 arg2 = &temp2;
5014 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5015 }
5016 {
5017 (arg1)->DecTo((wxSize const &)*arg2);
5018 if (PyErr_Occurred()) SWIG_fail;
5019 }
5020 resultobj = SWIG_Py_Void();
5021 return resultobj;
5022 fail:
5023 return NULL;
5024 }
5025
5026
5027 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5028 PyObject *resultobj = 0;
5029 wxSize *arg1 = (wxSize *) 0 ;
5030 int arg2 ;
5031 int arg3 ;
5032 void *argp1 = 0 ;
5033 int res1 = 0 ;
5034 int val2 ;
5035 int ecode2 = 0 ;
5036 int val3 ;
5037 int ecode3 = 0 ;
5038 PyObject * obj0 = 0 ;
5039 PyObject * obj1 = 0 ;
5040 PyObject * obj2 = 0 ;
5041 char * kwnames[] = {
5042 (char *) "self",(char *) "dx",(char *) "dy", NULL
5043 };
5044
5045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5047 if (!SWIG_IsOK(res1)) {
5048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5049 }
5050 arg1 = reinterpret_cast< wxSize * >(argp1);
5051 ecode2 = SWIG_AsVal_int(obj1, &val2);
5052 if (!SWIG_IsOK(ecode2)) {
5053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5054 }
5055 arg2 = static_cast< int >(val2);
5056 ecode3 = SWIG_AsVal_int(obj2, &val3);
5057 if (!SWIG_IsOK(ecode3)) {
5058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5059 }
5060 arg3 = static_cast< int >(val3);
5061 {
5062 (arg1)->IncBy(arg2,arg3);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_Py_Void();
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj = 0;
5074 wxSize *arg1 = (wxSize *) 0 ;
5075 int arg2 ;
5076 int arg3 ;
5077 void *argp1 = 0 ;
5078 int res1 = 0 ;
5079 int val2 ;
5080 int ecode2 = 0 ;
5081 int val3 ;
5082 int ecode3 = 0 ;
5083 PyObject * obj0 = 0 ;
5084 PyObject * obj1 = 0 ;
5085 PyObject * obj2 = 0 ;
5086 char * kwnames[] = {
5087 (char *) "self",(char *) "dx",(char *) "dy", NULL
5088 };
5089
5090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5094 }
5095 arg1 = reinterpret_cast< wxSize * >(argp1);
5096 ecode2 = SWIG_AsVal_int(obj1, &val2);
5097 if (!SWIG_IsOK(ecode2)) {
5098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5099 }
5100 arg2 = static_cast< int >(val2);
5101 ecode3 = SWIG_AsVal_int(obj2, &val3);
5102 if (!SWIG_IsOK(ecode3)) {
5103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5104 }
5105 arg3 = static_cast< int >(val3);
5106 {
5107 (arg1)->DecBy(arg2,arg3);
5108 if (PyErr_Occurred()) SWIG_fail;
5109 }
5110 resultobj = SWIG_Py_Void();
5111 return resultobj;
5112 fail:
5113 return NULL;
5114 }
5115
5116
5117 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5118 PyObject *resultobj = 0;
5119 wxSize *arg1 = (wxSize *) 0 ;
5120 float arg2 ;
5121 float arg3 ;
5122 void *argp1 = 0 ;
5123 int res1 = 0 ;
5124 float val2 ;
5125 int ecode2 = 0 ;
5126 float val3 ;
5127 int ecode3 = 0 ;
5128 PyObject * obj0 = 0 ;
5129 PyObject * obj1 = 0 ;
5130 PyObject * obj2 = 0 ;
5131 char * kwnames[] = {
5132 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5133 };
5134
5135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5137 if (!SWIG_IsOK(res1)) {
5138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5139 }
5140 arg1 = reinterpret_cast< wxSize * >(argp1);
5141 ecode2 = SWIG_AsVal_float(obj1, &val2);
5142 if (!SWIG_IsOK(ecode2)) {
5143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5144 }
5145 arg2 = static_cast< float >(val2);
5146 ecode3 = SWIG_AsVal_float(obj2, &val3);
5147 if (!SWIG_IsOK(ecode3)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5149 }
5150 arg3 = static_cast< float >(val3);
5151 {
5152 (arg1)->Scale(arg2,arg3);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int arg2 ;
5166 int arg3 ;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 int val2 ;
5170 int ecode2 = 0 ;
5171 int val3 ;
5172 int ecode3 = 0 ;
5173 PyObject * obj0 = 0 ;
5174 PyObject * obj1 = 0 ;
5175 PyObject * obj2 = 0 ;
5176 char * kwnames[] = {
5177 (char *) "self",(char *) "w",(char *) "h", NULL
5178 };
5179
5180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5182 if (!SWIG_IsOK(res1)) {
5183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5184 }
5185 arg1 = reinterpret_cast< wxSize * >(argp1);
5186 ecode2 = SWIG_AsVal_int(obj1, &val2);
5187 if (!SWIG_IsOK(ecode2)) {
5188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5189 }
5190 arg2 = static_cast< int >(val2);
5191 ecode3 = SWIG_AsVal_int(obj2, &val3);
5192 if (!SWIG_IsOK(ecode3)) {
5193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5194 }
5195 arg3 = static_cast< int >(val3);
5196 {
5197 (arg1)->Set(arg2,arg3);
5198 if (PyErr_Occurred()) SWIG_fail;
5199 }
5200 resultobj = SWIG_Py_Void();
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5208 PyObject *resultobj = 0;
5209 wxSize *arg1 = (wxSize *) 0 ;
5210 int arg2 ;
5211 void *argp1 = 0 ;
5212 int res1 = 0 ;
5213 int val2 ;
5214 int ecode2 = 0 ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 char * kwnames[] = {
5218 (char *) "self",(char *) "w", NULL
5219 };
5220
5221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5225 }
5226 arg1 = reinterpret_cast< wxSize * >(argp1);
5227 ecode2 = SWIG_AsVal_int(obj1, &val2);
5228 if (!SWIG_IsOK(ecode2)) {
5229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5230 }
5231 arg2 = static_cast< int >(val2);
5232 {
5233 (arg1)->SetWidth(arg2);
5234 if (PyErr_Occurred()) SWIG_fail;
5235 }
5236 resultobj = SWIG_Py_Void();
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj = 0;
5245 wxSize *arg1 = (wxSize *) 0 ;
5246 int arg2 ;
5247 void *argp1 = 0 ;
5248 int res1 = 0 ;
5249 int val2 ;
5250 int ecode2 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 PyObject * obj1 = 0 ;
5253 char * kwnames[] = {
5254 (char *) "self",(char *) "h", NULL
5255 };
5256
5257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5259 if (!SWIG_IsOK(res1)) {
5260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5261 }
5262 arg1 = reinterpret_cast< wxSize * >(argp1);
5263 ecode2 = SWIG_AsVal_int(obj1, &val2);
5264 if (!SWIG_IsOK(ecode2)) {
5265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5266 }
5267 arg2 = static_cast< int >(val2);
5268 {
5269 (arg1)->SetHeight(arg2);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_Py_Void();
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5280 PyObject *resultobj = 0;
5281 wxSize *arg1 = (wxSize *) 0 ;
5282 int result;
5283 void *argp1 = 0 ;
5284 int res1 = 0 ;
5285 PyObject *swig_obj[1] ;
5286
5287 if (!args) SWIG_fail;
5288 swig_obj[0] = args;
5289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5290 if (!SWIG_IsOK(res1)) {
5291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5292 }
5293 arg1 = reinterpret_cast< wxSize * >(argp1);
5294 {
5295 result = (int)((wxSize const *)arg1)->GetWidth();
5296 if (PyErr_Occurred()) SWIG_fail;
5297 }
5298 resultobj = SWIG_From_int(static_cast< int >(result));
5299 return resultobj;
5300 fail:
5301 return NULL;
5302 }
5303
5304
5305 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5306 PyObject *resultobj = 0;
5307 wxSize *arg1 = (wxSize *) 0 ;
5308 int result;
5309 void *argp1 = 0 ;
5310 int res1 = 0 ;
5311 PyObject *swig_obj[1] ;
5312
5313 if (!args) SWIG_fail;
5314 swig_obj[0] = args;
5315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5318 }
5319 arg1 = reinterpret_cast< wxSize * >(argp1);
5320 {
5321 result = (int)((wxSize const *)arg1)->GetHeight();
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 resultobj = SWIG_From_int(static_cast< int >(result));
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332 PyObject *resultobj = 0;
5333 wxSize *arg1 = (wxSize *) 0 ;
5334 bool result;
5335 void *argp1 = 0 ;
5336 int res1 = 0 ;
5337 PyObject *swig_obj[1] ;
5338
5339 if (!args) SWIG_fail;
5340 swig_obj[0] = args;
5341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5342 if (!SWIG_IsOK(res1)) {
5343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5344 }
5345 arg1 = reinterpret_cast< wxSize * >(argp1);
5346 {
5347 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5352 }
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj = 0;
5361 wxSize *arg1 = (wxSize *) 0 ;
5362 wxSize *arg2 = 0 ;
5363 void *argp1 = 0 ;
5364 int res1 = 0 ;
5365 wxSize temp2 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char * kwnames[] = {
5369 (char *) "self",(char *) "size", NULL
5370 };
5371
5372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5376 }
5377 arg1 = reinterpret_cast< wxSize * >(argp1);
5378 {
5379 arg2 = &temp2;
5380 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5381 }
5382 {
5383 (arg1)->SetDefaults((wxSize const &)*arg2);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 resultobj = SWIG_Py_Void();
5387 return resultobj;
5388 fail:
5389 return NULL;
5390 }
5391
5392
5393 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5394 PyObject *resultobj = 0;
5395 wxSize *arg1 = (wxSize *) 0 ;
5396 PyObject *result = 0 ;
5397 void *argp1 = 0 ;
5398 int res1 = 0 ;
5399 PyObject *swig_obj[1] ;
5400
5401 if (!args) SWIG_fail;
5402 swig_obj[0] = args;
5403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5404 if (!SWIG_IsOK(res1)) {
5405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5406 }
5407 arg1 = reinterpret_cast< wxSize * >(argp1);
5408 {
5409 result = (PyObject *)wxSize_Get(arg1);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 resultobj = result;
5413 return resultobj;
5414 fail:
5415 return NULL;
5416 }
5417
5418
5419 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 PyObject *obj;
5421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5422 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5423 return SWIG_Py_Void();
5424 }
5425
5426 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5427 return SWIG_Python_InitShadowInstance(args);
5428 }
5429
5430 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431 PyObject *resultobj = 0;
5432 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5433 double arg2 ;
5434 void *argp1 = 0 ;
5435 int res1 = 0 ;
5436 double val2 ;
5437 int ecode2 = 0 ;
5438 PyObject *swig_obj[2] ;
5439
5440 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5442 if (!SWIG_IsOK(res1)) {
5443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5444 }
5445 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5446 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5447 if (!SWIG_IsOK(ecode2)) {
5448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5449 }
5450 arg2 = static_cast< double >(val2);
5451 if (arg1) (arg1)->x = arg2;
5452
5453 resultobj = SWIG_Py_Void();
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *resultobj = 0;
5462 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5463 double result;
5464 void *argp1 = 0 ;
5465 int res1 = 0 ;
5466 PyObject *swig_obj[1] ;
5467
5468 if (!args) SWIG_fail;
5469 swig_obj[0] = args;
5470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5473 }
5474 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5475 result = (double) ((arg1)->x);
5476 resultobj = SWIG_From_double(static_cast< double >(result));
5477 return resultobj;
5478 fail:
5479 return NULL;
5480 }
5481
5482
5483 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5484 PyObject *resultobj = 0;
5485 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5486 double arg2 ;
5487 void *argp1 = 0 ;
5488 int res1 = 0 ;
5489 double val2 ;
5490 int ecode2 = 0 ;
5491 PyObject *swig_obj[2] ;
5492
5493 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5495 if (!SWIG_IsOK(res1)) {
5496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5497 }
5498 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5499 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5500 if (!SWIG_IsOK(ecode2)) {
5501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5502 }
5503 arg2 = static_cast< double >(val2);
5504 if (arg1) (arg1)->y = arg2;
5505
5506 resultobj = SWIG_Py_Void();
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5514 PyObject *resultobj = 0;
5515 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5516 double result;
5517 void *argp1 = 0 ;
5518 int res1 = 0 ;
5519 PyObject *swig_obj[1] ;
5520
5521 if (!args) SWIG_fail;
5522 swig_obj[0] = args;
5523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5524 if (!SWIG_IsOK(res1)) {
5525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5526 }
5527 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5528 result = (double) ((arg1)->y);
5529 resultobj = SWIG_From_double(static_cast< double >(result));
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5537 PyObject *resultobj = 0;
5538 double arg1 = (double) 0.0 ;
5539 double arg2 = (double) 0.0 ;
5540 wxRealPoint *result = 0 ;
5541 double val1 ;
5542 int ecode1 = 0 ;
5543 double val2 ;
5544 int ecode2 = 0 ;
5545 PyObject * obj0 = 0 ;
5546 PyObject * obj1 = 0 ;
5547 char * kwnames[] = {
5548 (char *) "x",(char *) "y", NULL
5549 };
5550
5551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5552 if (obj0) {
5553 ecode1 = SWIG_AsVal_double(obj0, &val1);
5554 if (!SWIG_IsOK(ecode1)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5556 }
5557 arg1 = static_cast< double >(val1);
5558 }
5559 if (obj1) {
5560 ecode2 = SWIG_AsVal_double(obj1, &val2);
5561 if (!SWIG_IsOK(ecode2)) {
5562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5563 }
5564 arg2 = static_cast< double >(val2);
5565 }
5566 {
5567 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 PyObject *resultobj = 0;
5579 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5580 void *argp1 = 0 ;
5581 int res1 = 0 ;
5582 PyObject *swig_obj[1] ;
5583
5584 if (!args) SWIG_fail;
5585 swig_obj[0] = args;
5586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5587 if (!SWIG_IsOK(res1)) {
5588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5589 }
5590 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5591 {
5592 delete arg1;
5593
5594 if (PyErr_Occurred()) SWIG_fail;
5595 }
5596 resultobj = SWIG_Py_Void();
5597 return resultobj;
5598 fail:
5599 return NULL;
5600 }
5601
5602
5603 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5604 PyObject *resultobj = 0;
5605 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5606 PyObject *arg2 = (PyObject *) 0 ;
5607 bool result;
5608 void *argp1 = 0 ;
5609 int res1 = 0 ;
5610 PyObject * obj0 = 0 ;
5611 PyObject * obj1 = 0 ;
5612 char * kwnames[] = {
5613 (char *) "self",(char *) "other", NULL
5614 };
5615
5616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5618 if (!SWIG_IsOK(res1)) {
5619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5620 }
5621 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5622 arg2 = obj1;
5623 {
5624 result = (bool)wxRealPoint___eq__(arg1,arg2);
5625 if (PyErr_Occurred()) SWIG_fail;
5626 }
5627 {
5628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5629 }
5630 return resultobj;
5631 fail:
5632 return NULL;
5633 }
5634
5635
5636 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5637 PyObject *resultobj = 0;
5638 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5639 PyObject *arg2 = (PyObject *) 0 ;
5640 bool result;
5641 void *argp1 = 0 ;
5642 int res1 = 0 ;
5643 PyObject * obj0 = 0 ;
5644 PyObject * obj1 = 0 ;
5645 char * kwnames[] = {
5646 (char *) "self",(char *) "other", NULL
5647 };
5648
5649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5651 if (!SWIG_IsOK(res1)) {
5652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5653 }
5654 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5655 arg2 = obj1;
5656 {
5657 result = (bool)wxRealPoint___ne__(arg1,arg2);
5658 if (PyErr_Occurred()) SWIG_fail;
5659 }
5660 {
5661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5662 }
5663 return resultobj;
5664 fail:
5665 return NULL;
5666 }
5667
5668
5669 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5670 PyObject *resultobj = 0;
5671 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5672 wxRealPoint *arg2 = 0 ;
5673 wxRealPoint result;
5674 void *argp1 = 0 ;
5675 int res1 = 0 ;
5676 wxRealPoint temp2 ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 char * kwnames[] = {
5680 (char *) "self",(char *) "pt", NULL
5681 };
5682
5683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5685 if (!SWIG_IsOK(res1)) {
5686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5687 }
5688 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5689 {
5690 arg2 = &temp2;
5691 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5692 }
5693 {
5694 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5705 PyObject *resultobj = 0;
5706 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5707 wxRealPoint *arg2 = 0 ;
5708 wxRealPoint result;
5709 void *argp1 = 0 ;
5710 int res1 = 0 ;
5711 wxRealPoint temp2 ;
5712 PyObject * obj0 = 0 ;
5713 PyObject * obj1 = 0 ;
5714 char * kwnames[] = {
5715 (char *) "self",(char *) "pt", NULL
5716 };
5717
5718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5720 if (!SWIG_IsOK(res1)) {
5721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5722 }
5723 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5724 {
5725 arg2 = &temp2;
5726 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5727 }
5728 {
5729 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5733 return resultobj;
5734 fail:
5735 return NULL;
5736 }
5737
5738
5739 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5740 PyObject *resultobj = 0;
5741 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5742 double arg2 ;
5743 double arg3 ;
5744 void *argp1 = 0 ;
5745 int res1 = 0 ;
5746 double val2 ;
5747 int ecode2 = 0 ;
5748 double val3 ;
5749 int ecode3 = 0 ;
5750 PyObject * obj0 = 0 ;
5751 PyObject * obj1 = 0 ;
5752 PyObject * obj2 = 0 ;
5753 char * kwnames[] = {
5754 (char *) "self",(char *) "x",(char *) "y", NULL
5755 };
5756
5757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5759 if (!SWIG_IsOK(res1)) {
5760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5761 }
5762 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5763 ecode2 = SWIG_AsVal_double(obj1, &val2);
5764 if (!SWIG_IsOK(ecode2)) {
5765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5766 }
5767 arg2 = static_cast< double >(val2);
5768 ecode3 = SWIG_AsVal_double(obj2, &val3);
5769 if (!SWIG_IsOK(ecode3)) {
5770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5771 }
5772 arg3 = static_cast< double >(val3);
5773 {
5774 wxRealPoint_Set(arg1,arg2,arg3);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_Py_Void();
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5785 PyObject *resultobj = 0;
5786 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5787 PyObject *result = 0 ;
5788 void *argp1 = 0 ;
5789 int res1 = 0 ;
5790 PyObject *swig_obj[1] ;
5791
5792 if (!args) SWIG_fail;
5793 swig_obj[0] = args;
5794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5799 {
5800 result = (PyObject *)wxRealPoint_Get(arg1);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 resultobj = result;
5804 return resultobj;
5805 fail:
5806 return NULL;
5807 }
5808
5809
5810 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5811 PyObject *obj;
5812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5813 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5814 return SWIG_Py_Void();
5815 }
5816
5817 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5818 return SWIG_Python_InitShadowInstance(args);
5819 }
5820
5821 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5822 PyObject *resultobj = 0;
5823 wxPoint *arg1 = (wxPoint *) 0 ;
5824 int arg2 ;
5825 void *argp1 = 0 ;
5826 int res1 = 0 ;
5827 int val2 ;
5828 int ecode2 = 0 ;
5829 PyObject *swig_obj[2] ;
5830
5831 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5833 if (!SWIG_IsOK(res1)) {
5834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5835 }
5836 arg1 = reinterpret_cast< wxPoint * >(argp1);
5837 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5838 if (!SWIG_IsOK(ecode2)) {
5839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5840 }
5841 arg2 = static_cast< int >(val2);
5842 if (arg1) (arg1)->x = arg2;
5843
5844 resultobj = SWIG_Py_Void();
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852 PyObject *resultobj = 0;
5853 wxPoint *arg1 = (wxPoint *) 0 ;
5854 int result;
5855 void *argp1 = 0 ;
5856 int res1 = 0 ;
5857 PyObject *swig_obj[1] ;
5858
5859 if (!args) SWIG_fail;
5860 swig_obj[0] = args;
5861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5864 }
5865 arg1 = reinterpret_cast< wxPoint * >(argp1);
5866 result = (int) ((arg1)->x);
5867 resultobj = SWIG_From_int(static_cast< int >(result));
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5875 PyObject *resultobj = 0;
5876 wxPoint *arg1 = (wxPoint *) 0 ;
5877 int arg2 ;
5878 void *argp1 = 0 ;
5879 int res1 = 0 ;
5880 int val2 ;
5881 int ecode2 = 0 ;
5882 PyObject *swig_obj[2] ;
5883
5884 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5886 if (!SWIG_IsOK(res1)) {
5887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5888 }
5889 arg1 = reinterpret_cast< wxPoint * >(argp1);
5890 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5891 if (!SWIG_IsOK(ecode2)) {
5892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5893 }
5894 arg2 = static_cast< int >(val2);
5895 if (arg1) (arg1)->y = arg2;
5896
5897 resultobj = SWIG_Py_Void();
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5905 PyObject *resultobj = 0;
5906 wxPoint *arg1 = (wxPoint *) 0 ;
5907 int result;
5908 void *argp1 = 0 ;
5909 int res1 = 0 ;
5910 PyObject *swig_obj[1] ;
5911
5912 if (!args) SWIG_fail;
5913 swig_obj[0] = args;
5914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5915 if (!SWIG_IsOK(res1)) {
5916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5917 }
5918 arg1 = reinterpret_cast< wxPoint * >(argp1);
5919 result = (int) ((arg1)->y);
5920 resultobj = SWIG_From_int(static_cast< int >(result));
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj = 0;
5929 int arg1 = (int) 0 ;
5930 int arg2 = (int) 0 ;
5931 wxPoint *result = 0 ;
5932 int val1 ;
5933 int ecode1 = 0 ;
5934 int val2 ;
5935 int ecode2 = 0 ;
5936 PyObject * obj0 = 0 ;
5937 PyObject * obj1 = 0 ;
5938 char * kwnames[] = {
5939 (char *) "x",(char *) "y", NULL
5940 };
5941
5942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5943 if (obj0) {
5944 ecode1 = SWIG_AsVal_int(obj0, &val1);
5945 if (!SWIG_IsOK(ecode1)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5947 }
5948 arg1 = static_cast< int >(val1);
5949 }
5950 if (obj1) {
5951 ecode2 = SWIG_AsVal_int(obj1, &val2);
5952 if (!SWIG_IsOK(ecode2)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5954 }
5955 arg2 = static_cast< int >(val2);
5956 }
5957 {
5958 result = (wxPoint *)new wxPoint(arg1,arg2);
5959 if (PyErr_Occurred()) SWIG_fail;
5960 }
5961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5962 return resultobj;
5963 fail:
5964 return NULL;
5965 }
5966
5967
5968 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5969 PyObject *resultobj = 0;
5970 wxPoint *arg1 = (wxPoint *) 0 ;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 PyObject *swig_obj[1] ;
5974
5975 if (!args) SWIG_fail;
5976 swig_obj[0] = args;
5977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5978 if (!SWIG_IsOK(res1)) {
5979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5980 }
5981 arg1 = reinterpret_cast< wxPoint * >(argp1);
5982 {
5983 delete arg1;
5984
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 resultobj = SWIG_Py_Void();
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj = 0;
5996 wxPoint *arg1 = (wxPoint *) 0 ;
5997 PyObject *arg2 = (PyObject *) 0 ;
5998 bool result;
5999 void *argp1 = 0 ;
6000 int res1 = 0 ;
6001 PyObject * obj0 = 0 ;
6002 PyObject * obj1 = 0 ;
6003 char * kwnames[] = {
6004 (char *) "self",(char *) "other", NULL
6005 };
6006
6007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6009 if (!SWIG_IsOK(res1)) {
6010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6011 }
6012 arg1 = reinterpret_cast< wxPoint * >(argp1);
6013 arg2 = obj1;
6014 {
6015 result = (bool)wxPoint___eq__(arg1,arg2);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 {
6019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6020 }
6021 return resultobj;
6022 fail:
6023 return NULL;
6024 }
6025
6026
6027 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6028 PyObject *resultobj = 0;
6029 wxPoint *arg1 = (wxPoint *) 0 ;
6030 PyObject *arg2 = (PyObject *) 0 ;
6031 bool result;
6032 void *argp1 = 0 ;
6033 int res1 = 0 ;
6034 PyObject * obj0 = 0 ;
6035 PyObject * obj1 = 0 ;
6036 char * kwnames[] = {
6037 (char *) "self",(char *) "other", NULL
6038 };
6039
6040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6042 if (!SWIG_IsOK(res1)) {
6043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6044 }
6045 arg1 = reinterpret_cast< wxPoint * >(argp1);
6046 arg2 = obj1;
6047 {
6048 result = (bool)wxPoint___ne__(arg1,arg2);
6049 if (PyErr_Occurred()) SWIG_fail;
6050 }
6051 {
6052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6053 }
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6061 PyObject *resultobj = 0;
6062 wxPoint *arg1 = (wxPoint *) 0 ;
6063 wxPoint *arg2 = 0 ;
6064 wxPoint result;
6065 void *argp1 = 0 ;
6066 int res1 = 0 ;
6067 wxPoint temp2 ;
6068 PyObject * obj0 = 0 ;
6069 PyObject * obj1 = 0 ;
6070 char * kwnames[] = {
6071 (char *) "self",(char *) "pt", NULL
6072 };
6073
6074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6076 if (!SWIG_IsOK(res1)) {
6077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6078 }
6079 arg1 = reinterpret_cast< wxPoint * >(argp1);
6080 {
6081 arg2 = &temp2;
6082 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6083 }
6084 {
6085 result = (arg1)->operator +((wxPoint const &)*arg2);
6086 if (PyErr_Occurred()) SWIG_fail;
6087 }
6088 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6089 return resultobj;
6090 fail:
6091 return NULL;
6092 }
6093
6094
6095 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6096 PyObject *resultobj = 0;
6097 wxPoint *arg1 = (wxPoint *) 0 ;
6098 wxPoint *arg2 = 0 ;
6099 wxPoint result;
6100 void *argp1 = 0 ;
6101 int res1 = 0 ;
6102 wxPoint temp2 ;
6103 PyObject * obj0 = 0 ;
6104 PyObject * obj1 = 0 ;
6105 char * kwnames[] = {
6106 (char *) "self",(char *) "pt", NULL
6107 };
6108
6109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6111 if (!SWIG_IsOK(res1)) {
6112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6113 }
6114 arg1 = reinterpret_cast< wxPoint * >(argp1);
6115 {
6116 arg2 = &temp2;
6117 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6118 }
6119 {
6120 result = (arg1)->operator -((wxPoint const &)*arg2);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6124 return resultobj;
6125 fail:
6126 return NULL;
6127 }
6128
6129
6130 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6131 PyObject *resultobj = 0;
6132 wxPoint *arg1 = (wxPoint *) 0 ;
6133 wxPoint *arg2 = 0 ;
6134 wxPoint *result = 0 ;
6135 void *argp1 = 0 ;
6136 int res1 = 0 ;
6137 wxPoint temp2 ;
6138 PyObject * obj0 = 0 ;
6139 PyObject * obj1 = 0 ;
6140 char * kwnames[] = {
6141 (char *) "self",(char *) "pt", NULL
6142 };
6143
6144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6146 if (!SWIG_IsOK(res1)) {
6147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6148 }
6149 arg1 = reinterpret_cast< wxPoint * >(argp1);
6150 {
6151 arg2 = &temp2;
6152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6153 }
6154 {
6155 {
6156 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6157 result = (wxPoint *) &_result_ref;
6158 }
6159 if (PyErr_Occurred()) SWIG_fail;
6160 }
6161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6162 return resultobj;
6163 fail:
6164 return NULL;
6165 }
6166
6167
6168 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6169 PyObject *resultobj = 0;
6170 wxPoint *arg1 = (wxPoint *) 0 ;
6171 wxPoint *arg2 = 0 ;
6172 wxPoint *result = 0 ;
6173 void *argp1 = 0 ;
6174 int res1 = 0 ;
6175 wxPoint temp2 ;
6176 PyObject * obj0 = 0 ;
6177 PyObject * obj1 = 0 ;
6178 char * kwnames[] = {
6179 (char *) "self",(char *) "pt", NULL
6180 };
6181
6182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6184 if (!SWIG_IsOK(res1)) {
6185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6186 }
6187 arg1 = reinterpret_cast< wxPoint * >(argp1);
6188 {
6189 arg2 = &temp2;
6190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6191 }
6192 {
6193 {
6194 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6195 result = (wxPoint *) &_result_ref;
6196 }
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxPoint *arg1 = (wxPoint *) 0 ;
6209 long arg2 ;
6210 long arg3 ;
6211 void *argp1 = 0 ;
6212 int res1 = 0 ;
6213 long val2 ;
6214 int ecode2 = 0 ;
6215 long val3 ;
6216 int ecode3 = 0 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 char * kwnames[] = {
6221 (char *) "self",(char *) "x",(char *) "y", NULL
6222 };
6223
6224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6226 if (!SWIG_IsOK(res1)) {
6227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6228 }
6229 arg1 = reinterpret_cast< wxPoint * >(argp1);
6230 ecode2 = SWIG_AsVal_long(obj1, &val2);
6231 if (!SWIG_IsOK(ecode2)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6233 }
6234 arg2 = static_cast< long >(val2);
6235 ecode3 = SWIG_AsVal_long(obj2, &val3);
6236 if (!SWIG_IsOK(ecode3)) {
6237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6238 }
6239 arg3 = static_cast< long >(val3);
6240 {
6241 wxPoint_Set(arg1,arg2,arg3);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 resultobj = SWIG_Py_Void();
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6252 PyObject *resultobj = 0;
6253 wxPoint *arg1 = (wxPoint *) 0 ;
6254 PyObject *result = 0 ;
6255 void *argp1 = 0 ;
6256 int res1 = 0 ;
6257 PyObject *swig_obj[1] ;
6258
6259 if (!args) SWIG_fail;
6260 swig_obj[0] = args;
6261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6262 if (!SWIG_IsOK(res1)) {
6263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6264 }
6265 arg1 = reinterpret_cast< wxPoint * >(argp1);
6266 {
6267 result = (PyObject *)wxPoint_Get(arg1);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = result;
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *obj;
6279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6280 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6281 return SWIG_Py_Void();
6282 }
6283
6284 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6285 return SWIG_Python_InitShadowInstance(args);
6286 }
6287
6288 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj = 0;
6290 int arg1 = (int) 0 ;
6291 int arg2 = (int) 0 ;
6292 int arg3 = (int) 0 ;
6293 int arg4 = (int) 0 ;
6294 wxRect *result = 0 ;
6295 int val1 ;
6296 int ecode1 = 0 ;
6297 int val2 ;
6298 int ecode2 = 0 ;
6299 int val3 ;
6300 int ecode3 = 0 ;
6301 int val4 ;
6302 int ecode4 = 0 ;
6303 PyObject * obj0 = 0 ;
6304 PyObject * obj1 = 0 ;
6305 PyObject * obj2 = 0 ;
6306 PyObject * obj3 = 0 ;
6307 char * kwnames[] = {
6308 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6309 };
6310
6311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6312 if (obj0) {
6313 ecode1 = SWIG_AsVal_int(obj0, &val1);
6314 if (!SWIG_IsOK(ecode1)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6316 }
6317 arg1 = static_cast< int >(val1);
6318 }
6319 if (obj1) {
6320 ecode2 = SWIG_AsVal_int(obj1, &val2);
6321 if (!SWIG_IsOK(ecode2)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6323 }
6324 arg2 = static_cast< int >(val2);
6325 }
6326 if (obj2) {
6327 ecode3 = SWIG_AsVal_int(obj2, &val3);
6328 if (!SWIG_IsOK(ecode3)) {
6329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6330 }
6331 arg3 = static_cast< int >(val3);
6332 }
6333 if (obj3) {
6334 ecode4 = SWIG_AsVal_int(obj3, &val4);
6335 if (!SWIG_IsOK(ecode4)) {
6336 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6337 }
6338 arg4 = static_cast< int >(val4);
6339 }
6340 {
6341 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6342 if (PyErr_Occurred()) SWIG_fail;
6343 }
6344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6345 return resultobj;
6346 fail:
6347 return NULL;
6348 }
6349
6350
6351 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj = 0;
6353 wxPoint *arg1 = 0 ;
6354 wxPoint *arg2 = 0 ;
6355 wxRect *result = 0 ;
6356 wxPoint temp1 ;
6357 wxPoint temp2 ;
6358 PyObject * obj0 = 0 ;
6359 PyObject * obj1 = 0 ;
6360 char * kwnames[] = {
6361 (char *) "topLeft",(char *) "bottomRight", NULL
6362 };
6363
6364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6365 {
6366 arg1 = &temp1;
6367 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6368 }
6369 {
6370 arg2 = &temp2;
6371 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6372 }
6373 {
6374 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6375 if (PyErr_Occurred()) SWIG_fail;
6376 }
6377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj = 0;
6386 wxPoint *arg1 = 0 ;
6387 wxSize *arg2 = 0 ;
6388 wxRect *result = 0 ;
6389 wxPoint temp1 ;
6390 wxSize temp2 ;
6391 PyObject * obj0 = 0 ;
6392 PyObject * obj1 = 0 ;
6393 char * kwnames[] = {
6394 (char *) "pos",(char *) "size", NULL
6395 };
6396
6397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6398 {
6399 arg1 = &temp1;
6400 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6401 }
6402 {
6403 arg2 = &temp2;
6404 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6405 }
6406 {
6407 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = 0;
6419 wxSize *arg1 = 0 ;
6420 wxRect *result = 0 ;
6421 wxSize temp1 ;
6422 PyObject * obj0 = 0 ;
6423 char * kwnames[] = {
6424 (char *) "size", NULL
6425 };
6426
6427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6428 {
6429 arg1 = &temp1;
6430 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6431 }
6432 {
6433 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6444 PyObject *resultobj = 0;
6445 wxRect *arg1 = (wxRect *) 0 ;
6446 void *argp1 = 0 ;
6447 int res1 = 0 ;
6448 PyObject *swig_obj[1] ;
6449
6450 if (!args) SWIG_fail;
6451 swig_obj[0] = args;
6452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 {
6458 delete arg1;
6459
6460 if (PyErr_Occurred()) SWIG_fail;
6461 }
6462 resultobj = SWIG_Py_Void();
6463 return resultobj;
6464 fail:
6465 return NULL;
6466 }
6467
6468
6469 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6470 PyObject *resultobj = 0;
6471 wxRect *arg1 = (wxRect *) 0 ;
6472 int result;
6473 void *argp1 = 0 ;
6474 int res1 = 0 ;
6475 PyObject *swig_obj[1] ;
6476
6477 if (!args) SWIG_fail;
6478 swig_obj[0] = args;
6479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6480 if (!SWIG_IsOK(res1)) {
6481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6482 }
6483 arg1 = reinterpret_cast< wxRect * >(argp1);
6484 {
6485 result = (int)((wxRect const *)arg1)->GetX();
6486 if (PyErr_Occurred()) SWIG_fail;
6487 }
6488 resultobj = SWIG_From_int(static_cast< int >(result));
6489 return resultobj;
6490 fail:
6491 return NULL;
6492 }
6493
6494
6495 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6496 PyObject *resultobj = 0;
6497 wxRect *arg1 = (wxRect *) 0 ;
6498 int arg2 ;
6499 void *argp1 = 0 ;
6500 int res1 = 0 ;
6501 int val2 ;
6502 int ecode2 = 0 ;
6503 PyObject * obj0 = 0 ;
6504 PyObject * obj1 = 0 ;
6505 char * kwnames[] = {
6506 (char *) "self",(char *) "x", NULL
6507 };
6508
6509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6511 if (!SWIG_IsOK(res1)) {
6512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6513 }
6514 arg1 = reinterpret_cast< wxRect * >(argp1);
6515 ecode2 = SWIG_AsVal_int(obj1, &val2);
6516 if (!SWIG_IsOK(ecode2)) {
6517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6518 }
6519 arg2 = static_cast< int >(val2);
6520 {
6521 (arg1)->SetX(arg2);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 resultobj = SWIG_Py_Void();
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6532 PyObject *resultobj = 0;
6533 wxRect *arg1 = (wxRect *) 0 ;
6534 int result;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 PyObject *swig_obj[1] ;
6538
6539 if (!args) SWIG_fail;
6540 swig_obj[0] = args;
6541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6542 if (!SWIG_IsOK(res1)) {
6543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6544 }
6545 arg1 = reinterpret_cast< wxRect * >(argp1);
6546 {
6547 result = (int)(arg1)->GetY();
6548 if (PyErr_Occurred()) SWIG_fail;
6549 }
6550 resultobj = SWIG_From_int(static_cast< int >(result));
6551 return resultobj;
6552 fail:
6553 return NULL;
6554 }
6555
6556
6557 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6558 PyObject *resultobj = 0;
6559 wxRect *arg1 = (wxRect *) 0 ;
6560 int arg2 ;
6561 void *argp1 = 0 ;
6562 int res1 = 0 ;
6563 int val2 ;
6564 int ecode2 = 0 ;
6565 PyObject * obj0 = 0 ;
6566 PyObject * obj1 = 0 ;
6567 char * kwnames[] = {
6568 (char *) "self",(char *) "y", NULL
6569 };
6570
6571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6573 if (!SWIG_IsOK(res1)) {
6574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6575 }
6576 arg1 = reinterpret_cast< wxRect * >(argp1);
6577 ecode2 = SWIG_AsVal_int(obj1, &val2);
6578 if (!SWIG_IsOK(ecode2)) {
6579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6580 }
6581 arg2 = static_cast< int >(val2);
6582 {
6583 (arg1)->SetY(arg2);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_Py_Void();
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6594 PyObject *resultobj = 0;
6595 wxRect *arg1 = (wxRect *) 0 ;
6596 int result;
6597 void *argp1 = 0 ;
6598 int res1 = 0 ;
6599 PyObject *swig_obj[1] ;
6600
6601 if (!args) SWIG_fail;
6602 swig_obj[0] = args;
6603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6604 if (!SWIG_IsOK(res1)) {
6605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6606 }
6607 arg1 = reinterpret_cast< wxRect * >(argp1);
6608 {
6609 result = (int)((wxRect const *)arg1)->GetWidth();
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 resultobj = SWIG_From_int(static_cast< int >(result));
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj = 0;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 int arg2 ;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 int val2 ;
6626 int ecode2 = 0 ;
6627 PyObject * obj0 = 0 ;
6628 PyObject * obj1 = 0 ;
6629 char * kwnames[] = {
6630 (char *) "self",(char *) "w", NULL
6631 };
6632
6633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6635 if (!SWIG_IsOK(res1)) {
6636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6637 }
6638 arg1 = reinterpret_cast< wxRect * >(argp1);
6639 ecode2 = SWIG_AsVal_int(obj1, &val2);
6640 if (!SWIG_IsOK(ecode2)) {
6641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6642 }
6643 arg2 = static_cast< int >(val2);
6644 {
6645 (arg1)->SetWidth(arg2);
6646 if (PyErr_Occurred()) SWIG_fail;
6647 }
6648 resultobj = SWIG_Py_Void();
6649 return resultobj;
6650 fail:
6651 return NULL;
6652 }
6653
6654
6655 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6656 PyObject *resultobj = 0;
6657 wxRect *arg1 = (wxRect *) 0 ;
6658 int result;
6659 void *argp1 = 0 ;
6660 int res1 = 0 ;
6661 PyObject *swig_obj[1] ;
6662
6663 if (!args) SWIG_fail;
6664 swig_obj[0] = args;
6665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6666 if (!SWIG_IsOK(res1)) {
6667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6668 }
6669 arg1 = reinterpret_cast< wxRect * >(argp1);
6670 {
6671 result = (int)((wxRect const *)arg1)->GetHeight();
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 resultobj = SWIG_From_int(static_cast< int >(result));
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 int arg2 ;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 int val2 ;
6688 int ecode2 = 0 ;
6689 PyObject * obj0 = 0 ;
6690 PyObject * obj1 = 0 ;
6691 char * kwnames[] = {
6692 (char *) "self",(char *) "h", NULL
6693 };
6694
6695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 ecode2 = SWIG_AsVal_int(obj1, &val2);
6702 if (!SWIG_IsOK(ecode2)) {
6703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6704 }
6705 arg2 = static_cast< int >(val2);
6706 {
6707 (arg1)->SetHeight(arg2);
6708 if (PyErr_Occurred()) SWIG_fail;
6709 }
6710 resultobj = SWIG_Py_Void();
6711 return resultobj;
6712 fail:
6713 return NULL;
6714 }
6715
6716
6717 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6718 PyObject *resultobj = 0;
6719 wxRect *arg1 = (wxRect *) 0 ;
6720 wxPoint result;
6721 void *argp1 = 0 ;
6722 int res1 = 0 ;
6723 PyObject *swig_obj[1] ;
6724
6725 if (!args) SWIG_fail;
6726 swig_obj[0] = args;
6727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6728 if (!SWIG_IsOK(res1)) {
6729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6730 }
6731 arg1 = reinterpret_cast< wxRect * >(argp1);
6732 {
6733 result = ((wxRect const *)arg1)->GetPosition();
6734 if (PyErr_Occurred()) SWIG_fail;
6735 }
6736 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6744 PyObject *resultobj = 0;
6745 wxRect *arg1 = (wxRect *) 0 ;
6746 wxPoint *arg2 = 0 ;
6747 void *argp1 = 0 ;
6748 int res1 = 0 ;
6749 wxPoint temp2 ;
6750 PyObject * obj0 = 0 ;
6751 PyObject * obj1 = 0 ;
6752 char * kwnames[] = {
6753 (char *) "self",(char *) "p", NULL
6754 };
6755
6756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6758 if (!SWIG_IsOK(res1)) {
6759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6760 }
6761 arg1 = reinterpret_cast< wxRect * >(argp1);
6762 {
6763 arg2 = &temp2;
6764 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6765 }
6766 {
6767 (arg1)->SetPosition((wxPoint const &)*arg2);
6768 if (PyErr_Occurred()) SWIG_fail;
6769 }
6770 resultobj = SWIG_Py_Void();
6771 return resultobj;
6772 fail:
6773 return NULL;
6774 }
6775
6776
6777 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6778 PyObject *resultobj = 0;
6779 wxRect *arg1 = (wxRect *) 0 ;
6780 wxSize result;
6781 void *argp1 = 0 ;
6782 int res1 = 0 ;
6783 PyObject *swig_obj[1] ;
6784
6785 if (!args) SWIG_fail;
6786 swig_obj[0] = args;
6787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6788 if (!SWIG_IsOK(res1)) {
6789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6790 }
6791 arg1 = reinterpret_cast< wxRect * >(argp1);
6792 {
6793 result = ((wxRect const *)arg1)->GetSize();
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6804 PyObject *resultobj = 0;
6805 wxRect *arg1 = (wxRect *) 0 ;
6806 wxSize *arg2 = 0 ;
6807 void *argp1 = 0 ;
6808 int res1 = 0 ;
6809 wxSize temp2 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char * kwnames[] = {
6813 (char *) "self",(char *) "s", NULL
6814 };
6815
6816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6818 if (!SWIG_IsOK(res1)) {
6819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6820 }
6821 arg1 = reinterpret_cast< wxRect * >(argp1);
6822 {
6823 arg2 = &temp2;
6824 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6825 }
6826 {
6827 (arg1)->SetSize((wxSize const &)*arg2);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_Py_Void();
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 wxRect *arg1 = (wxRect *) 0 ;
6840 bool result;
6841 void *argp1 = 0 ;
6842 int res1 = 0 ;
6843 PyObject *swig_obj[1] ;
6844
6845 if (!args) SWIG_fail;
6846 swig_obj[0] = args;
6847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6848 if (!SWIG_IsOK(res1)) {
6849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6850 }
6851 arg1 = reinterpret_cast< wxRect * >(argp1);
6852 {
6853 result = (bool)((wxRect const *)arg1)->IsEmpty();
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 {
6857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6858 }
6859 return resultobj;
6860 fail:
6861 return NULL;
6862 }
6863
6864
6865 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6866 PyObject *resultobj = 0;
6867 wxRect *arg1 = (wxRect *) 0 ;
6868 wxPoint result;
6869 void *argp1 = 0 ;
6870 int res1 = 0 ;
6871 PyObject *swig_obj[1] ;
6872
6873 if (!args) SWIG_fail;
6874 swig_obj[0] = args;
6875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6876 if (!SWIG_IsOK(res1)) {
6877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6878 }
6879 arg1 = reinterpret_cast< wxRect * >(argp1);
6880 {
6881 result = ((wxRect const *)arg1)->GetTopLeft();
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6892 PyObject *resultobj = 0;
6893 wxRect *arg1 = (wxRect *) 0 ;
6894 wxPoint *arg2 = 0 ;
6895 void *argp1 = 0 ;
6896 int res1 = 0 ;
6897 wxPoint temp2 ;
6898 PyObject * obj0 = 0 ;
6899 PyObject * obj1 = 0 ;
6900 char * kwnames[] = {
6901 (char *) "self",(char *) "p", NULL
6902 };
6903
6904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6906 if (!SWIG_IsOK(res1)) {
6907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6908 }
6909 arg1 = reinterpret_cast< wxRect * >(argp1);
6910 {
6911 arg2 = &temp2;
6912 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6913 }
6914 {
6915 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 resultobj = SWIG_Py_Void();
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6926 PyObject *resultobj = 0;
6927 wxRect *arg1 = (wxRect *) 0 ;
6928 wxPoint result;
6929 void *argp1 = 0 ;
6930 int res1 = 0 ;
6931 PyObject *swig_obj[1] ;
6932
6933 if (!args) SWIG_fail;
6934 swig_obj[0] = args;
6935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 {
6941 result = ((wxRect const *)arg1)->GetBottomRight();
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj = 0;
6953 wxRect *arg1 = (wxRect *) 0 ;
6954 wxPoint *arg2 = 0 ;
6955 void *argp1 = 0 ;
6956 int res1 = 0 ;
6957 wxPoint temp2 ;
6958 PyObject * obj0 = 0 ;
6959 PyObject * obj1 = 0 ;
6960 char * kwnames[] = {
6961 (char *) "self",(char *) "p", NULL
6962 };
6963
6964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6966 if (!SWIG_IsOK(res1)) {
6967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6968 }
6969 arg1 = reinterpret_cast< wxRect * >(argp1);
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_Py_Void();
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6986 PyObject *resultobj = 0;
6987 wxRect *arg1 = (wxRect *) 0 ;
6988 wxPoint result;
6989 void *argp1 = 0 ;
6990 int res1 = 0 ;
6991 PyObject *swig_obj[1] ;
6992
6993 if (!args) SWIG_fail;
6994 swig_obj[0] = args;
6995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6998 }
6999 arg1 = reinterpret_cast< wxRect * >(argp1);
7000 {
7001 result = ((wxRect const *)arg1)->GetTopRight();
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj = 0;
7013 wxRect *arg1 = (wxRect *) 0 ;
7014 wxPoint *arg2 = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 wxPoint temp2 ;
7018 PyObject * obj0 = 0 ;
7019 PyObject * obj1 = 0 ;
7020 char * kwnames[] = {
7021 (char *) "self",(char *) "p", NULL
7022 };
7023
7024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7026 if (!SWIG_IsOK(res1)) {
7027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7028 }
7029 arg1 = reinterpret_cast< wxRect * >(argp1);
7030 {
7031 arg2 = &temp2;
7032 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7033 }
7034 {
7035 (arg1)->SetTopRight((wxPoint const &)*arg2);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 resultobj = SWIG_Py_Void();
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7046 PyObject *resultobj = 0;
7047 wxRect *arg1 = (wxRect *) 0 ;
7048 wxPoint result;
7049 void *argp1 = 0 ;
7050 int res1 = 0 ;
7051 PyObject *swig_obj[1] ;
7052
7053 if (!args) SWIG_fail;
7054 swig_obj[0] = args;
7055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7056 if (!SWIG_IsOK(res1)) {
7057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7058 }
7059 arg1 = reinterpret_cast< wxRect * >(argp1);
7060 {
7061 result = ((wxRect const *)arg1)->GetBottomLeft();
7062 if (PyErr_Occurred()) SWIG_fail;
7063 }
7064 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7065 return resultobj;
7066 fail:
7067 return NULL;
7068 }
7069
7070
7071 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7072 PyObject *resultobj = 0;
7073 wxRect *arg1 = (wxRect *) 0 ;
7074 wxPoint *arg2 = 0 ;
7075 void *argp1 = 0 ;
7076 int res1 = 0 ;
7077 wxPoint temp2 ;
7078 PyObject * obj0 = 0 ;
7079 PyObject * obj1 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "self",(char *) "p", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 {
7091 arg2 = &temp2;
7092 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7093 }
7094 {
7095 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_Py_Void();
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 PyObject *resultobj = 0;
7107 wxRect *arg1 = (wxRect *) 0 ;
7108 int result;
7109 void *argp1 = 0 ;
7110 int res1 = 0 ;
7111 PyObject *swig_obj[1] ;
7112
7113 if (!args) SWIG_fail;
7114 swig_obj[0] = args;
7115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7116 if (!SWIG_IsOK(res1)) {
7117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7118 }
7119 arg1 = reinterpret_cast< wxRect * >(argp1);
7120 {
7121 result = (int)((wxRect const *)arg1)->GetLeft();
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 resultobj = SWIG_From_int(static_cast< int >(result));
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7132 PyObject *resultobj = 0;
7133 wxRect *arg1 = (wxRect *) 0 ;
7134 int result;
7135 void *argp1 = 0 ;
7136 int res1 = 0 ;
7137 PyObject *swig_obj[1] ;
7138
7139 if (!args) SWIG_fail;
7140 swig_obj[0] = args;
7141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7142 if (!SWIG_IsOK(res1)) {
7143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7144 }
7145 arg1 = reinterpret_cast< wxRect * >(argp1);
7146 {
7147 result = (int)((wxRect const *)arg1)->GetTop();
7148 if (PyErr_Occurred()) SWIG_fail;
7149 }
7150 resultobj = SWIG_From_int(static_cast< int >(result));
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7158 PyObject *resultobj = 0;
7159 wxRect *arg1 = (wxRect *) 0 ;
7160 int result;
7161 void *argp1 = 0 ;
7162 int res1 = 0 ;
7163 PyObject *swig_obj[1] ;
7164
7165 if (!args) SWIG_fail;
7166 swig_obj[0] = args;
7167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7168 if (!SWIG_IsOK(res1)) {
7169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7170 }
7171 arg1 = reinterpret_cast< wxRect * >(argp1);
7172 {
7173 result = (int)((wxRect const *)arg1)->GetBottom();
7174 if (PyErr_Occurred()) SWIG_fail;
7175 }
7176 resultobj = SWIG_From_int(static_cast< int >(result));
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7184 PyObject *resultobj = 0;
7185 wxRect *arg1 = (wxRect *) 0 ;
7186 int result;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 PyObject *swig_obj[1] ;
7190
7191 if (!args) SWIG_fail;
7192 swig_obj[0] = args;
7193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7194 if (!SWIG_IsOK(res1)) {
7195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7196 }
7197 arg1 = reinterpret_cast< wxRect * >(argp1);
7198 {
7199 result = (int)((wxRect const *)arg1)->GetRight();
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 resultobj = SWIG_From_int(static_cast< int >(result));
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj = 0;
7211 wxRect *arg1 = (wxRect *) 0 ;
7212 int arg2 ;
7213 void *argp1 = 0 ;
7214 int res1 = 0 ;
7215 int val2 ;
7216 int ecode2 = 0 ;
7217 PyObject * obj0 = 0 ;
7218 PyObject * obj1 = 0 ;
7219 char * kwnames[] = {
7220 (char *) "self",(char *) "left", NULL
7221 };
7222
7223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7225 if (!SWIG_IsOK(res1)) {
7226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7227 }
7228 arg1 = reinterpret_cast< wxRect * >(argp1);
7229 ecode2 = SWIG_AsVal_int(obj1, &val2);
7230 if (!SWIG_IsOK(ecode2)) {
7231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7232 }
7233 arg2 = static_cast< int >(val2);
7234 {
7235 (arg1)->SetLeft(arg2);
7236 if (PyErr_Occurred()) SWIG_fail;
7237 }
7238 resultobj = SWIG_Py_Void();
7239 return resultobj;
7240 fail:
7241 return NULL;
7242 }
7243
7244
7245 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7246 PyObject *resultobj = 0;
7247 wxRect *arg1 = (wxRect *) 0 ;
7248 int arg2 ;
7249 void *argp1 = 0 ;
7250 int res1 = 0 ;
7251 int val2 ;
7252 int ecode2 = 0 ;
7253 PyObject * obj0 = 0 ;
7254 PyObject * obj1 = 0 ;
7255 char * kwnames[] = {
7256 (char *) "self",(char *) "right", NULL
7257 };
7258
7259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7261 if (!SWIG_IsOK(res1)) {
7262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7263 }
7264 arg1 = reinterpret_cast< wxRect * >(argp1);
7265 ecode2 = SWIG_AsVal_int(obj1, &val2);
7266 if (!SWIG_IsOK(ecode2)) {
7267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7268 }
7269 arg2 = static_cast< int >(val2);
7270 {
7271 (arg1)->SetRight(arg2);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 resultobj = SWIG_Py_Void();
7275 return resultobj;
7276 fail:
7277 return NULL;
7278 }
7279
7280
7281 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7282 PyObject *resultobj = 0;
7283 wxRect *arg1 = (wxRect *) 0 ;
7284 int arg2 ;
7285 void *argp1 = 0 ;
7286 int res1 = 0 ;
7287 int val2 ;
7288 int ecode2 = 0 ;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 char * kwnames[] = {
7292 (char *) "self",(char *) "top", NULL
7293 };
7294
7295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7297 if (!SWIG_IsOK(res1)) {
7298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7299 }
7300 arg1 = reinterpret_cast< wxRect * >(argp1);
7301 ecode2 = SWIG_AsVal_int(obj1, &val2);
7302 if (!SWIG_IsOK(ecode2)) {
7303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7304 }
7305 arg2 = static_cast< int >(val2);
7306 {
7307 (arg1)->SetTop(arg2);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 resultobj = SWIG_Py_Void();
7311 return resultobj;
7312 fail:
7313 return NULL;
7314 }
7315
7316
7317 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7318 PyObject *resultobj = 0;
7319 wxRect *arg1 = (wxRect *) 0 ;
7320 int arg2 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 int val2 ;
7324 int ecode2 = 0 ;
7325 PyObject * obj0 = 0 ;
7326 PyObject * obj1 = 0 ;
7327 char * kwnames[] = {
7328 (char *) "self",(char *) "bottom", NULL
7329 };
7330
7331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7333 if (!SWIG_IsOK(res1)) {
7334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7335 }
7336 arg1 = reinterpret_cast< wxRect * >(argp1);
7337 ecode2 = SWIG_AsVal_int(obj1, &val2);
7338 if (!SWIG_IsOK(ecode2)) {
7339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7340 }
7341 arg2 = static_cast< int >(val2);
7342 {
7343 (arg1)->SetBottom(arg2);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 resultobj = SWIG_Py_Void();
7347 return resultobj;
7348 fail:
7349 return NULL;
7350 }
7351
7352
7353 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj = 0;
7355 wxRect *arg1 = (wxRect *) 0 ;
7356 int arg2 ;
7357 int arg3 ;
7358 wxRect result;
7359 void *argp1 = 0 ;
7360 int res1 = 0 ;
7361 int val2 ;
7362 int ecode2 = 0 ;
7363 int val3 ;
7364 int ecode3 = 0 ;
7365 PyObject * obj0 = 0 ;
7366 PyObject * obj1 = 0 ;
7367 PyObject * obj2 = 0 ;
7368 char * kwnames[] = {
7369 (char *) "self",(char *) "dx",(char *) "dy", NULL
7370 };
7371
7372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7374 if (!SWIG_IsOK(res1)) {
7375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7376 }
7377 arg1 = reinterpret_cast< wxRect * >(argp1);
7378 ecode2 = SWIG_AsVal_int(obj1, &val2);
7379 if (!SWIG_IsOK(ecode2)) {
7380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7381 }
7382 arg2 = static_cast< int >(val2);
7383 ecode3 = SWIG_AsVal_int(obj2, &val3);
7384 if (!SWIG_IsOK(ecode3)) {
7385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7386 }
7387 arg3 = static_cast< int >(val3);
7388 {
7389 result = (arg1)->Inflate(arg2,arg3);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxRect *arg1 = (wxRect *) 0 ;
7402 int arg2 ;
7403 int arg3 ;
7404 wxRect *result = 0 ;
7405 void *argp1 = 0 ;
7406 int res1 = 0 ;
7407 int val2 ;
7408 int ecode2 = 0 ;
7409 int val3 ;
7410 int ecode3 = 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 PyObject * obj2 = 0 ;
7414 char * kwnames[] = {
7415 (char *) "self",(char *) "dx",(char *) "dy", NULL
7416 };
7417
7418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7422 }
7423 arg1 = reinterpret_cast< wxRect * >(argp1);
7424 ecode2 = SWIG_AsVal_int(obj1, &val2);
7425 if (!SWIG_IsOK(ecode2)) {
7426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7427 }
7428 arg2 = static_cast< int >(val2);
7429 ecode3 = SWIG_AsVal_int(obj2, &val3);
7430 if (!SWIG_IsOK(ecode3)) {
7431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7432 }
7433 arg3 = static_cast< int >(val3);
7434 {
7435 {
7436 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7437 result = (wxRect *) &_result_ref;
7438 }
7439 if (PyErr_Occurred()) SWIG_fail;
7440 }
7441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 int arg2 ;
7452 int arg3 ;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 int val2 ;
7456 int ecode2 = 0 ;
7457 int val3 ;
7458 int ecode3 = 0 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 PyObject * obj2 = 0 ;
7462 char * kwnames[] = {
7463 (char *) "self",(char *) "dx",(char *) "dy", NULL
7464 };
7465
7466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7470 }
7471 arg1 = reinterpret_cast< wxRect * >(argp1);
7472 ecode2 = SWIG_AsVal_int(obj1, &val2);
7473 if (!SWIG_IsOK(ecode2)) {
7474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7475 }
7476 arg2 = static_cast< int >(val2);
7477 ecode3 = SWIG_AsVal_int(obj2, &val3);
7478 if (!SWIG_IsOK(ecode3)) {
7479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7480 }
7481 arg3 = static_cast< int >(val3);
7482 {
7483 (arg1)->Offset(arg2,arg3);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 resultobj = SWIG_Py_Void();
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxRect *arg1 = (wxRect *) 0 ;
7496 wxPoint *arg2 = 0 ;
7497 void *argp1 = 0 ;
7498 int res1 = 0 ;
7499 wxPoint temp2 ;
7500 PyObject * obj0 = 0 ;
7501 PyObject * obj1 = 0 ;
7502 char * kwnames[] = {
7503 (char *) "self",(char *) "pt", NULL
7504 };
7505
7506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7508 if (!SWIG_IsOK(res1)) {
7509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7510 }
7511 arg1 = reinterpret_cast< wxRect * >(argp1);
7512 {
7513 arg2 = &temp2;
7514 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7515 }
7516 {
7517 (arg1)->Offset((wxPoint const &)*arg2);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 resultobj = SWIG_Py_Void();
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj = 0;
7529 wxRect *arg1 = (wxRect *) 0 ;
7530 wxRect *arg2 = 0 ;
7531 wxRect result;
7532 void *argp1 = 0 ;
7533 int res1 = 0 ;
7534 wxRect temp2 ;
7535 PyObject * obj0 = 0 ;
7536 PyObject * obj1 = 0 ;
7537 char * kwnames[] = {
7538 (char *) "self",(char *) "rect", NULL
7539 };
7540
7541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7545 }
7546 arg1 = reinterpret_cast< wxRect * >(argp1);
7547 {
7548 arg2 = &temp2;
7549 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7550 }
7551 {
7552 result = (arg1)->Intersect((wxRect const &)*arg2);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj = 0;
7564 wxRect *arg1 = (wxRect *) 0 ;
7565 wxRect *arg2 = 0 ;
7566 wxRect result;
7567 void *argp1 = 0 ;
7568 int res1 = 0 ;
7569 wxRect temp2 ;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char * kwnames[] = {
7573 (char *) "self",(char *) "rect", NULL
7574 };
7575
7576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7578 if (!SWIG_IsOK(res1)) {
7579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7580 }
7581 arg1 = reinterpret_cast< wxRect * >(argp1);
7582 {
7583 arg2 = &temp2;
7584 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7585 }
7586 {
7587 result = (arg1)->Union((wxRect const &)*arg2);
7588 if (PyErr_Occurred()) SWIG_fail;
7589 }
7590 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7591 return resultobj;
7592 fail:
7593 return NULL;
7594 }
7595
7596
7597 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7598 PyObject *resultobj = 0;
7599 wxRect *arg1 = (wxRect *) 0 ;
7600 wxRect *arg2 = 0 ;
7601 wxRect result;
7602 void *argp1 = 0 ;
7603 int res1 = 0 ;
7604 wxRect temp2 ;
7605 PyObject * obj0 = 0 ;
7606 PyObject * obj1 = 0 ;
7607 char * kwnames[] = {
7608 (char *) "self",(char *) "rect", NULL
7609 };
7610
7611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7613 if (!SWIG_IsOK(res1)) {
7614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7615 }
7616 arg1 = reinterpret_cast< wxRect * >(argp1);
7617 {
7618 arg2 = &temp2;
7619 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7620 }
7621 {
7622 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7623 if (PyErr_Occurred()) SWIG_fail;
7624 }
7625 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj = 0;
7634 wxRect *arg1 = (wxRect *) 0 ;
7635 wxRect *arg2 = 0 ;
7636 wxRect *result = 0 ;
7637 void *argp1 = 0 ;
7638 int res1 = 0 ;
7639 wxRect temp2 ;
7640 PyObject * obj0 = 0 ;
7641 PyObject * obj1 = 0 ;
7642 char * kwnames[] = {
7643 (char *) "self",(char *) "rect", NULL
7644 };
7645
7646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7648 if (!SWIG_IsOK(res1)) {
7649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7650 }
7651 arg1 = reinterpret_cast< wxRect * >(argp1);
7652 {
7653 arg2 = &temp2;
7654 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7655 }
7656 {
7657 {
7658 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7659 result = (wxRect *) &_result_ref;
7660 }
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = 0;
7672 wxRect *arg1 = (wxRect *) 0 ;
7673 PyObject *arg2 = (PyObject *) 0 ;
7674 bool result;
7675 void *argp1 = 0 ;
7676 int res1 = 0 ;
7677 PyObject * obj0 = 0 ;
7678 PyObject * obj1 = 0 ;
7679 char * kwnames[] = {
7680 (char *) "self",(char *) "other", NULL
7681 };
7682
7683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7685 if (!SWIG_IsOK(res1)) {
7686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7687 }
7688 arg1 = reinterpret_cast< wxRect * >(argp1);
7689 arg2 = obj1;
7690 {
7691 result = (bool)wxRect___eq__(arg1,arg2);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 {
7695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7696 }
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj = 0;
7705 wxRect *arg1 = (wxRect *) 0 ;
7706 PyObject *arg2 = (PyObject *) 0 ;
7707 bool result;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 PyObject * obj0 = 0 ;
7711 PyObject * obj1 = 0 ;
7712 char * kwnames[] = {
7713 (char *) "self",(char *) "other", NULL
7714 };
7715
7716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7718 if (!SWIG_IsOK(res1)) {
7719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7720 }
7721 arg1 = reinterpret_cast< wxRect * >(argp1);
7722 arg2 = obj1;
7723 {
7724 result = (bool)wxRect___ne__(arg1,arg2);
7725 if (PyErr_Occurred()) SWIG_fail;
7726 }
7727 {
7728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7729 }
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7737 PyObject *resultobj = 0;
7738 wxRect *arg1 = (wxRect *) 0 ;
7739 int arg2 ;
7740 int arg3 ;
7741 bool result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 int val2 ;
7745 int ecode2 = 0 ;
7746 int val3 ;
7747 int ecode3 = 0 ;
7748 PyObject * obj0 = 0 ;
7749 PyObject * obj1 = 0 ;
7750 PyObject * obj2 = 0 ;
7751 char * kwnames[] = {
7752 (char *) "self",(char *) "x",(char *) "y", NULL
7753 };
7754
7755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7757 if (!SWIG_IsOK(res1)) {
7758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7759 }
7760 arg1 = reinterpret_cast< wxRect * >(argp1);
7761 ecode2 = SWIG_AsVal_int(obj1, &val2);
7762 if (!SWIG_IsOK(ecode2)) {
7763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7764 }
7765 arg2 = static_cast< int >(val2);
7766 ecode3 = SWIG_AsVal_int(obj2, &val3);
7767 if (!SWIG_IsOK(ecode3)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7769 }
7770 arg3 = static_cast< int >(val3);
7771 {
7772 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 {
7776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777 }
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj = 0;
7786 wxRect *arg1 = (wxRect *) 0 ;
7787 wxPoint *arg2 = 0 ;
7788 bool result;
7789 void *argp1 = 0 ;
7790 int res1 = 0 ;
7791 wxPoint temp2 ;
7792 PyObject * obj0 = 0 ;
7793 PyObject * obj1 = 0 ;
7794 char * kwnames[] = {
7795 (char *) "self",(char *) "pt", NULL
7796 };
7797
7798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7800 if (!SWIG_IsOK(res1)) {
7801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7802 }
7803 arg1 = reinterpret_cast< wxRect * >(argp1);
7804 {
7805 arg2 = &temp2;
7806 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7807 }
7808 {
7809 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7810 if (PyErr_Occurred()) SWIG_fail;
7811 }
7812 {
7813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7814 }
7815 return resultobj;
7816 fail:
7817 return NULL;
7818 }
7819
7820
7821 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7822 PyObject *resultobj = 0;
7823 wxRect *arg1 = (wxRect *) 0 ;
7824 wxRect *arg2 = 0 ;
7825 bool result;
7826 void *argp1 = 0 ;
7827 int res1 = 0 ;
7828 wxRect temp2 ;
7829 PyObject * obj0 = 0 ;
7830 PyObject * obj1 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "self",(char *) "rect", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 {
7842 arg2 = &temp2;
7843 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7844 }
7845 {
7846 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 {
7850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7851 }
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7859 PyObject *resultobj = 0;
7860 wxRect *arg1 = (wxRect *) 0 ;
7861 wxRect *arg2 = 0 ;
7862 bool result;
7863 void *argp1 = 0 ;
7864 int res1 = 0 ;
7865 wxRect temp2 ;
7866 PyObject * obj0 = 0 ;
7867 PyObject * obj1 = 0 ;
7868 char * kwnames[] = {
7869 (char *) "self",(char *) "rect", NULL
7870 };
7871
7872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7876 }
7877 arg1 = reinterpret_cast< wxRect * >(argp1);
7878 {
7879 arg2 = &temp2;
7880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7881 }
7882 {
7883 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7884 if (PyErr_Occurred()) SWIG_fail;
7885 }
7886 {
7887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7888 }
7889 return resultobj;
7890 fail:
7891 return NULL;
7892 }
7893
7894
7895 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7896 PyObject *resultobj = 0;
7897 wxRect *arg1 = (wxRect *) 0 ;
7898 wxRect *arg2 = 0 ;
7899 int arg3 = (int) wxBOTH ;
7900 wxRect result;
7901 void *argp1 = 0 ;
7902 int res1 = 0 ;
7903 wxRect temp2 ;
7904 int val3 ;
7905 int ecode3 = 0 ;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 PyObject * obj2 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "self",(char *) "r",(char *) "dir", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7915 if (!SWIG_IsOK(res1)) {
7916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7917 }
7918 arg1 = reinterpret_cast< wxRect * >(argp1);
7919 {
7920 arg2 = &temp2;
7921 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7922 }
7923 if (obj2) {
7924 ecode3 = SWIG_AsVal_int(obj2, &val3);
7925 if (!SWIG_IsOK(ecode3)) {
7926 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7927 }
7928 arg3 = static_cast< int >(val3);
7929 }
7930 {
7931 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7942 PyObject *resultobj = 0;
7943 wxRect *arg1 = (wxRect *) 0 ;
7944 int arg2 ;
7945 void *argp1 = 0 ;
7946 int res1 = 0 ;
7947 int val2 ;
7948 int ecode2 = 0 ;
7949 PyObject *swig_obj[2] ;
7950
7951 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7953 if (!SWIG_IsOK(res1)) {
7954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7955 }
7956 arg1 = reinterpret_cast< wxRect * >(argp1);
7957 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7958 if (!SWIG_IsOK(ecode2)) {
7959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7960 }
7961 arg2 = static_cast< int >(val2);
7962 if (arg1) (arg1)->x = arg2;
7963
7964 resultobj = SWIG_Py_Void();
7965 return resultobj;
7966 fail:
7967 return NULL;
7968 }
7969
7970
7971 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 PyObject *resultobj = 0;
7973 wxRect *arg1 = (wxRect *) 0 ;
7974 int result;
7975 void *argp1 = 0 ;
7976 int res1 = 0 ;
7977 PyObject *swig_obj[1] ;
7978
7979 if (!args) SWIG_fail;
7980 swig_obj[0] = args;
7981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7984 }
7985 arg1 = reinterpret_cast< wxRect * >(argp1);
7986 result = (int) ((arg1)->x);
7987 resultobj = SWIG_From_int(static_cast< int >(result));
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7995 PyObject *resultobj = 0;
7996 wxRect *arg1 = (wxRect *) 0 ;
7997 int arg2 ;
7998 void *argp1 = 0 ;
7999 int res1 = 0 ;
8000 int val2 ;
8001 int ecode2 = 0 ;
8002 PyObject *swig_obj[2] ;
8003
8004 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
8005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8006 if (!SWIG_IsOK(res1)) {
8007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8008 }
8009 arg1 = reinterpret_cast< wxRect * >(argp1);
8010 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8011 if (!SWIG_IsOK(ecode2)) {
8012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8013 }
8014 arg2 = static_cast< int >(val2);
8015 if (arg1) (arg1)->y = arg2;
8016
8017 resultobj = SWIG_Py_Void();
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *resultobj = 0;
8026 wxRect *arg1 = (wxRect *) 0 ;
8027 int result;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 PyObject *swig_obj[1] ;
8031
8032 if (!args) SWIG_fail;
8033 swig_obj[0] = args;
8034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 result = (int) ((arg1)->y);
8040 resultobj = SWIG_From_int(static_cast< int >(result));
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048 PyObject *resultobj = 0;
8049 wxRect *arg1 = (wxRect *) 0 ;
8050 int arg2 ;
8051 void *argp1 = 0 ;
8052 int res1 = 0 ;
8053 int val2 ;
8054 int ecode2 = 0 ;
8055 PyObject *swig_obj[2] ;
8056
8057 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8059 if (!SWIG_IsOK(res1)) {
8060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8061 }
8062 arg1 = reinterpret_cast< wxRect * >(argp1);
8063 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8064 if (!SWIG_IsOK(ecode2)) {
8065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8066 }
8067 arg2 = static_cast< int >(val2);
8068 if (arg1) (arg1)->width = arg2;
8069
8070 resultobj = SWIG_Py_Void();
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxRect *arg1 = (wxRect *) 0 ;
8080 int result;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 PyObject *swig_obj[1] ;
8084
8085 if (!args) SWIG_fail;
8086 swig_obj[0] = args;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8090 }
8091 arg1 = reinterpret_cast< wxRect * >(argp1);
8092 result = (int) ((arg1)->width);
8093 resultobj = SWIG_From_int(static_cast< int >(result));
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8101 PyObject *resultobj = 0;
8102 wxRect *arg1 = (wxRect *) 0 ;
8103 int arg2 ;
8104 void *argp1 = 0 ;
8105 int res1 = 0 ;
8106 int val2 ;
8107 int ecode2 = 0 ;
8108 PyObject *swig_obj[2] ;
8109
8110 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8112 if (!SWIG_IsOK(res1)) {
8113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8114 }
8115 arg1 = reinterpret_cast< wxRect * >(argp1);
8116 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8117 if (!SWIG_IsOK(ecode2)) {
8118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8119 }
8120 arg2 = static_cast< int >(val2);
8121 if (arg1) (arg1)->height = arg2;
8122
8123 resultobj = SWIG_Py_Void();
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 int result;
8134 void *argp1 = 0 ;
8135 int res1 = 0 ;
8136 PyObject *swig_obj[1] ;
8137
8138 if (!args) SWIG_fail;
8139 swig_obj[0] = args;
8140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8141 if (!SWIG_IsOK(res1)) {
8142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8143 }
8144 arg1 = reinterpret_cast< wxRect * >(argp1);
8145 result = (int) ((arg1)->height);
8146 resultobj = SWIG_From_int(static_cast< int >(result));
8147 return resultobj;
8148 fail:
8149 return NULL;
8150 }
8151
8152
8153 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8154 PyObject *resultobj = 0;
8155 wxRect *arg1 = (wxRect *) 0 ;
8156 int arg2 = (int) 0 ;
8157 int arg3 = (int) 0 ;
8158 int arg4 = (int) 0 ;
8159 int arg5 = (int) 0 ;
8160 void *argp1 = 0 ;
8161 int res1 = 0 ;
8162 int val2 ;
8163 int ecode2 = 0 ;
8164 int val3 ;
8165 int ecode3 = 0 ;
8166 int val4 ;
8167 int ecode4 = 0 ;
8168 int val5 ;
8169 int ecode5 = 0 ;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 PyObject * obj2 = 0 ;
8173 PyObject * obj3 = 0 ;
8174 PyObject * obj4 = 0 ;
8175 char * kwnames[] = {
8176 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8177 };
8178
8179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8181 if (!SWIG_IsOK(res1)) {
8182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8183 }
8184 arg1 = reinterpret_cast< wxRect * >(argp1);
8185 if (obj1) {
8186 ecode2 = SWIG_AsVal_int(obj1, &val2);
8187 if (!SWIG_IsOK(ecode2)) {
8188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8189 }
8190 arg2 = static_cast< int >(val2);
8191 }
8192 if (obj2) {
8193 ecode3 = SWIG_AsVal_int(obj2, &val3);
8194 if (!SWIG_IsOK(ecode3)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8196 }
8197 arg3 = static_cast< int >(val3);
8198 }
8199 if (obj3) {
8200 ecode4 = SWIG_AsVal_int(obj3, &val4);
8201 if (!SWIG_IsOK(ecode4)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8203 }
8204 arg4 = static_cast< int >(val4);
8205 }
8206 if (obj4) {
8207 ecode5 = SWIG_AsVal_int(obj4, &val5);
8208 if (!SWIG_IsOK(ecode5)) {
8209 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8210 }
8211 arg5 = static_cast< int >(val5);
8212 }
8213 {
8214 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8215 if (PyErr_Occurred()) SWIG_fail;
8216 }
8217 resultobj = SWIG_Py_Void();
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8225 PyObject *resultobj = 0;
8226 wxRect *arg1 = (wxRect *) 0 ;
8227 PyObject *result = 0 ;
8228 void *argp1 = 0 ;
8229 int res1 = 0 ;
8230 PyObject *swig_obj[1] ;
8231
8232 if (!args) SWIG_fail;
8233 swig_obj[0] = args;
8234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8235 if (!SWIG_IsOK(res1)) {
8236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8237 }
8238 arg1 = reinterpret_cast< wxRect * >(argp1);
8239 {
8240 result = (PyObject *)wxRect_Get(arg1);
8241 if (PyErr_Occurred()) SWIG_fail;
8242 }
8243 resultobj = result;
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 PyObject *obj;
8252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8253 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8254 return SWIG_Py_Void();
8255 }
8256
8257 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8258 return SWIG_Python_InitShadowInstance(args);
8259 }
8260
8261 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj = 0;
8263 wxRect *arg1 = (wxRect *) 0 ;
8264 wxRect *arg2 = (wxRect *) 0 ;
8265 PyObject *result = 0 ;
8266 void *argp1 = 0 ;
8267 int res1 = 0 ;
8268 void *argp2 = 0 ;
8269 int res2 = 0 ;
8270 PyObject * obj0 = 0 ;
8271 PyObject * obj1 = 0 ;
8272 char * kwnames[] = {
8273 (char *) "r1",(char *) "r2", NULL
8274 };
8275
8276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8278 if (!SWIG_IsOK(res1)) {
8279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8280 }
8281 arg1 = reinterpret_cast< wxRect * >(argp1);
8282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8283 if (!SWIG_IsOK(res2)) {
8284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8285 }
8286 arg2 = reinterpret_cast< wxRect * >(argp2);
8287 {
8288 if (!wxPyCheckForApp()) SWIG_fail;
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (PyObject *)wxIntersectRect(arg1,arg2);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = result;
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 double arg1 = (double) 0.0 ;
8304 double arg2 = (double) 0.0 ;
8305 wxPoint2D *result = 0 ;
8306 double val1 ;
8307 int ecode1 = 0 ;
8308 double val2 ;
8309 int ecode2 = 0 ;
8310 PyObject * obj0 = 0 ;
8311 PyObject * obj1 = 0 ;
8312 char * kwnames[] = {
8313 (char *) "x",(char *) "y", NULL
8314 };
8315
8316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8317 if (obj0) {
8318 ecode1 = SWIG_AsVal_double(obj0, &val1);
8319 if (!SWIG_IsOK(ecode1)) {
8320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8321 }
8322 arg1 = static_cast< double >(val1);
8323 }
8324 if (obj1) {
8325 ecode2 = SWIG_AsVal_double(obj1, &val2);
8326 if (!SWIG_IsOK(ecode2)) {
8327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8328 }
8329 arg2 = static_cast< double >(val2);
8330 }
8331 {
8332 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8336 return resultobj;
8337 fail:
8338 return NULL;
8339 }
8340
8341
8342 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8343 PyObject *resultobj = 0;
8344 wxPoint2D *arg1 = 0 ;
8345 wxPoint2D *result = 0 ;
8346 wxPoint2D temp1 ;
8347 PyObject * obj0 = 0 ;
8348 char * kwnames[] = {
8349 (char *) "pt", NULL
8350 };
8351
8352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8353 {
8354 arg1 = &temp1;
8355 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8356 }
8357 {
8358 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj = 0;
8370 wxPoint *arg1 = 0 ;
8371 wxPoint2D *result = 0 ;
8372 wxPoint temp1 ;
8373 PyObject * obj0 = 0 ;
8374 char * kwnames[] = {
8375 (char *) "pt", NULL
8376 };
8377
8378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8379 {
8380 arg1 = &temp1;
8381 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8382 }
8383 {
8384 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8385 if (PyErr_Occurred()) SWIG_fail;
8386 }
8387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8388 return resultobj;
8389 fail:
8390 return NULL;
8391 }
8392
8393
8394 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8395 PyObject *resultobj = 0;
8396 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8397 void *argp1 = 0 ;
8398 int res1 = 0 ;
8399 PyObject *swig_obj[1] ;
8400
8401 if (!args) SWIG_fail;
8402 swig_obj[0] = args;
8403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8404 if (!SWIG_IsOK(res1)) {
8405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8406 }
8407 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8408 {
8409 delete arg1;
8410
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 resultobj = SWIG_Py_Void();
8414 return resultobj;
8415 fail:
8416 return NULL;
8417 }
8418
8419
8420 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8421 PyObject *resultobj = 0;
8422 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8423 int *arg2 = (int *) 0 ;
8424 int *arg3 = (int *) 0 ;
8425 void *argp1 = 0 ;
8426 int res1 = 0 ;
8427 int temp2 ;
8428 int res2 = SWIG_TMPOBJ ;
8429 int temp3 ;
8430 int res3 = SWIG_TMPOBJ ;
8431 PyObject *swig_obj[1] ;
8432
8433 arg2 = &temp2;
8434 arg3 = &temp3;
8435 if (!args) SWIG_fail;
8436 swig_obj[0] = args;
8437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8440 }
8441 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8442 {
8443 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 resultobj = SWIG_Py_Void();
8447 if (SWIG_IsTmpObj(res2)) {
8448 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8449 } else {
8450 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8452 }
8453 if (SWIG_IsTmpObj(res3)) {
8454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8455 } else {
8456 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8458 }
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8466 PyObject *resultobj = 0;
8467 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8468 int *arg2 = (int *) 0 ;
8469 int *arg3 = (int *) 0 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 int temp2 ;
8473 int res2 = SWIG_TMPOBJ ;
8474 int temp3 ;
8475 int res3 = SWIG_TMPOBJ ;
8476 PyObject *swig_obj[1] ;
8477
8478 arg2 = &temp2;
8479 arg3 = &temp3;
8480 if (!args) SWIG_fail;
8481 swig_obj[0] = args;
8482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8489 if (PyErr_Occurred()) SWIG_fail;
8490 }
8491 resultobj = SWIG_Py_Void();
8492 if (SWIG_IsTmpObj(res2)) {
8493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8494 } else {
8495 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8497 }
8498 if (SWIG_IsTmpObj(res3)) {
8499 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8500 } else {
8501 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8502 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8503 }
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 PyObject *resultobj = 0;
8512 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8513 double result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 PyObject *swig_obj[1] ;
8517
8518 if (!args) SWIG_fail;
8519 swig_obj[0] = args;
8520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8521 if (!SWIG_IsOK(res1)) {
8522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8523 }
8524 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8525 {
8526 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8527 if (PyErr_Occurred()) SWIG_fail;
8528 }
8529 resultobj = SWIG_From_double(static_cast< double >(result));
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8537 PyObject *resultobj = 0;
8538 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8539 double result;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 PyObject *swig_obj[1] ;
8543
8544 if (!args) SWIG_fail;
8545 swig_obj[0] = args;
8546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8549 }
8550 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8551 {
8552 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 resultobj = SWIG_From_double(static_cast< double >(result));
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj = 0;
8564 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8565 double arg2 ;
8566 void *argp1 = 0 ;
8567 int res1 = 0 ;
8568 double val2 ;
8569 int ecode2 = 0 ;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 char * kwnames[] = {
8573 (char *) "self",(char *) "length", NULL
8574 };
8575
8576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8580 }
8581 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8582 ecode2 = SWIG_AsVal_double(obj1, &val2);
8583 if (!SWIG_IsOK(ecode2)) {
8584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8585 }
8586 arg2 = static_cast< double >(val2);
8587 {
8588 (arg1)->SetVectorLength(arg2);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_Py_Void();
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8601 double arg2 ;
8602 void *argp1 = 0 ;
8603 int res1 = 0 ;
8604 double val2 ;
8605 int ecode2 = 0 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "degrees", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 ecode2 = SWIG_AsVal_double(obj1, &val2);
8619 if (!SWIG_IsOK(ecode2)) {
8620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8621 }
8622 arg2 = static_cast< double >(val2);
8623 {
8624 (arg1)->SetVectorAngle(arg2);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_Py_Void();
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 wxPoint2D *arg2 = 0 ;
8638 double result;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 wxPoint2D temp2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pt", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 {
8655 arg2 = &temp2;
8656 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8657 }
8658 {
8659 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_From_double(static_cast< double >(result));
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8670 PyObject *resultobj = 0;
8671 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8672 wxPoint2D *arg2 = 0 ;
8673 double result;
8674 void *argp1 = 0 ;
8675 int res1 = 0 ;
8676 wxPoint2D temp2 ;
8677 PyObject * obj0 = 0 ;
8678 PyObject * obj1 = 0 ;
8679 char * kwnames[] = {
8680 (char *) "self",(char *) "pt", NULL
8681 };
8682
8683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8685 if (!SWIG_IsOK(res1)) {
8686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8687 }
8688 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8689 {
8690 arg2 = &temp2;
8691 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8692 }
8693 {
8694 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_From_double(static_cast< double >(result));
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8705 PyObject *resultobj = 0;
8706 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8707 wxPoint2D *arg2 = 0 ;
8708 double result;
8709 void *argp1 = 0 ;
8710 int res1 = 0 ;
8711 wxPoint2D temp2 ;
8712 PyObject * obj0 = 0 ;
8713 PyObject * obj1 = 0 ;
8714 char * kwnames[] = {
8715 (char *) "self",(char *) "vec", NULL
8716 };
8717
8718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8720 if (!SWIG_IsOK(res1)) {
8721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8722 }
8723 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8724 {
8725 arg2 = &temp2;
8726 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8727 }
8728 {
8729 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8730 if (PyErr_Occurred()) SWIG_fail;
8731 }
8732 resultobj = SWIG_From_double(static_cast< double >(result));
8733 return resultobj;
8734 fail:
8735 return NULL;
8736 }
8737
8738
8739 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8740 PyObject *resultobj = 0;
8741 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8742 wxPoint2D *arg2 = 0 ;
8743 double result;
8744 void *argp1 = 0 ;
8745 int res1 = 0 ;
8746 wxPoint2D temp2 ;
8747 PyObject * obj0 = 0 ;
8748 PyObject * obj1 = 0 ;
8749 char * kwnames[] = {
8750 (char *) "self",(char *) "vec", NULL
8751 };
8752
8753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8755 if (!SWIG_IsOK(res1)) {
8756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8757 }
8758 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8759 {
8760 arg2 = &temp2;
8761 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8762 }
8763 {
8764 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8765 if (PyErr_Occurred()) SWIG_fail;
8766 }
8767 resultobj = SWIG_From_double(static_cast< double >(result));
8768 return resultobj;
8769 fail:
8770 return NULL;
8771 }
8772
8773
8774 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8775 PyObject *resultobj = 0;
8776 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8777 wxPoint2D result;
8778 void *argp1 = 0 ;
8779 int res1 = 0 ;
8780 PyObject *swig_obj[1] ;
8781
8782 if (!args) SWIG_fail;
8783 swig_obj[0] = args;
8784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8785 if (!SWIG_IsOK(res1)) {
8786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8787 }
8788 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8789 {
8790 result = (arg1)->operator -();
8791 if (PyErr_Occurred()) SWIG_fail;
8792 }
8793 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8794 return resultobj;
8795 fail:
8796 return NULL;
8797 }
8798
8799
8800 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8801 PyObject *resultobj = 0;
8802 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8803 wxPoint2D *arg2 = 0 ;
8804 wxPoint2D *result = 0 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 wxPoint2D temp2 ;
8808 PyObject * obj0 = 0 ;
8809 PyObject * obj1 = 0 ;
8810 char * kwnames[] = {
8811 (char *) "self",(char *) "pt", NULL
8812 };
8813
8814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8816 if (!SWIG_IsOK(res1)) {
8817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8818 }
8819 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8820 {
8821 arg2 = &temp2;
8822 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8823 }
8824 {
8825 {
8826 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8827 result = (wxPoint2D *) &_result_ref;
8828 }
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8841 wxPoint2D *arg2 = 0 ;
8842 wxPoint2D *result = 0 ;
8843 void *argp1 = 0 ;
8844 int res1 = 0 ;
8845 wxPoint2D temp2 ;
8846 PyObject * obj0 = 0 ;
8847 PyObject * obj1 = 0 ;
8848 char * kwnames[] = {
8849 (char *) "self",(char *) "pt", NULL
8850 };
8851
8852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8854 if (!SWIG_IsOK(res1)) {
8855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8856 }
8857 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8858 {
8859 arg2 = &temp2;
8860 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8861 }
8862 {
8863 {
8864 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8865 result = (wxPoint2D *) &_result_ref;
8866 }
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8879 wxPoint2D *arg2 = 0 ;
8880 wxPoint2D *result = 0 ;
8881 void *argp1 = 0 ;
8882 int res1 = 0 ;
8883 wxPoint2D temp2 ;
8884 PyObject * obj0 = 0 ;
8885 PyObject * obj1 = 0 ;
8886 char * kwnames[] = {
8887 (char *) "self",(char *) "pt", NULL
8888 };
8889
8890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8892 if (!SWIG_IsOK(res1)) {
8893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8894 }
8895 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8896 {
8897 arg2 = &temp2;
8898 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8899 }
8900 {
8901 {
8902 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8903 result = (wxPoint2D *) &_result_ref;
8904 }
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8915 PyObject *resultobj = 0;
8916 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8917 wxPoint2D *arg2 = 0 ;
8918 wxPoint2D *result = 0 ;
8919 void *argp1 = 0 ;
8920 int res1 = 0 ;
8921 wxPoint2D temp2 ;
8922 PyObject * obj0 = 0 ;
8923 PyObject * obj1 = 0 ;
8924 char * kwnames[] = {
8925 (char *) "self",(char *) "pt", NULL
8926 };
8927
8928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8930 if (!SWIG_IsOK(res1)) {
8931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8932 }
8933 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8934 {
8935 arg2 = &temp2;
8936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8937 }
8938 {
8939 {
8940 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8941 result = (wxPoint2D *) &_result_ref;
8942 }
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj = 0;
8954 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8955 PyObject *arg2 = (PyObject *) 0 ;
8956 bool result;
8957 void *argp1 = 0 ;
8958 int res1 = 0 ;
8959 PyObject * obj0 = 0 ;
8960 PyObject * obj1 = 0 ;
8961 char * kwnames[] = {
8962 (char *) "self",(char *) "other", NULL
8963 };
8964
8965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8967 if (!SWIG_IsOK(res1)) {
8968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8969 }
8970 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8971 arg2 = obj1;
8972 {
8973 result = (bool)wxPoint2D___eq__(arg1,arg2);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 {
8977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8978 }
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8988 PyObject *arg2 = (PyObject *) 0 ;
8989 bool result;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject * obj0 = 0 ;
8993 PyObject * obj1 = 0 ;
8994 char * kwnames[] = {
8995 (char *) "self",(char *) "other", NULL
8996 };
8997
8998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9004 arg2 = obj1;
9005 {
9006 result = (bool)wxPoint2D___ne__(arg1,arg2);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 {
9010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 PyObject *resultobj = 0;
9020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9021 double arg2 ;
9022 void *argp1 = 0 ;
9023 int res1 = 0 ;
9024 double val2 ;
9025 int ecode2 = 0 ;
9026 PyObject *swig_obj[2] ;
9027
9028 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9030 if (!SWIG_IsOK(res1)) {
9031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9032 }
9033 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9034 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9035 if (!SWIG_IsOK(ecode2)) {
9036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9037 }
9038 arg2 = static_cast< double >(val2);
9039 if (arg1) (arg1)->m_x = arg2;
9040
9041 resultobj = SWIG_Py_Void();
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9051 double result;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 PyObject *swig_obj[1] ;
9055
9056 if (!args) SWIG_fail;
9057 swig_obj[0] = args;
9058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9061 }
9062 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9063 result = (double) ((arg1)->m_x);
9064 resultobj = SWIG_From_double(static_cast< double >(result));
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9072 PyObject *resultobj = 0;
9073 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9074 double arg2 ;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 double val2 ;
9078 int ecode2 = 0 ;
9079 PyObject *swig_obj[2] ;
9080
9081 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9085 }
9086 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9087 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9088 if (!SWIG_IsOK(ecode2)) {
9089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9090 }
9091 arg2 = static_cast< double >(val2);
9092 if (arg1) (arg1)->m_y = arg2;
9093
9094 resultobj = SWIG_Py_Void();
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9102 PyObject *resultobj = 0;
9103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9104 double result;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9116 result = (double) ((arg1)->m_y);
9117 resultobj = SWIG_From_double(static_cast< double >(result));
9118 return resultobj;
9119 fail:
9120 return NULL;
9121 }
9122
9123
9124 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9125 PyObject *resultobj = 0;
9126 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9127 double arg2 = (double) 0 ;
9128 double arg3 = (double) 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 double val2 ;
9132 int ecode2 = 0 ;
9133 double val3 ;
9134 int ecode3 = 0 ;
9135 PyObject * obj0 = 0 ;
9136 PyObject * obj1 = 0 ;
9137 PyObject * obj2 = 0 ;
9138 char * kwnames[] = {
9139 (char *) "self",(char *) "x",(char *) "y", NULL
9140 };
9141
9142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9144 if (!SWIG_IsOK(res1)) {
9145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9146 }
9147 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9148 if (obj1) {
9149 ecode2 = SWIG_AsVal_double(obj1, &val2);
9150 if (!SWIG_IsOK(ecode2)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9152 }
9153 arg2 = static_cast< double >(val2);
9154 }
9155 if (obj2) {
9156 ecode3 = SWIG_AsVal_double(obj2, &val3);
9157 if (!SWIG_IsOK(ecode3)) {
9158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9159 }
9160 arg3 = static_cast< double >(val3);
9161 }
9162 {
9163 wxPoint2D_Set(arg1,arg2,arg3);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 resultobj = SWIG_Py_Void();
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 PyObject *resultobj = 0;
9175 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9176 PyObject *result = 0 ;
9177 void *argp1 = 0 ;
9178 int res1 = 0 ;
9179 PyObject *swig_obj[1] ;
9180
9181 if (!args) SWIG_fail;
9182 swig_obj[0] = args;
9183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9184 if (!SWIG_IsOK(res1)) {
9185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9186 }
9187 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9188 {
9189 result = (PyObject *)wxPoint2D_Get(arg1);
9190 if (PyErr_Occurred()) SWIG_fail;
9191 }
9192 resultobj = result;
9193 return resultobj;
9194 fail:
9195 return NULL;
9196 }
9197
9198
9199 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9200 PyObject *obj;
9201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9202 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9203 return SWIG_Py_Void();
9204 }
9205
9206 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 return SWIG_Python_InitShadowInstance(args);
9208 }
9209
9210 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9211 PyObject *resultobj = 0;
9212 wxDouble arg1 = (wxDouble) 0.0 ;
9213 wxDouble arg2 = (wxDouble) 0.0 ;
9214 wxDouble arg3 = (wxDouble) 0.0 ;
9215 wxDouble arg4 = (wxDouble) 0.0 ;
9216 wxRect2D *result = 0 ;
9217 void *argp1 ;
9218 int res1 = 0 ;
9219 void *argp2 ;
9220 int res2 = 0 ;
9221 void *argp3 ;
9222 int res3 = 0 ;
9223 void *argp4 ;
9224 int res4 = 0 ;
9225 PyObject * obj0 = 0 ;
9226 PyObject * obj1 = 0 ;
9227 PyObject * obj2 = 0 ;
9228 PyObject * obj3 = 0 ;
9229 char * kwnames[] = {
9230 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9231 };
9232
9233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9234 if (obj0) {
9235 {
9236 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9239 }
9240 if (!argp1) {
9241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9242 } else {
9243 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9244 arg1 = *temp;
9245 if (SWIG_IsNewObj(res1)) delete temp;
9246 }
9247 }
9248 }
9249 if (obj1) {
9250 {
9251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9252 if (!SWIG_IsOK(res2)) {
9253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9254 }
9255 if (!argp2) {
9256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9257 } else {
9258 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9259 arg2 = *temp;
9260 if (SWIG_IsNewObj(res2)) delete temp;
9261 }
9262 }
9263 }
9264 if (obj2) {
9265 {
9266 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9267 if (!SWIG_IsOK(res3)) {
9268 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9269 }
9270 if (!argp3) {
9271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9272 } else {
9273 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9274 arg3 = *temp;
9275 if (SWIG_IsNewObj(res3)) delete temp;
9276 }
9277 }
9278 }
9279 if (obj3) {
9280 {
9281 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9282 if (!SWIG_IsOK(res4)) {
9283 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9284 }
9285 if (!argp4) {
9286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9287 } else {
9288 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9289 arg4 = *temp;
9290 if (SWIG_IsNewObj(res4)) delete temp;
9291 }
9292 }
9293 }
9294 {
9295 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9296 if (PyErr_Occurred()) SWIG_fail;
9297 }
9298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9299 return resultobj;
9300 fail:
9301 return NULL;
9302 }
9303
9304
9305 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9306 PyObject *resultobj = 0;
9307 wxRect2D *arg1 = (wxRect2D *) 0 ;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 PyObject *swig_obj[1] ;
9311
9312 if (!args) SWIG_fail;
9313 swig_obj[0] = args;
9314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9315 if (!SWIG_IsOK(res1)) {
9316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9317 }
9318 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9319 {
9320 delete arg1;
9321
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxRect2D *arg1 = (wxRect2D *) 0 ;
9334 wxPoint2D result;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 PyObject *swig_obj[1] ;
9338
9339 if (!args) SWIG_fail;
9340 swig_obj[0] = args;
9341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9344 }
9345 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9346 {
9347 result = (arg1)->GetPosition();
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxRect2D *arg1 = (wxRect2D *) 0 ;
9360 wxSize result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9370 }
9371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9372 {
9373 result = (arg1)->GetSize();
9374 if (PyErr_Occurred()) SWIG_fail;
9375 }
9376 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9377 return resultobj;
9378 fail:
9379 return NULL;
9380 }
9381
9382
9383 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9384 PyObject *resultobj = 0;
9385 wxRect2D *arg1 = (wxRect2D *) 0 ;
9386 wxDouble result;
9387 void *argp1 = 0 ;
9388 int res1 = 0 ;
9389 PyObject *swig_obj[1] ;
9390
9391 if (!args) SWIG_fail;
9392 swig_obj[0] = args;
9393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9394 if (!SWIG_IsOK(res1)) {
9395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9396 }
9397 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9398 {
9399 result = ((wxRect2D const *)arg1)->GetLeft();
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9403 return resultobj;
9404 fail:
9405 return NULL;
9406 }
9407
9408
9409 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9410 PyObject *resultobj = 0;
9411 wxRect2D *arg1 = (wxRect2D *) 0 ;
9412 wxDouble arg2 ;
9413 void *argp1 = 0 ;
9414 int res1 = 0 ;
9415 void *argp2 ;
9416 int res2 = 0 ;
9417 PyObject * obj0 = 0 ;
9418 PyObject * obj1 = 0 ;
9419 char * kwnames[] = {
9420 (char *) "self",(char *) "n", NULL
9421 };
9422
9423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9425 if (!SWIG_IsOK(res1)) {
9426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9427 }
9428 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9429 {
9430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9431 if (!SWIG_IsOK(res2)) {
9432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9433 }
9434 if (!argp2) {
9435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9436 } else {
9437 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9438 arg2 = *temp;
9439 if (SWIG_IsNewObj(res2)) delete temp;
9440 }
9441 }
9442 {
9443 (arg1)->SetLeft(arg2);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = SWIG_Py_Void();
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxRect2D *arg1 = (wxRect2D *) 0 ;
9456 wxDouble arg2 ;
9457 void *argp1 = 0 ;
9458 int res1 = 0 ;
9459 void *argp2 ;
9460 int res2 = 0 ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 char * kwnames[] = {
9464 (char *) "self",(char *) "n", NULL
9465 };
9466
9467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9471 }
9472 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9473 {
9474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9475 if (!SWIG_IsOK(res2)) {
9476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9477 }
9478 if (!argp2) {
9479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9480 } else {
9481 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9482 arg2 = *temp;
9483 if (SWIG_IsNewObj(res2)) delete temp;
9484 }
9485 }
9486 {
9487 (arg1)->MoveLeftTo(arg2);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_Py_Void();
9491 return resultobj;
9492 fail:
9493 return NULL;
9494 }
9495
9496
9497 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9498 PyObject *resultobj = 0;
9499 wxRect2D *arg1 = (wxRect2D *) 0 ;
9500 wxDouble result;
9501 void *argp1 = 0 ;
9502 int res1 = 0 ;
9503 PyObject *swig_obj[1] ;
9504
9505 if (!args) SWIG_fail;
9506 swig_obj[0] = args;
9507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9508 if (!SWIG_IsOK(res1)) {
9509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9510 }
9511 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9512 {
9513 result = ((wxRect2D const *)arg1)->GetTop();
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj = 0;
9525 wxRect2D *arg1 = (wxRect2D *) 0 ;
9526 wxDouble arg2 ;
9527 void *argp1 = 0 ;
9528 int res1 = 0 ;
9529 void *argp2 ;
9530 int res2 = 0 ;
9531 PyObject * obj0 = 0 ;
9532 PyObject * obj1 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "n", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9541 }
9542 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9543 {
9544 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9545 if (!SWIG_IsOK(res2)) {
9546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9547 }
9548 if (!argp2) {
9549 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9550 } else {
9551 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9552 arg2 = *temp;
9553 if (SWIG_IsNewObj(res2)) delete temp;
9554 }
9555 }
9556 {
9557 (arg1)->SetTop(arg2);
9558 if (PyErr_Occurred()) SWIG_fail;
9559 }
9560 resultobj = SWIG_Py_Void();
9561 return resultobj;
9562 fail:
9563 return NULL;
9564 }
9565
9566
9567 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9568 PyObject *resultobj = 0;
9569 wxRect2D *arg1 = (wxRect2D *) 0 ;
9570 wxDouble arg2 ;
9571 void *argp1 = 0 ;
9572 int res1 = 0 ;
9573 void *argp2 ;
9574 int res2 = 0 ;
9575 PyObject * obj0 = 0 ;
9576 PyObject * obj1 = 0 ;
9577 char * kwnames[] = {
9578 (char *) "self",(char *) "n", NULL
9579 };
9580
9581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9583 if (!SWIG_IsOK(res1)) {
9584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9585 }
9586 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9587 {
9588 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9589 if (!SWIG_IsOK(res2)) {
9590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9591 }
9592 if (!argp2) {
9593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9594 } else {
9595 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9596 arg2 = *temp;
9597 if (SWIG_IsNewObj(res2)) delete temp;
9598 }
9599 }
9600 {
9601 (arg1)->MoveTopTo(arg2);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_Py_Void();
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxRect2D *arg1 = (wxRect2D *) 0 ;
9614 wxDouble result;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9624 }
9625 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9626 {
9627 result = ((wxRect2D const *)arg1)->GetBottom();
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9631 return resultobj;
9632 fail:
9633 return NULL;
9634 }
9635
9636
9637 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9638 PyObject *resultobj = 0;
9639 wxRect2D *arg1 = (wxRect2D *) 0 ;
9640 wxDouble arg2 ;
9641 void *argp1 = 0 ;
9642 int res1 = 0 ;
9643 void *argp2 ;
9644 int res2 = 0 ;
9645 PyObject * obj0 = 0 ;
9646 PyObject * obj1 = 0 ;
9647 char * kwnames[] = {
9648 (char *) "self",(char *) "n", NULL
9649 };
9650
9651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9653 if (!SWIG_IsOK(res1)) {
9654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9655 }
9656 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9657 {
9658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9659 if (!SWIG_IsOK(res2)) {
9660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9661 }
9662 if (!argp2) {
9663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9664 } else {
9665 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9666 arg2 = *temp;
9667 if (SWIG_IsNewObj(res2)) delete temp;
9668 }
9669 }
9670 {
9671 (arg1)->SetBottom(arg2);
9672 if (PyErr_Occurred()) SWIG_fail;
9673 }
9674 resultobj = SWIG_Py_Void();
9675 return resultobj;
9676 fail:
9677 return NULL;
9678 }
9679
9680
9681 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj = 0;
9683 wxRect2D *arg1 = (wxRect2D *) 0 ;
9684 wxDouble arg2 ;
9685 void *argp1 = 0 ;
9686 int res1 = 0 ;
9687 void *argp2 ;
9688 int res2 = 0 ;
9689 PyObject * obj0 = 0 ;
9690 PyObject * obj1 = 0 ;
9691 char * kwnames[] = {
9692 (char *) "self",(char *) "n", NULL
9693 };
9694
9695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9697 if (!SWIG_IsOK(res1)) {
9698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9699 }
9700 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9701 {
9702 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9703 if (!SWIG_IsOK(res2)) {
9704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9705 }
9706 if (!argp2) {
9707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9708 } else {
9709 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9710 arg2 = *temp;
9711 if (SWIG_IsNewObj(res2)) delete temp;
9712 }
9713 }
9714 {
9715 (arg1)->MoveBottomTo(arg2);
9716 if (PyErr_Occurred()) SWIG_fail;
9717 }
9718 resultobj = SWIG_Py_Void();
9719 return resultobj;
9720 fail:
9721 return NULL;
9722 }
9723
9724
9725 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9726 PyObject *resultobj = 0;
9727 wxRect2D *arg1 = (wxRect2D *) 0 ;
9728 wxDouble result;
9729 void *argp1 = 0 ;
9730 int res1 = 0 ;
9731 PyObject *swig_obj[1] ;
9732
9733 if (!args) SWIG_fail;
9734 swig_obj[0] = args;
9735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9736 if (!SWIG_IsOK(res1)) {
9737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9738 }
9739 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9740 {
9741 result = ((wxRect2D const *)arg1)->GetRight();
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9752 PyObject *resultobj = 0;
9753 wxRect2D *arg1 = (wxRect2D *) 0 ;
9754 wxDouble arg2 ;
9755 void *argp1 = 0 ;
9756 int res1 = 0 ;
9757 void *argp2 ;
9758 int res2 = 0 ;
9759 PyObject * obj0 = 0 ;
9760 PyObject * obj1 = 0 ;
9761 char * kwnames[] = {
9762 (char *) "self",(char *) "n", NULL
9763 };
9764
9765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9769 }
9770 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9771 {
9772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9773 if (!SWIG_IsOK(res2)) {
9774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9775 }
9776 if (!argp2) {
9777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9778 } else {
9779 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9780 arg2 = *temp;
9781 if (SWIG_IsNewObj(res2)) delete temp;
9782 }
9783 }
9784 {
9785 (arg1)->SetRight(arg2);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 resultobj = SWIG_Py_Void();
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9796 PyObject *resultobj = 0;
9797 wxRect2D *arg1 = (wxRect2D *) 0 ;
9798 wxDouble arg2 ;
9799 void *argp1 = 0 ;
9800 int res1 = 0 ;
9801 void *argp2 ;
9802 int res2 = 0 ;
9803 PyObject * obj0 = 0 ;
9804 PyObject * obj1 = 0 ;
9805 char * kwnames[] = {
9806 (char *) "self",(char *) "n", NULL
9807 };
9808
9809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9811 if (!SWIG_IsOK(res1)) {
9812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9813 }
9814 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9815 {
9816 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9817 if (!SWIG_IsOK(res2)) {
9818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9819 }
9820 if (!argp2) {
9821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9822 } else {
9823 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9824 arg2 = *temp;
9825 if (SWIG_IsNewObj(res2)) delete temp;
9826 }
9827 }
9828 {
9829 (arg1)->MoveRightTo(arg2);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_Py_Void();
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *resultobj = 0;
9841 wxRect2D *arg1 = (wxRect2D *) 0 ;
9842 wxPoint2D result;
9843 void *argp1 = 0 ;
9844 int res1 = 0 ;
9845 PyObject *swig_obj[1] ;
9846
9847 if (!args) SWIG_fail;
9848 swig_obj[0] = args;
9849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9850 if (!SWIG_IsOK(res1)) {
9851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9852 }
9853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9854 {
9855 result = ((wxRect2D const *)arg1)->GetLeftTop();
9856 if (PyErr_Occurred()) SWIG_fail;
9857 }
9858 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj = 0;
9867 wxRect2D *arg1 = (wxRect2D *) 0 ;
9868 wxPoint2D *arg2 = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 wxPoint2D temp2 ;
9872 PyObject * obj0 = 0 ;
9873 PyObject * obj1 = 0 ;
9874 char * kwnames[] = {
9875 (char *) "self",(char *) "pt", NULL
9876 };
9877
9878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9880 if (!SWIG_IsOK(res1)) {
9881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9882 }
9883 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9884 {
9885 arg2 = &temp2;
9886 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9887 }
9888 {
9889 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9890 if (PyErr_Occurred()) SWIG_fail;
9891 }
9892 resultobj = SWIG_Py_Void();
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj = 0;
9901 wxRect2D *arg1 = (wxRect2D *) 0 ;
9902 wxPoint2D *arg2 = 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 wxPoint2D temp2 ;
9906 PyObject * obj0 = 0 ;
9907 PyObject * obj1 = 0 ;
9908 char * kwnames[] = {
9909 (char *) "self",(char *) "pt", NULL
9910 };
9911
9912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9916 }
9917 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9918 {
9919 arg2 = &temp2;
9920 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9921 }
9922 {
9923 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *resultobj = 0;
9935 wxRect2D *arg1 = (wxRect2D *) 0 ;
9936 wxPoint2D result;
9937 void *argp1 = 0 ;
9938 int res1 = 0 ;
9939 PyObject *swig_obj[1] ;
9940
9941 if (!args) SWIG_fail;
9942 swig_obj[0] = args;
9943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9944 if (!SWIG_IsOK(res1)) {
9945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9946 }
9947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9948 {
9949 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj = 0;
9961 wxRect2D *arg1 = (wxRect2D *) 0 ;
9962 wxPoint2D *arg2 = 0 ;
9963 void *argp1 = 0 ;
9964 int res1 = 0 ;
9965 wxPoint2D temp2 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char * kwnames[] = {
9969 (char *) "self",(char *) "pt", NULL
9970 };
9971
9972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9976 }
9977 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9978 {
9979 arg2 = &temp2;
9980 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9981 }
9982 {
9983 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxRect2D *arg1 = (wxRect2D *) 0 ;
9996 wxPoint2D *arg2 = 0 ;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 wxPoint2D temp2 ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char * kwnames[] = {
10003 (char *) "self",(char *) "pt", NULL
10004 };
10005
10006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10008 if (!SWIG_IsOK(res1)) {
10009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10010 }
10011 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10012 {
10013 arg2 = &temp2;
10014 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10015 }
10016 {
10017 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxRect2D *arg1 = (wxRect2D *) 0 ;
10030 wxPoint2D result;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 PyObject *swig_obj[1] ;
10034
10035 if (!args) SWIG_fail;
10036 swig_obj[0] = args;
10037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10040 }
10041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10042 {
10043 result = ((wxRect2D const *)arg1)->GetRightTop();
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxRect2D *arg1 = (wxRect2D *) 0 ;
10056 wxPoint2D *arg2 = 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 wxPoint2D temp2 ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "pt", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10070 }
10071 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10072 {
10073 arg2 = &temp2;
10074 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10075 }
10076 {
10077 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxRect2D *arg1 = (wxRect2D *) 0 ;
10090 wxPoint2D *arg2 = 0 ;
10091 void *argp1 = 0 ;
10092 int res1 = 0 ;
10093 wxPoint2D temp2 ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "pt", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10104 }
10105 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10106 {
10107 arg2 = &temp2;
10108 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10109 }
10110 {
10111 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 resultobj = SWIG_Py_Void();
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122 PyObject *resultobj = 0;
10123 wxRect2D *arg1 = (wxRect2D *) 0 ;
10124 wxPoint2D result;
10125 void *argp1 = 0 ;
10126 int res1 = 0 ;
10127 PyObject *swig_obj[1] ;
10128
10129 if (!args) SWIG_fail;
10130 swig_obj[0] = args;
10131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10132 if (!SWIG_IsOK(res1)) {
10133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10134 }
10135 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10136 {
10137 result = ((wxRect2D const *)arg1)->GetRightBottom();
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10141 return resultobj;
10142 fail:
10143 return NULL;
10144 }
10145
10146
10147 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj = 0;
10149 wxRect2D *arg1 = (wxRect2D *) 0 ;
10150 wxPoint2D *arg2 = 0 ;
10151 void *argp1 = 0 ;
10152 int res1 = 0 ;
10153 wxPoint2D temp2 ;
10154 PyObject * obj0 = 0 ;
10155 PyObject * obj1 = 0 ;
10156 char * kwnames[] = {
10157 (char *) "self",(char *) "pt", NULL
10158 };
10159
10160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10162 if (!SWIG_IsOK(res1)) {
10163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10164 }
10165 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10166 {
10167 arg2 = &temp2;
10168 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10169 }
10170 {
10171 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 resultobj = SWIG_Py_Void();
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj = 0;
10183 wxRect2D *arg1 = (wxRect2D *) 0 ;
10184 wxPoint2D *arg2 = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 wxPoint2D temp2 ;
10188 PyObject * obj0 = 0 ;
10189 PyObject * obj1 = 0 ;
10190 char * kwnames[] = {
10191 (char *) "self",(char *) "pt", NULL
10192 };
10193
10194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10196 if (!SWIG_IsOK(res1)) {
10197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10198 }
10199 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10200 {
10201 arg2 = &temp2;
10202 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10203 }
10204 {
10205 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 resultobj = SWIG_Py_Void();
10209 return resultobj;
10210 fail:
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10216 PyObject *resultobj = 0;
10217 wxRect2D *arg1 = (wxRect2D *) 0 ;
10218 wxPoint2D result;
10219 void *argp1 = 0 ;
10220 int res1 = 0 ;
10221 PyObject *swig_obj[1] ;
10222
10223 if (!args) SWIG_fail;
10224 swig_obj[0] = args;
10225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10226 if (!SWIG_IsOK(res1)) {
10227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10228 }
10229 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10230 {
10231 result = ((wxRect2D const *)arg1)->GetCentre();
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10235 return resultobj;
10236 fail:
10237 return NULL;
10238 }
10239
10240
10241 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10242 PyObject *resultobj = 0;
10243 wxRect2D *arg1 = (wxRect2D *) 0 ;
10244 wxPoint2D *arg2 = 0 ;
10245 void *argp1 = 0 ;
10246 int res1 = 0 ;
10247 wxPoint2D temp2 ;
10248 PyObject * obj0 = 0 ;
10249 PyObject * obj1 = 0 ;
10250 char * kwnames[] = {
10251 (char *) "self",(char *) "pt", NULL
10252 };
10253
10254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10256 if (!SWIG_IsOK(res1)) {
10257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10258 }
10259 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10260 {
10261 arg2 = &temp2;
10262 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10263 }
10264 {
10265 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10266 if (PyErr_Occurred()) SWIG_fail;
10267 }
10268 resultobj = SWIG_Py_Void();
10269 return resultobj;
10270 fail:
10271 return NULL;
10272 }
10273
10274
10275 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10276 PyObject *resultobj = 0;
10277 wxRect2D *arg1 = (wxRect2D *) 0 ;
10278 wxPoint2D *arg2 = 0 ;
10279 void *argp1 = 0 ;
10280 int res1 = 0 ;
10281 wxPoint2D temp2 ;
10282 PyObject * obj0 = 0 ;
10283 PyObject * obj1 = 0 ;
10284 char * kwnames[] = {
10285 (char *) "self",(char *) "pt", NULL
10286 };
10287
10288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10290 if (!SWIG_IsOK(res1)) {
10291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10292 }
10293 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10294 {
10295 arg2 = &temp2;
10296 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10297 }
10298 {
10299 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10300 if (PyErr_Occurred()) SWIG_fail;
10301 }
10302 resultobj = SWIG_Py_Void();
10303 return resultobj;
10304 fail:
10305 return NULL;
10306 }
10307
10308
10309 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10310 PyObject *resultobj = 0;
10311 wxRect2D *arg1 = (wxRect2D *) 0 ;
10312 wxPoint2D *arg2 = 0 ;
10313 wxOutCode result;
10314 void *argp1 = 0 ;
10315 int res1 = 0 ;
10316 wxPoint2D temp2 ;
10317 PyObject * obj0 = 0 ;
10318 PyObject * obj1 = 0 ;
10319 char * kwnames[] = {
10320 (char *) "self",(char *) "pt", NULL
10321 };
10322
10323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10325 if (!SWIG_IsOK(res1)) {
10326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10327 }
10328 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10329 {
10330 arg2 = &temp2;
10331 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10332 }
10333 {
10334 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 resultobj = SWIG_From_int(static_cast< int >(result));
10338 return resultobj;
10339 fail:
10340 return NULL;
10341 }
10342
10343
10344 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10345 PyObject *resultobj = 0;
10346 wxRect2D *arg1 = (wxRect2D *) 0 ;
10347 wxPoint2D *arg2 = 0 ;
10348 bool result;
10349 void *argp1 = 0 ;
10350 int res1 = 0 ;
10351 wxPoint2D temp2 ;
10352 PyObject * obj0 = 0 ;
10353 PyObject * obj1 = 0 ;
10354 char * kwnames[] = {
10355 (char *) "self",(char *) "pt", NULL
10356 };
10357
10358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10360 if (!SWIG_IsOK(res1)) {
10361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10362 }
10363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10364 {
10365 arg2 = &temp2;
10366 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10367 }
10368 {
10369 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10370 if (PyErr_Occurred()) SWIG_fail;
10371 }
10372 {
10373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10374 }
10375 return resultobj;
10376 fail:
10377 return NULL;
10378 }
10379
10380
10381 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj = 0;
10383 wxRect2D *arg1 = (wxRect2D *) 0 ;
10384 wxRect2D *arg2 = 0 ;
10385 bool result;
10386 void *argp1 = 0 ;
10387 int res1 = 0 ;
10388 wxRect2D temp2 ;
10389 PyObject * obj0 = 0 ;
10390 PyObject * obj1 = 0 ;
10391 char * kwnames[] = {
10392 (char *) "self",(char *) "rect", NULL
10393 };
10394
10395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10399 }
10400 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10401 {
10402 arg2 = &temp2;
10403 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10404 }
10405 {
10406 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10407 if (PyErr_Occurred()) SWIG_fail;
10408 }
10409 {
10410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10411 }
10412 return resultobj;
10413 fail:
10414 return NULL;
10415 }
10416
10417
10418 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10419 PyObject *resultobj = 0;
10420 wxRect2D *arg1 = (wxRect2D *) 0 ;
10421 bool result;
10422 void *argp1 = 0 ;
10423 int res1 = 0 ;
10424 PyObject *swig_obj[1] ;
10425
10426 if (!args) SWIG_fail;
10427 swig_obj[0] = args;
10428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10429 if (!SWIG_IsOK(res1)) {
10430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10431 }
10432 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10433 {
10434 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 {
10438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10439 }
10440 return resultobj;
10441 fail:
10442 return NULL;
10443 }
10444
10445
10446 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10447 PyObject *resultobj = 0;
10448 wxRect2D *arg1 = (wxRect2D *) 0 ;
10449 wxRect2D *arg2 = 0 ;
10450 bool result;
10451 void *argp1 = 0 ;
10452 int res1 = 0 ;
10453 wxRect2D temp2 ;
10454 PyObject * obj0 = 0 ;
10455 PyObject * obj1 = 0 ;
10456 char * kwnames[] = {
10457 (char *) "self",(char *) "rect", NULL
10458 };
10459
10460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10462 if (!SWIG_IsOK(res1)) {
10463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10464 }
10465 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10466 {
10467 arg2 = &temp2;
10468 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10469 }
10470 {
10471 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 {
10475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10476 }
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10484 PyObject *resultobj = 0;
10485 wxRect2D *arg1 = (wxRect2D *) 0 ;
10486 wxDouble arg2 ;
10487 wxDouble arg3 ;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 void *argp2 ;
10491 int res2 = 0 ;
10492 void *argp3 ;
10493 int res3 = 0 ;
10494
10495 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10497 if (!SWIG_IsOK(res1)) {
10498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10499 }
10500 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10501 {
10502 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10503 if (!SWIG_IsOK(res2)) {
10504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10505 }
10506 if (!argp2) {
10507 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10508 } else {
10509 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10510 arg2 = *temp;
10511 if (SWIG_IsNewObj(res2)) delete temp;
10512 }
10513 }
10514 {
10515 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10516 if (!SWIG_IsOK(res3)) {
10517 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10518 }
10519 if (!argp3) {
10520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10521 } else {
10522 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10523 arg3 = *temp;
10524 if (SWIG_IsNewObj(res3)) delete temp;
10525 }
10526 }
10527 {
10528 (arg1)->Inset(arg2,arg3);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 resultobj = SWIG_Py_Void();
10532 return resultobj;
10533 fail:
10534 return NULL;
10535 }
10536
10537
10538 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10539 PyObject *resultobj = 0;
10540 wxRect2D *arg1 = (wxRect2D *) 0 ;
10541 wxDouble arg2 ;
10542 wxDouble arg3 ;
10543 wxDouble arg4 ;
10544 wxDouble arg5 ;
10545 void *argp1 = 0 ;
10546 int res1 = 0 ;
10547 void *argp2 ;
10548 int res2 = 0 ;
10549 void *argp3 ;
10550 int res3 = 0 ;
10551 void *argp4 ;
10552 int res4 = 0 ;
10553 void *argp5 ;
10554 int res5 = 0 ;
10555
10556 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10560 }
10561 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10562 {
10563 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10564 if (!SWIG_IsOK(res2)) {
10565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10566 }
10567 if (!argp2) {
10568 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10569 } else {
10570 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10571 arg2 = *temp;
10572 if (SWIG_IsNewObj(res2)) delete temp;
10573 }
10574 }
10575 {
10576 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10577 if (!SWIG_IsOK(res3)) {
10578 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10579 }
10580 if (!argp3) {
10581 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10582 } else {
10583 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10584 arg3 = *temp;
10585 if (SWIG_IsNewObj(res3)) delete temp;
10586 }
10587 }
10588 {
10589 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10590 if (!SWIG_IsOK(res4)) {
10591 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10592 }
10593 if (!argp4) {
10594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10595 } else {
10596 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10597 arg4 = *temp;
10598 if (SWIG_IsNewObj(res4)) delete temp;
10599 }
10600 }
10601 {
10602 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10603 if (!SWIG_IsOK(res5)) {
10604 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10605 }
10606 if (!argp5) {
10607 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10608 } else {
10609 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10610 arg5 = *temp;
10611 if (SWIG_IsNewObj(res5)) delete temp;
10612 }
10613 }
10614 {
10615 (arg1)->Inset(arg2,arg3,arg4,arg5);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 resultobj = SWIG_Py_Void();
10619 return resultobj;
10620 fail:
10621 return NULL;
10622 }
10623
10624
10625 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10626 int argc;
10627 PyObject *argv[6];
10628
10629 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10630 --argc;
10631 if (argc == 3) {
10632 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10633 }
10634 if (argc == 5) {
10635 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10636 }
10637
10638 fail:
10639 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10640 return NULL;
10641 }
10642
10643
10644 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj = 0;
10646 wxRect2D *arg1 = (wxRect2D *) 0 ;
10647 wxPoint2D *arg2 = 0 ;
10648 void *argp1 = 0 ;
10649 int res1 = 0 ;
10650 wxPoint2D temp2 ;
10651 PyObject * obj0 = 0 ;
10652 PyObject * obj1 = 0 ;
10653 char * kwnames[] = {
10654 (char *) "self",(char *) "pt", NULL
10655 };
10656
10657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10659 if (!SWIG_IsOK(res1)) {
10660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10661 }
10662 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10663 {
10664 arg2 = &temp2;
10665 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10666 }
10667 {
10668 (arg1)->Offset((wxPoint2D const &)*arg2);
10669 if (PyErr_Occurred()) SWIG_fail;
10670 }
10671 resultobj = SWIG_Py_Void();
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10679 PyObject *resultobj = 0;
10680 wxRect2D *arg1 = (wxRect2D *) 0 ;
10681 wxRect2D *arg2 = 0 ;
10682 void *argp1 = 0 ;
10683 int res1 = 0 ;
10684 wxRect2D temp2 ;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 char * kwnames[] = {
10688 (char *) "self",(char *) "rect", NULL
10689 };
10690
10691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10693 if (!SWIG_IsOK(res1)) {
10694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10695 }
10696 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10697 {
10698 arg2 = &temp2;
10699 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10700 }
10701 {
10702 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10703 if (PyErr_Occurred()) SWIG_fail;
10704 }
10705 resultobj = SWIG_Py_Void();
10706 return resultobj;
10707 fail:
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10713 PyObject *resultobj = 0;
10714 wxRect2D *arg1 = (wxRect2D *) 0 ;
10715 int arg2 ;
10716 int arg3 ;
10717 wxPoint2D result;
10718 void *argp1 = 0 ;
10719 int res1 = 0 ;
10720 int val2 ;
10721 int ecode2 = 0 ;
10722 int val3 ;
10723 int ecode3 = 0 ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 PyObject * obj2 = 0 ;
10727 char * kwnames[] = {
10728 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10729 };
10730
10731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10733 if (!SWIG_IsOK(res1)) {
10734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10735 }
10736 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10737 ecode2 = SWIG_AsVal_int(obj1, &val2);
10738 if (!SWIG_IsOK(ecode2)) {
10739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10740 }
10741 arg2 = static_cast< int >(val2);
10742 ecode3 = SWIG_AsVal_int(obj2, &val3);
10743 if (!SWIG_IsOK(ecode3)) {
10744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10745 }
10746 arg3 = static_cast< int >(val3);
10747 {
10748 result = (arg1)->Interpolate(arg2,arg3);
10749 if (PyErr_Occurred()) SWIG_fail;
10750 }
10751 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10752 return resultobj;
10753 fail:
10754 return NULL;
10755 }
10756
10757
10758 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10759 PyObject *resultobj = 0;
10760 wxRect2D *arg1 = (wxRect2D *) 0 ;
10761 wxRect2D *arg2 = 0 ;
10762 void *argp1 = 0 ;
10763 int res1 = 0 ;
10764 wxRect2D temp2 ;
10765 PyObject * obj0 = 0 ;
10766 PyObject * obj1 = 0 ;
10767 char * kwnames[] = {
10768 (char *) "self",(char *) "otherRect", NULL
10769 };
10770
10771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10773 if (!SWIG_IsOK(res1)) {
10774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10775 }
10776 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10777 {
10778 arg2 = &temp2;
10779 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10780 }
10781 {
10782 (arg1)->Intersect((wxRect2D const &)*arg2);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 resultobj = SWIG_Py_Void();
10786 return resultobj;
10787 fail:
10788 return NULL;
10789 }
10790
10791
10792 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10793 PyObject *resultobj = 0;
10794 wxRect2D *arg1 = (wxRect2D *) 0 ;
10795 wxRect2D *arg2 = 0 ;
10796 wxRect2D result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 wxRect2D temp2 ;
10800 PyObject * obj0 = 0 ;
10801 PyObject * obj1 = 0 ;
10802 char * kwnames[] = {
10803 (char *) "self",(char *) "otherRect", NULL
10804 };
10805
10806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10808 if (!SWIG_IsOK(res1)) {
10809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10810 }
10811 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10812 {
10813 arg2 = &temp2;
10814 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10815 }
10816 {
10817 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10818 if (PyErr_Occurred()) SWIG_fail;
10819 }
10820 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxRect2D *arg1 = (wxRect2D *) 0 ;
10830 wxRect2D *arg2 = 0 ;
10831 bool result;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 wxRect2D temp2 ;
10835 PyObject * obj0 = 0 ;
10836 PyObject * obj1 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "self",(char *) "rect", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10843 if (!SWIG_IsOK(res1)) {
10844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10845 }
10846 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10847 {
10848 arg2 = &temp2;
10849 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10850 }
10851 {
10852 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 {
10856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10857 }
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj = 0;
10866 wxRect2D *arg1 = (wxRect2D *) 0 ;
10867 wxRect2D *arg2 = 0 ;
10868 void *argp1 = 0 ;
10869 int res1 = 0 ;
10870 wxRect2D temp2 ;
10871 PyObject * obj0 = 0 ;
10872 PyObject * obj1 = 0 ;
10873 char * kwnames[] = {
10874 (char *) "self",(char *) "otherRect", NULL
10875 };
10876
10877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10879 if (!SWIG_IsOK(res1)) {
10880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10881 }
10882 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10883 {
10884 arg2 = &temp2;
10885 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10886 }
10887 {
10888 (arg1)->Union((wxRect2D const &)*arg2);
10889 if (PyErr_Occurred()) SWIG_fail;
10890 }
10891 resultobj = SWIG_Py_Void();
10892 return resultobj;
10893 fail:
10894 return NULL;
10895 }
10896
10897
10898 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10899 PyObject *resultobj = 0;
10900 wxRect2D *arg1 = (wxRect2D *) 0 ;
10901 wxRect2D *arg2 = 0 ;
10902 wxRect2D result;
10903 void *argp1 = 0 ;
10904 int res1 = 0 ;
10905 wxRect2D temp2 ;
10906 PyObject * obj0 = 0 ;
10907 PyObject * obj1 = 0 ;
10908 char * kwnames[] = {
10909 (char *) "self",(char *) "otherRect", NULL
10910 };
10911
10912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10914 if (!SWIG_IsOK(res1)) {
10915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10916 }
10917 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10918 {
10919 arg2 = &temp2;
10920 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10921 }
10922 {
10923 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10934 PyObject *resultobj = 0;
10935 wxRect2D *arg1 = (wxRect2D *) 0 ;
10936 wxDouble arg2 ;
10937 void *argp1 = 0 ;
10938 int res1 = 0 ;
10939 void *argp2 ;
10940 int res2 = 0 ;
10941
10942 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10944 if (!SWIG_IsOK(res1)) {
10945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10946 }
10947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10948 {
10949 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10950 if (!SWIG_IsOK(res2)) {
10951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10952 }
10953 if (!argp2) {
10954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10955 } else {
10956 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10957 arg2 = *temp;
10958 if (SWIG_IsNewObj(res2)) delete temp;
10959 }
10960 }
10961 {
10962 (arg1)->Scale(arg2);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 resultobj = SWIG_Py_Void();
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10973 PyObject *resultobj = 0;
10974 wxRect2D *arg1 = (wxRect2D *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 void *argp1 = 0 ;
10978 int res1 = 0 ;
10979 int val2 ;
10980 int ecode2 = 0 ;
10981 int val3 ;
10982 int ecode3 = 0 ;
10983
10984 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10986 if (!SWIG_IsOK(res1)) {
10987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10988 }
10989 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10990 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10991 if (!SWIG_IsOK(ecode2)) {
10992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10993 }
10994 arg2 = static_cast< int >(val2);
10995 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10996 if (!SWIG_IsOK(ecode3)) {
10997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10998 }
10999 arg3 = static_cast< int >(val3);
11000 {
11001 (arg1)->Scale(arg2,arg3);
11002 if (PyErr_Occurred()) SWIG_fail;
11003 }
11004 resultobj = SWIG_Py_Void();
11005 return resultobj;
11006 fail:
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11012 int argc;
11013 PyObject *argv[4];
11014
11015 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11016 --argc;
11017 if (argc == 2) {
11018 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11019 }
11020 if (argc == 3) {
11021 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11022 }
11023
11024 fail:
11025 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11026 return NULL;
11027 }
11028
11029
11030 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11031 PyObject *resultobj = 0;
11032 wxRect2D *arg1 = (wxRect2D *) 0 ;
11033 PyObject *arg2 = (PyObject *) 0 ;
11034 bool result;
11035 void *argp1 = 0 ;
11036 int res1 = 0 ;
11037 PyObject * obj0 = 0 ;
11038 PyObject * obj1 = 0 ;
11039 char * kwnames[] = {
11040 (char *) "self",(char *) "other", NULL
11041 };
11042
11043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11045 if (!SWIG_IsOK(res1)) {
11046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11047 }
11048 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11049 arg2 = obj1;
11050 {
11051 result = (bool)wxRect2D___eq__(arg1,arg2);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 {
11055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11056 }
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11064 PyObject *resultobj = 0;
11065 wxRect2D *arg1 = (wxRect2D *) 0 ;
11066 PyObject *arg2 = (PyObject *) 0 ;
11067 bool result;
11068 void *argp1 = 0 ;
11069 int res1 = 0 ;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 char * kwnames[] = {
11073 (char *) "self",(char *) "other", NULL
11074 };
11075
11076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11078 if (!SWIG_IsOK(res1)) {
11079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11080 }
11081 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11082 arg2 = obj1;
11083 {
11084 result = (bool)wxRect2D___ne__(arg1,arg2);
11085 if (PyErr_Occurred()) SWIG_fail;
11086 }
11087 {
11088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11089 }
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097 PyObject *resultobj = 0;
11098 wxRect2D *arg1 = (wxRect2D *) 0 ;
11099 wxDouble arg2 ;
11100 void *argp1 = 0 ;
11101 int res1 = 0 ;
11102 void *argp2 ;
11103 int res2 = 0 ;
11104 PyObject *swig_obj[2] ;
11105
11106 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
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_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11110 }
11111 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11112 {
11113 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11114 if (!SWIG_IsOK(res2)) {
11115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11116 }
11117 if (!argp2) {
11118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11119 } else {
11120 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11121 arg2 = *temp;
11122 if (SWIG_IsNewObj(res2)) delete temp;
11123 }
11124 }
11125 if (arg1) (arg1)->m_x = arg2;
11126
11127 resultobj = SWIG_Py_Void();
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11135 PyObject *resultobj = 0;
11136 wxRect2D *arg1 = (wxRect2D *) 0 ;
11137 wxDouble result;
11138 void *argp1 = 0 ;
11139 int res1 = 0 ;
11140 PyObject *swig_obj[1] ;
11141
11142 if (!args) SWIG_fail;
11143 swig_obj[0] = args;
11144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11145 if (!SWIG_IsOK(res1)) {
11146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11147 }
11148 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11149 result = ((arg1)->m_x);
11150 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11158 PyObject *resultobj = 0;
11159 wxRect2D *arg1 = (wxRect2D *) 0 ;
11160 wxDouble arg2 ;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 void *argp2 ;
11164 int res2 = 0 ;
11165 PyObject *swig_obj[2] ;
11166
11167 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
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_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11171 }
11172 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11173 {
11174 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11175 if (!SWIG_IsOK(res2)) {
11176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11177 }
11178 if (!argp2) {
11179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11180 } else {
11181 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11182 arg2 = *temp;
11183 if (SWIG_IsNewObj(res2)) delete temp;
11184 }
11185 }
11186 if (arg1) (arg1)->m_y = arg2;
11187
11188 resultobj = SWIG_Py_Void();
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11196 PyObject *resultobj = 0;
11197 wxRect2D *arg1 = (wxRect2D *) 0 ;
11198 wxDouble result;
11199 void *argp1 = 0 ;
11200 int res1 = 0 ;
11201 PyObject *swig_obj[1] ;
11202
11203 if (!args) SWIG_fail;
11204 swig_obj[0] = args;
11205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11206 if (!SWIG_IsOK(res1)) {
11207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11208 }
11209 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11210 result = ((arg1)->m_y);
11211 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11212 return resultobj;
11213 fail:
11214 return NULL;
11215 }
11216
11217
11218 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11219 PyObject *resultobj = 0;
11220 wxRect2D *arg1 = (wxRect2D *) 0 ;
11221 wxDouble arg2 ;
11222 void *argp1 = 0 ;
11223 int res1 = 0 ;
11224 void *argp2 ;
11225 int res2 = 0 ;
11226 PyObject *swig_obj[2] ;
11227
11228 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
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_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11232 }
11233 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11234 {
11235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11236 if (!SWIG_IsOK(res2)) {
11237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11238 }
11239 if (!argp2) {
11240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11241 } else {
11242 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11243 arg2 = *temp;
11244 if (SWIG_IsNewObj(res2)) delete temp;
11245 }
11246 }
11247 if (arg1) (arg1)->m_width = arg2;
11248
11249 resultobj = SWIG_Py_Void();
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *resultobj = 0;
11258 wxRect2D *arg1 = (wxRect2D *) 0 ;
11259 wxDouble result;
11260 void *argp1 = 0 ;
11261 int res1 = 0 ;
11262 PyObject *swig_obj[1] ;
11263
11264 if (!args) SWIG_fail;
11265 swig_obj[0] = args;
11266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11267 if (!SWIG_IsOK(res1)) {
11268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11269 }
11270 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11271 result = ((arg1)->m_width);
11272 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11273 return resultobj;
11274 fail:
11275 return NULL;
11276 }
11277
11278
11279 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11280 PyObject *resultobj = 0;
11281 wxRect2D *arg1 = (wxRect2D *) 0 ;
11282 wxDouble arg2 ;
11283 void *argp1 = 0 ;
11284 int res1 = 0 ;
11285 void *argp2 ;
11286 int res2 = 0 ;
11287 PyObject *swig_obj[2] ;
11288
11289 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11291 if (!SWIG_IsOK(res1)) {
11292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11293 }
11294 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11295 {
11296 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11297 if (!SWIG_IsOK(res2)) {
11298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11299 }
11300 if (!argp2) {
11301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11302 } else {
11303 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11304 arg2 = *temp;
11305 if (SWIG_IsNewObj(res2)) delete temp;
11306 }
11307 }
11308 if (arg1) (arg1)->m_height = arg2;
11309
11310 resultobj = SWIG_Py_Void();
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11318 PyObject *resultobj = 0;
11319 wxRect2D *arg1 = (wxRect2D *) 0 ;
11320 wxDouble result;
11321 void *argp1 = 0 ;
11322 int res1 = 0 ;
11323 PyObject *swig_obj[1] ;
11324
11325 if (!args) SWIG_fail;
11326 swig_obj[0] = args;
11327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11328 if (!SWIG_IsOK(res1)) {
11329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11330 }
11331 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11332 result = ((arg1)->m_height);
11333 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11334 return resultobj;
11335 fail:
11336 return NULL;
11337 }
11338
11339
11340 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11341 PyObject *resultobj = 0;
11342 wxRect2D *arg1 = (wxRect2D *) 0 ;
11343 wxDouble arg2 = (wxDouble) 0 ;
11344 wxDouble arg3 = (wxDouble) 0 ;
11345 wxDouble arg4 = (wxDouble) 0 ;
11346 wxDouble arg5 = (wxDouble) 0 ;
11347 void *argp1 = 0 ;
11348 int res1 = 0 ;
11349 void *argp2 ;
11350 int res2 = 0 ;
11351 void *argp3 ;
11352 int res3 = 0 ;
11353 void *argp4 ;
11354 int res4 = 0 ;
11355 void *argp5 ;
11356 int res5 = 0 ;
11357 PyObject * obj0 = 0 ;
11358 PyObject * obj1 = 0 ;
11359 PyObject * obj2 = 0 ;
11360 PyObject * obj3 = 0 ;
11361 PyObject * obj4 = 0 ;
11362 char * kwnames[] = {
11363 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11364 };
11365
11366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11368 if (!SWIG_IsOK(res1)) {
11369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11370 }
11371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11372 if (obj1) {
11373 {
11374 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11375 if (!SWIG_IsOK(res2)) {
11376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11377 }
11378 if (!argp2) {
11379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11380 } else {
11381 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11382 arg2 = *temp;
11383 if (SWIG_IsNewObj(res2)) delete temp;
11384 }
11385 }
11386 }
11387 if (obj2) {
11388 {
11389 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11390 if (!SWIG_IsOK(res3)) {
11391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11392 }
11393 if (!argp3) {
11394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11395 } else {
11396 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11397 arg3 = *temp;
11398 if (SWIG_IsNewObj(res3)) delete temp;
11399 }
11400 }
11401 }
11402 if (obj3) {
11403 {
11404 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11405 if (!SWIG_IsOK(res4)) {
11406 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11407 }
11408 if (!argp4) {
11409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11410 } else {
11411 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11412 arg4 = *temp;
11413 if (SWIG_IsNewObj(res4)) delete temp;
11414 }
11415 }
11416 }
11417 if (obj4) {
11418 {
11419 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11420 if (!SWIG_IsOK(res5)) {
11421 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11422 }
11423 if (!argp5) {
11424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11425 } else {
11426 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11427 arg5 = *temp;
11428 if (SWIG_IsNewObj(res5)) delete temp;
11429 }
11430 }
11431 }
11432 {
11433 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 resultobj = SWIG_Py_Void();
11437 return resultobj;
11438 fail:
11439 return NULL;
11440 }
11441
11442
11443 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11444 PyObject *resultobj = 0;
11445 wxRect2D *arg1 = (wxRect2D *) 0 ;
11446 PyObject *result = 0 ;
11447 void *argp1 = 0 ;
11448 int res1 = 0 ;
11449 PyObject *swig_obj[1] ;
11450
11451 if (!args) SWIG_fail;
11452 swig_obj[0] = args;
11453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11454 if (!SWIG_IsOK(res1)) {
11455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11456 }
11457 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11458 {
11459 result = (PyObject *)wxRect2D_Get(arg1);
11460 if (PyErr_Occurred()) SWIG_fail;
11461 }
11462 resultobj = result;
11463 return resultobj;
11464 fail:
11465 return NULL;
11466 }
11467
11468
11469 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 PyObject *obj;
11471 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11472 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11473 return SWIG_Py_Void();
11474 }
11475
11476 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11477 return SWIG_Python_InitShadowInstance(args);
11478 }
11479
11480 SWIGINTERN PyObject *_wrap_new_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11481 PyObject *resultobj = 0;
11482 int arg1 = (int) 0 ;
11483 int arg2 = (int) 0 ;
11484 wxPosition *result = 0 ;
11485 int val1 ;
11486 int ecode1 = 0 ;
11487 int val2 ;
11488 int ecode2 = 0 ;
11489 PyObject * obj0 = 0 ;
11490 PyObject * obj1 = 0 ;
11491 char * kwnames[] = {
11492 (char *) "row",(char *) "col", NULL
11493 };
11494
11495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Position",kwnames,&obj0,&obj1)) SWIG_fail;
11496 if (obj0) {
11497 ecode1 = SWIG_AsVal_int(obj0, &val1);
11498 if (!SWIG_IsOK(ecode1)) {
11499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Position" "', expected argument " "1"" of type '" "int""'");
11500 }
11501 arg1 = static_cast< int >(val1);
11502 }
11503 if (obj1) {
11504 ecode2 = SWIG_AsVal_int(obj1, &val2);
11505 if (!SWIG_IsOK(ecode2)) {
11506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Position" "', expected argument " "2"" of type '" "int""'");
11507 }
11508 arg2 = static_cast< int >(val2);
11509 }
11510 {
11511 result = (wxPosition *)new wxPosition(arg1,arg2);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPosition, SWIG_POINTER_NEW | 0 );
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 SWIGINTERN PyObject *_wrap_delete_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11522 PyObject *resultobj = 0;
11523 wxPosition *arg1 = (wxPosition *) 0 ;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 PyObject *swig_obj[1] ;
11527
11528 if (!args) SWIG_fail;
11529 swig_obj[0] = args;
11530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, SWIG_POINTER_DISOWN | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', expected argument " "1"" of type '" "wxPosition *""'");
11533 }
11534 arg1 = reinterpret_cast< wxPosition * >(argp1);
11535 {
11536 delete arg1;
11537
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 resultobj = SWIG_Py_Void();
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *_wrap_Position_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11548 PyObject *resultobj = 0;
11549 wxPosition *arg1 = (wxPosition *) 0 ;
11550 int result;
11551 void *argp1 = 0 ;
11552 int res1 = 0 ;
11553 PyObject *swig_obj[1] ;
11554
11555 if (!args) SWIG_fail;
11556 swig_obj[0] = args;
11557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11558 if (!SWIG_IsOK(res1)) {
11559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetRow" "', expected argument " "1"" of type '" "wxPosition const *""'");
11560 }
11561 arg1 = reinterpret_cast< wxPosition * >(argp1);
11562 {
11563 result = (int)((wxPosition const *)arg1)->GetRow();
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_From_int(static_cast< int >(result));
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_Position_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11574 PyObject *resultobj = 0;
11575 wxPosition *arg1 = (wxPosition *) 0 ;
11576 int result;
11577 void *argp1 = 0 ;
11578 int res1 = 0 ;
11579 PyObject *swig_obj[1] ;
11580
11581 if (!args) SWIG_fail;
11582 swig_obj[0] = args;
11583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11584 if (!SWIG_IsOK(res1)) {
11585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetColumn" "', expected argument " "1"" of type '" "wxPosition const *""'");
11586 }
11587 arg1 = reinterpret_cast< wxPosition * >(argp1);
11588 {
11589 result = (int)((wxPosition const *)arg1)->GetColumn();
11590 if (PyErr_Occurred()) SWIG_fail;
11591 }
11592 resultobj = SWIG_From_int(static_cast< int >(result));
11593 return resultobj;
11594 fail:
11595 return NULL;
11596 }
11597
11598
11599 SWIGINTERN PyObject *_wrap_Position_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11600 PyObject *resultobj = 0;
11601 wxPosition *arg1 = (wxPosition *) 0 ;
11602 int result;
11603 void *argp1 = 0 ;
11604 int res1 = 0 ;
11605 PyObject *swig_obj[1] ;
11606
11607 if (!args) SWIG_fail;
11608 swig_obj[0] = args;
11609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11610 if (!SWIG_IsOK(res1)) {
11611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetCol" "', expected argument " "1"" of type '" "wxPosition const *""'");
11612 }
11613 arg1 = reinterpret_cast< wxPosition * >(argp1);
11614 {
11615 result = (int)((wxPosition const *)arg1)->GetCol();
11616 if (PyErr_Occurred()) SWIG_fail;
11617 }
11618 resultobj = SWIG_From_int(static_cast< int >(result));
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *_wrap_Position_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj = 0;
11627 wxPosition *arg1 = (wxPosition *) 0 ;
11628 int arg2 ;
11629 void *argp1 = 0 ;
11630 int res1 = 0 ;
11631 int val2 ;
11632 int ecode2 = 0 ;
11633 PyObject * obj0 = 0 ;
11634 PyObject * obj1 = 0 ;
11635 char * kwnames[] = {
11636 (char *) "self",(char *) "row", NULL
11637 };
11638
11639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
11640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11641 if (!SWIG_IsOK(res1)) {
11642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetRow" "', expected argument " "1"" of type '" "wxPosition *""'");
11643 }
11644 arg1 = reinterpret_cast< wxPosition * >(argp1);
11645 ecode2 = SWIG_AsVal_int(obj1, &val2);
11646 if (!SWIG_IsOK(ecode2)) {
11647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetRow" "', expected argument " "2"" of type '" "int""'");
11648 }
11649 arg2 = static_cast< int >(val2);
11650 {
11651 (arg1)->SetRow(arg2);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 resultobj = SWIG_Py_Void();
11655 return resultobj;
11656 fail:
11657 return NULL;
11658 }
11659
11660
11661 SWIGINTERN PyObject *_wrap_Position_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11662 PyObject *resultobj = 0;
11663 wxPosition *arg1 = (wxPosition *) 0 ;
11664 int arg2 ;
11665 void *argp1 = 0 ;
11666 int res1 = 0 ;
11667 int val2 ;
11668 int ecode2 = 0 ;
11669 PyObject * obj0 = 0 ;
11670 PyObject * obj1 = 0 ;
11671 char * kwnames[] = {
11672 (char *) "self",(char *) "column", NULL
11673 };
11674
11675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
11676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetColumn" "', expected argument " "1"" of type '" "wxPosition *""'");
11679 }
11680 arg1 = reinterpret_cast< wxPosition * >(argp1);
11681 ecode2 = SWIG_AsVal_int(obj1, &val2);
11682 if (!SWIG_IsOK(ecode2)) {
11683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetColumn" "', expected argument " "2"" of type '" "int""'");
11684 }
11685 arg2 = static_cast< int >(val2);
11686 {
11687 (arg1)->SetColumn(arg2);
11688 if (PyErr_Occurred()) SWIG_fail;
11689 }
11690 resultobj = SWIG_Py_Void();
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 SWIGINTERN PyObject *_wrap_Position_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj = 0;
11699 wxPosition *arg1 = (wxPosition *) 0 ;
11700 int arg2 ;
11701 void *argp1 = 0 ;
11702 int res1 = 0 ;
11703 int val2 ;
11704 int ecode2 = 0 ;
11705 PyObject * obj0 = 0 ;
11706 PyObject * obj1 = 0 ;
11707 char * kwnames[] = {
11708 (char *) "self",(char *) "column", NULL
11709 };
11710
11711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
11712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11713 if (!SWIG_IsOK(res1)) {
11714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetCol" "', expected argument " "1"" of type '" "wxPosition *""'");
11715 }
11716 arg1 = reinterpret_cast< wxPosition * >(argp1);
11717 ecode2 = SWIG_AsVal_int(obj1, &val2);
11718 if (!SWIG_IsOK(ecode2)) {
11719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetCol" "', expected argument " "2"" of type '" "int""'");
11720 }
11721 arg2 = static_cast< int >(val2);
11722 {
11723 (arg1)->SetCol(arg2);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 resultobj = SWIG_Py_Void();
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_Position___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj = 0;
11735 wxPosition *arg1 = (wxPosition *) 0 ;
11736 PyObject *arg2 = (PyObject *) 0 ;
11737 bool result;
11738 void *argp1 = 0 ;
11739 int res1 = 0 ;
11740 PyObject * obj0 = 0 ;
11741 PyObject * obj1 = 0 ;
11742 char * kwnames[] = {
11743 (char *) "self",(char *) "other", NULL
11744 };
11745
11746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11748 if (!SWIG_IsOK(res1)) {
11749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___eq__" "', expected argument " "1"" of type '" "wxPosition *""'");
11750 }
11751 arg1 = reinterpret_cast< wxPosition * >(argp1);
11752 arg2 = obj1;
11753 {
11754 result = (bool)wxPosition___eq__(arg1,arg2);
11755 if (PyErr_Occurred()) SWIG_fail;
11756 }
11757 {
11758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11759 }
11760 return resultobj;
11761 fail:
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap_Position___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj = 0;
11768 wxPosition *arg1 = (wxPosition *) 0 ;
11769 PyObject *arg2 = (PyObject *) 0 ;
11770 bool result;
11771 void *argp1 = 0 ;
11772 int res1 = 0 ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 char * kwnames[] = {
11776 (char *) "self",(char *) "other", NULL
11777 };
11778
11779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11781 if (!SWIG_IsOK(res1)) {
11782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___ne__" "', expected argument " "1"" of type '" "wxPosition *""'");
11783 }
11784 arg1 = reinterpret_cast< wxPosition * >(argp1);
11785 arg2 = obj1;
11786 {
11787 result = (bool)wxPosition___ne__(arg1,arg2);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 SWIGINTERN PyObject *_wrap_Position___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11800 PyObject *resultobj = 0;
11801 wxPosition *arg1 = (wxPosition *) 0 ;
11802 wxPosition *arg2 = 0 ;
11803 wxPosition result;
11804 void *argp1 = 0 ;
11805 int res1 = 0 ;
11806 void *argp2 = 0 ;
11807 int res2 = 0 ;
11808
11809 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11811 if (!SWIG_IsOK(res1)) {
11812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11813 }
11814 arg1 = reinterpret_cast< wxPosition * >(argp1);
11815 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11816 if (!SWIG_IsOK(res2)) {
11817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11818 }
11819 if (!argp2) {
11820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11821 }
11822 arg2 = reinterpret_cast< wxPosition * >(argp2);
11823 {
11824 result = ((wxPosition const *)arg1)->operator +((wxPosition const &)*arg2);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11835 PyObject *resultobj = 0;
11836 wxPosition *arg1 = (wxPosition *) 0 ;
11837 wxPosition *arg2 = 0 ;
11838 wxPosition result;
11839 void *argp1 = 0 ;
11840 int res1 = 0 ;
11841 void *argp2 = 0 ;
11842 int res2 = 0 ;
11843
11844 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11846 if (!SWIG_IsOK(res1)) {
11847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11848 }
11849 arg1 = reinterpret_cast< wxPosition * >(argp1);
11850 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11851 if (!SWIG_IsOK(res2)) {
11852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11853 }
11854 if (!argp2) {
11855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11856 }
11857 arg2 = reinterpret_cast< wxPosition * >(argp2);
11858 {
11859 result = ((wxPosition const *)arg1)->operator -((wxPosition const &)*arg2);
11860 if (PyErr_Occurred()) SWIG_fail;
11861 }
11862 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11863 return resultobj;
11864 fail:
11865 return NULL;
11866 }
11867
11868
11869 SWIGINTERN PyObject *_wrap_Position___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11870 PyObject *resultobj = 0;
11871 wxPosition *arg1 = (wxPosition *) 0 ;
11872 wxSize *arg2 = 0 ;
11873 wxPosition result;
11874 void *argp1 = 0 ;
11875 int res1 = 0 ;
11876 wxSize temp2 ;
11877
11878 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11880 if (!SWIG_IsOK(res1)) {
11881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11882 }
11883 arg1 = reinterpret_cast< wxPosition * >(argp1);
11884 {
11885 arg2 = &temp2;
11886 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11887 }
11888 {
11889 result = ((wxPosition const *)arg1)->operator +((wxSize const &)*arg2);
11890 if (PyErr_Occurred()) SWIG_fail;
11891 }
11892 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11893 return resultobj;
11894 fail:
11895 return NULL;
11896 }
11897
11898
11899 SWIGINTERN PyObject *_wrap_Position___add__(PyObject *self, PyObject *args) {
11900 int argc;
11901 PyObject *argv[3];
11902
11903 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___add__",0,2,argv))) SWIG_fail;
11904 --argc;
11905 if (argc == 2) {
11906 int _v = 0;
11907 {
11908 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11909 _v = SWIG_CheckState(res);
11910 }
11911 if (!_v) goto check_1;
11912 return _wrap_Position___add____SWIG_0(self, argc, argv);
11913 }
11914 check_1:
11915
11916 if (argc == 2) {
11917 return _wrap_Position___add____SWIG_1(self, argc, argv);
11918 }
11919
11920 fail:
11921 Py_INCREF(Py_NotImplemented);
11922 return Py_NotImplemented;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11927 PyObject *resultobj = 0;
11928 wxPosition *arg1 = (wxPosition *) 0 ;
11929 wxSize *arg2 = 0 ;
11930 wxPosition result;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 wxSize temp2 ;
11934
11935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11937 if (!SWIG_IsOK(res1)) {
11938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11939 }
11940 arg1 = reinterpret_cast< wxPosition * >(argp1);
11941 {
11942 arg2 = &temp2;
11943 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11944 }
11945 {
11946 result = ((wxPosition const *)arg1)->operator -((wxSize const &)*arg2);
11947 if (PyErr_Occurred()) SWIG_fail;
11948 }
11949 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11950 return resultobj;
11951 fail:
11952 return NULL;
11953 }
11954
11955
11956 SWIGINTERN PyObject *_wrap_Position___sub__(PyObject *self, PyObject *args) {
11957 int argc;
11958 PyObject *argv[3];
11959
11960 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___sub__",0,2,argv))) SWIG_fail;
11961 --argc;
11962 if (argc == 2) {
11963 int _v = 0;
11964 {
11965 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11966 _v = SWIG_CheckState(res);
11967 }
11968 if (!_v) goto check_1;
11969 return _wrap_Position___sub____SWIG_0(self, argc, argv);
11970 }
11971 check_1:
11972
11973 if (argc == 2) {
11974 return _wrap_Position___sub____SWIG_1(self, argc, argv);
11975 }
11976
11977 fail:
11978 Py_INCREF(Py_NotImplemented);
11979 return Py_NotImplemented;
11980 }
11981
11982
11983 SWIGINTERN PyObject *Position_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984 PyObject *obj;
11985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11986 SWIG_TypeNewClientData(SWIGTYPE_p_wxPosition, SWIG_NewClientData(obj));
11987 return SWIG_Py_Void();
11988 }
11989
11990 SWIGINTERN PyObject *Position_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11991 return SWIG_Python_InitShadowInstance(args);
11992 }
11993
11994 SWIGINTERN int DefaultPosition_set(PyObject *) {
11995 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11996 return 1;
11997 }
11998
11999
12000 SWIGINTERN PyObject *DefaultPosition_get(void) {
12001 PyObject *pyobj = 0;
12002
12003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
12004 return pyobj;
12005 }
12006
12007
12008 SWIGINTERN int DefaultSize_set(PyObject *) {
12009 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
12010 return 1;
12011 }
12012
12013
12014 SWIGINTERN PyObject *DefaultSize_get(void) {
12015 PyObject *pyobj = 0;
12016
12017 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
12018 return pyobj;
12019 }
12020
12021
12022 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj = 0;
12024 PyObject *arg1 = (PyObject *) 0 ;
12025 wxPyInputStream *result = 0 ;
12026 PyObject * obj0 = 0 ;
12027 char * kwnames[] = {
12028 (char *) "p", NULL
12029 };
12030
12031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
12032 arg1 = obj0;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
12036 wxPyEndAllowThreads(__tstate);
12037 if (PyErr_Occurred()) SWIG_fail;
12038 }
12039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
12040 return resultobj;
12041 fail:
12042 return NULL;
12043 }
12044
12045
12046 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12047 PyObject *resultobj = 0;
12048 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12049 void *argp1 = 0 ;
12050 int res1 = 0 ;
12051 PyObject *swig_obj[1] ;
12052
12053 if (!args) SWIG_fail;
12054 swig_obj[0] = args;
12055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12058 }
12059 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 delete arg1;
12063
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 resultobj = SWIG_Py_Void();
12068 return resultobj;
12069 fail:
12070 return NULL;
12071 }
12072
12073
12074 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12075 PyObject *resultobj = 0;
12076 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12077 void *argp1 = 0 ;
12078 int res1 = 0 ;
12079 PyObject *swig_obj[1] ;
12080
12081 if (!args) SWIG_fail;
12082 swig_obj[0] = args;
12083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12084 if (!SWIG_IsOK(res1)) {
12085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12086 }
12087 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 (arg1)->close();
12091 wxPyEndAllowThreads(__tstate);
12092 if (PyErr_Occurred()) SWIG_fail;
12093 }
12094 resultobj = SWIG_Py_Void();
12095 return resultobj;
12096 fail:
12097 return NULL;
12098 }
12099
12100
12101 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 PyObject *resultobj = 0;
12103 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12104 void *argp1 = 0 ;
12105 int res1 = 0 ;
12106 PyObject *swig_obj[1] ;
12107
12108 if (!args) SWIG_fail;
12109 swig_obj[0] = args;
12110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12111 if (!SWIG_IsOK(res1)) {
12112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12113 }
12114 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12115 {
12116 PyThreadState* __tstate = wxPyBeginAllowThreads();
12117 (arg1)->flush();
12118 wxPyEndAllowThreads(__tstate);
12119 if (PyErr_Occurred()) SWIG_fail;
12120 }
12121 resultobj = SWIG_Py_Void();
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12129 PyObject *resultobj = 0;
12130 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12131 bool result;
12132 void *argp1 = 0 ;
12133 int res1 = 0 ;
12134 PyObject *swig_obj[1] ;
12135
12136 if (!args) SWIG_fail;
12137 swig_obj[0] = args;
12138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12139 if (!SWIG_IsOK(res1)) {
12140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12141 }
12142 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = (bool)(arg1)->eof();
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 {
12150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12151 }
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = 0;
12160 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12161 int arg2 = (int) -1 ;
12162 PyObject *result = 0 ;
12163 void *argp1 = 0 ;
12164 int res1 = 0 ;
12165 int val2 ;
12166 int ecode2 = 0 ;
12167 PyObject * obj0 = 0 ;
12168 PyObject * obj1 = 0 ;
12169 char * kwnames[] = {
12170 (char *) "self",(char *) "size", NULL
12171 };
12172
12173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
12174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12175 if (!SWIG_IsOK(res1)) {
12176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12177 }
12178 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12179 if (obj1) {
12180 ecode2 = SWIG_AsVal_int(obj1, &val2);
12181 if (!SWIG_IsOK(ecode2)) {
12182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
12183 }
12184 arg2 = static_cast< int >(val2);
12185 }
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 result = (PyObject *)(arg1)->read(arg2);
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 resultobj = result;
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj = 0;
12201 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12202 int arg2 = (int) -1 ;
12203 PyObject *result = 0 ;
12204 void *argp1 = 0 ;
12205 int res1 = 0 ;
12206 int val2 ;
12207 int ecode2 = 0 ;
12208 PyObject * obj0 = 0 ;
12209 PyObject * obj1 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "size", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12218 }
12219 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12220 if (obj1) {
12221 ecode2 = SWIG_AsVal_int(obj1, &val2);
12222 if (!SWIG_IsOK(ecode2)) {
12223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
12224 }
12225 arg2 = static_cast< int >(val2);
12226 }
12227 {
12228 PyThreadState* __tstate = wxPyBeginAllowThreads();
12229 result = (PyObject *)(arg1)->readline(arg2);
12230 wxPyEndAllowThreads(__tstate);
12231 if (PyErr_Occurred()) SWIG_fail;
12232 }
12233 resultobj = result;
12234 return resultobj;
12235 fail:
12236 return NULL;
12237 }
12238
12239
12240 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12241 PyObject *resultobj = 0;
12242 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12243 int arg2 = (int) -1 ;
12244 PyObject *result = 0 ;
12245 void *argp1 = 0 ;
12246 int res1 = 0 ;
12247 int val2 ;
12248 int ecode2 = 0 ;
12249 PyObject * obj0 = 0 ;
12250 PyObject * obj1 = 0 ;
12251 char * kwnames[] = {
12252 (char *) "self",(char *) "sizehint", NULL
12253 };
12254
12255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
12256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12257 if (!SWIG_IsOK(res1)) {
12258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12259 }
12260 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12261 if (obj1) {
12262 ecode2 = SWIG_AsVal_int(obj1, &val2);
12263 if (!SWIG_IsOK(ecode2)) {
12264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
12265 }
12266 arg2 = static_cast< int >(val2);
12267 }
12268 {
12269 PyThreadState* __tstate = wxPyBeginAllowThreads();
12270 result = (PyObject *)(arg1)->readlines(arg2);
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 resultobj = result;
12275 return resultobj;
12276 fail:
12277 return NULL;
12278 }
12279
12280
12281 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj = 0;
12283 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12284 int arg2 ;
12285 int arg3 = (int) 0 ;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 int val2 ;
12289 int ecode2 = 0 ;
12290 int val3 ;
12291 int ecode3 = 0 ;
12292 PyObject * obj0 = 0 ;
12293 PyObject * obj1 = 0 ;
12294 PyObject * obj2 = 0 ;
12295 char * kwnames[] = {
12296 (char *) "self",(char *) "offset",(char *) "whence", NULL
12297 };
12298
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12303 }
12304 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12305 ecode2 = SWIG_AsVal_int(obj1, &val2);
12306 if (!SWIG_IsOK(ecode2)) {
12307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
12308 }
12309 arg2 = static_cast< int >(val2);
12310 if (obj2) {
12311 ecode3 = SWIG_AsVal_int(obj2, &val3);
12312 if (!SWIG_IsOK(ecode3)) {
12313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
12314 }
12315 arg3 = static_cast< int >(val3);
12316 }
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 (arg1)->seek(arg2,arg3);
12320 wxPyEndAllowThreads(__tstate);
12321 if (PyErr_Occurred()) SWIG_fail;
12322 }
12323 resultobj = SWIG_Py_Void();
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12331 PyObject *resultobj = 0;
12332 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12333 int result;
12334 void *argp1 = 0 ;
12335 int res1 = 0 ;
12336 PyObject *swig_obj[1] ;
12337
12338 if (!args) SWIG_fail;
12339 swig_obj[0] = args;
12340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12341 if (!SWIG_IsOK(res1)) {
12342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12343 }
12344 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = (int)(arg1)->tell();
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 resultobj = SWIG_From_int(static_cast< int >(result));
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12359 PyObject *resultobj = 0;
12360 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12361 char result;
12362 void *argp1 = 0 ;
12363 int res1 = 0 ;
12364 PyObject *swig_obj[1] ;
12365
12366 if (!args) SWIG_fail;
12367 swig_obj[0] = args;
12368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12369 if (!SWIG_IsOK(res1)) {
12370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12371 }
12372 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12373 {
12374 PyThreadState* __tstate = wxPyBeginAllowThreads();
12375 result = (char)(arg1)->Peek();
12376 wxPyEndAllowThreads(__tstate);
12377 if (PyErr_Occurred()) SWIG_fail;
12378 }
12379 resultobj = SWIG_From_char(static_cast< char >(result));
12380 return resultobj;
12381 fail:
12382 return NULL;
12383 }
12384
12385
12386 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12387 PyObject *resultobj = 0;
12388 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12389 char result;
12390 void *argp1 = 0 ;
12391 int res1 = 0 ;
12392 PyObject *swig_obj[1] ;
12393
12394 if (!args) SWIG_fail;
12395 swig_obj[0] = args;
12396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12397 if (!SWIG_IsOK(res1)) {
12398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12399 }
12400 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = (char)(arg1)->GetC();
12404 wxPyEndAllowThreads(__tstate);
12405 if (PyErr_Occurred()) SWIG_fail;
12406 }
12407 resultobj = SWIG_From_char(static_cast< char >(result));
12408 return resultobj;
12409 fail:
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12415 PyObject *resultobj = 0;
12416 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12417 size_t result;
12418 void *argp1 = 0 ;
12419 int res1 = 0 ;
12420 PyObject *swig_obj[1] ;
12421
12422 if (!args) SWIG_fail;
12423 swig_obj[0] = args;
12424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12425 if (!SWIG_IsOK(res1)) {
12426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12427 }
12428 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 result = (size_t)(arg1)->LastRead();
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 PyObject *resultobj = 0;
12444 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12445 bool result;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 PyObject *swig_obj[1] ;
12449
12450 if (!args) SWIG_fail;
12451 swig_obj[0] = args;
12452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12455 }
12456 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (bool)(arg1)->CanRead();
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 {
12464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12465 }
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12473 PyObject *resultobj = 0;
12474 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12475 bool result;
12476 void *argp1 = 0 ;
12477 int res1 = 0 ;
12478 PyObject *swig_obj[1] ;
12479
12480 if (!args) SWIG_fail;
12481 swig_obj[0] = args;
12482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12485 }
12486 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12487 {
12488 PyThreadState* __tstate = wxPyBeginAllowThreads();
12489 result = (bool)(arg1)->Eof();
12490 wxPyEndAllowThreads(__tstate);
12491 if (PyErr_Occurred()) SWIG_fail;
12492 }
12493 {
12494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12495 }
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj = 0;
12504 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12505 char arg2 ;
12506 bool result;
12507 void *argp1 = 0 ;
12508 int res1 = 0 ;
12509 char val2 ;
12510 int ecode2 = 0 ;
12511 PyObject * obj0 = 0 ;
12512 PyObject * obj1 = 0 ;
12513 char * kwnames[] = {
12514 (char *) "self",(char *) "c", NULL
12515 };
12516
12517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
12518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12519 if (!SWIG_IsOK(res1)) {
12520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12521 }
12522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12523 ecode2 = SWIG_AsVal_char(obj1, &val2);
12524 if (!SWIG_IsOK(ecode2)) {
12525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12526 }
12527 arg2 = static_cast< char >(val2);
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (bool)(arg1)->Ungetch(arg2);
12531 wxPyEndAllowThreads(__tstate);
12532 if (PyErr_Occurred()) SWIG_fail;
12533 }
12534 {
12535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12536 }
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12544 PyObject *resultobj = 0;
12545 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12546 long arg2 ;
12547 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12548 long result;
12549 void *argp1 = 0 ;
12550 int res1 = 0 ;
12551 long val2 ;
12552 int ecode2 = 0 ;
12553 int val3 ;
12554 int ecode3 = 0 ;
12555 PyObject * obj0 = 0 ;
12556 PyObject * obj1 = 0 ;
12557 PyObject * obj2 = 0 ;
12558 char * kwnames[] = {
12559 (char *) "self",(char *) "pos",(char *) "mode", NULL
12560 };
12561
12562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12564 if (!SWIG_IsOK(res1)) {
12565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12566 }
12567 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12568 ecode2 = SWIG_AsVal_long(obj1, &val2);
12569 if (!SWIG_IsOK(ecode2)) {
12570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12571 }
12572 arg2 = static_cast< long >(val2);
12573 if (obj2) {
12574 ecode3 = SWIG_AsVal_int(obj2, &val3);
12575 if (!SWIG_IsOK(ecode3)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12577 }
12578 arg3 = static_cast< wxSeekMode >(val3);
12579 }
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 result = (long)(arg1)->SeekI(arg2,arg3);
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 resultobj = SWIG_From_long(static_cast< long >(result));
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12594 PyObject *resultobj = 0;
12595 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12596 long result;
12597 void *argp1 = 0 ;
12598 int res1 = 0 ;
12599 PyObject *swig_obj[1] ;
12600
12601 if (!args) SWIG_fail;
12602 swig_obj[0] = args;
12603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12606 }
12607 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 result = (long)(arg1)->TellI();
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 resultobj = SWIG_From_long(static_cast< long >(result));
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12622 PyObject *obj;
12623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12624 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12625 return SWIG_Py_Void();
12626 }
12627
12628 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12629 return SWIG_Python_InitShadowInstance(args);
12630 }
12631
12632 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12633 PyObject *resultobj = 0;
12634 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12635 PyObject *arg2 = (PyObject *) 0 ;
12636 void *argp1 = 0 ;
12637 int res1 = 0 ;
12638 PyObject * obj0 = 0 ;
12639 PyObject * obj1 = 0 ;
12640 char * kwnames[] = {
12641 (char *) "self",(char *) "obj", NULL
12642 };
12643
12644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12646 if (!SWIG_IsOK(res1)) {
12647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12648 }
12649 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12650 arg2 = obj1;
12651 {
12652 PyThreadState* __tstate = wxPyBeginAllowThreads();
12653 wxOutputStream_write(arg1,arg2);
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 resultobj = SWIG_Py_Void();
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12665 PyObject *resultobj = 0;
12666 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12667 size_t result;
12668 void *argp1 = 0 ;
12669 int res1 = 0 ;
12670 PyObject *swig_obj[1] ;
12671
12672 if (!args) SWIG_fail;
12673 swig_obj[0] = args;
12674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12677 }
12678 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12682 wxPyEndAllowThreads(__tstate);
12683 if (PyErr_Occurred()) SWIG_fail;
12684 }
12685 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12693 PyObject *obj;
12694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12695 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12696 return SWIG_Py_Void();
12697 }
12698
12699 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj = 0;
12701 wxInputStream *arg1 = (wxInputStream *) 0 ;
12702 wxString *arg2 = 0 ;
12703 wxString *arg3 = 0 ;
12704 wxString *arg4 = 0 ;
12705 wxDateTime arg5 ;
12706 wxFSFile *result = 0 ;
12707 wxPyInputStream *temp1 ;
12708 bool temp2 = false ;
12709 bool temp3 = false ;
12710 bool temp4 = false ;
12711 void *argp5 ;
12712 int res5 = 0 ;
12713 PyObject * obj0 = 0 ;
12714 PyObject * obj1 = 0 ;
12715 PyObject * obj2 = 0 ;
12716 PyObject * obj3 = 0 ;
12717 PyObject * obj4 = 0 ;
12718 char * kwnames[] = {
12719 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12720 };
12721
12722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12723 {
12724 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12725 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12726 } else {
12727 PyErr_Clear(); // clear the failure of the wxPyConvert above
12728 arg1 = wxPyCBInputStream_create(obj0, true);
12729 if (arg1 == NULL) {
12730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12731 SWIG_fail;
12732 }
12733 }
12734 }
12735 {
12736 arg2 = wxString_in_helper(obj1);
12737 if (arg2 == NULL) SWIG_fail;
12738 temp2 = true;
12739 }
12740 {
12741 arg3 = wxString_in_helper(obj2);
12742 if (arg3 == NULL) SWIG_fail;
12743 temp3 = true;
12744 }
12745 {
12746 arg4 = wxString_in_helper(obj3);
12747 if (arg4 == NULL) SWIG_fail;
12748 temp4 = true;
12749 }
12750 {
12751 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12752 if (!SWIG_IsOK(res5)) {
12753 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12754 }
12755 if (!argp5) {
12756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12757 } else {
12758 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12759 arg5 = *temp;
12760 if (SWIG_IsNewObj(res5)) delete temp;
12761 }
12762 }
12763 {
12764 PyThreadState* __tstate = wxPyBeginAllowThreads();
12765 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12770 {
12771 if (temp2)
12772 delete arg2;
12773 }
12774 {
12775 if (temp3)
12776 delete arg3;
12777 }
12778 {
12779 if (temp4)
12780 delete arg4;
12781 }
12782 return resultobj;
12783 fail:
12784 {
12785 if (temp2)
12786 delete arg2;
12787 }
12788 {
12789 if (temp3)
12790 delete arg3;
12791 }
12792 {
12793 if (temp4)
12794 delete arg4;
12795 }
12796 return NULL;
12797 }
12798
12799
12800 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12801 PyObject *resultobj = 0;
12802 wxFSFile *arg1 = (wxFSFile *) 0 ;
12803 void *argp1 = 0 ;
12804 int res1 = 0 ;
12805 PyObject *swig_obj[1] ;
12806
12807 if (!args) SWIG_fail;
12808 swig_obj[0] = args;
12809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12810 if (!SWIG_IsOK(res1)) {
12811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12812 }
12813 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 delete arg1;
12817
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 resultobj = SWIG_Py_Void();
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12829 PyObject *resultobj = 0;
12830 wxFSFile *arg1 = (wxFSFile *) 0 ;
12831 wxInputStream *result = 0 ;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 PyObject *swig_obj[1] ;
12835
12836 if (!args) SWIG_fail;
12837 swig_obj[0] = args;
12838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12839 if (!SWIG_IsOK(res1)) {
12840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12841 }
12842 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 result = (wxInputStream *)(arg1)->GetStream();
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 wxPyInputStream * _ptr = NULL;
12851
12852 if (result) {
12853 _ptr = new wxPyInputStream(result);
12854 }
12855 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12856 }
12857 return resultobj;
12858 fail:
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12864 PyObject *resultobj = 0;
12865 wxFSFile *arg1 = (wxFSFile *) 0 ;
12866 void *argp1 = 0 ;
12867 int res1 = 0 ;
12868 PyObject *swig_obj[1] ;
12869
12870 if (!args) SWIG_fail;
12871 swig_obj[0] = args;
12872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12873 if (!SWIG_IsOK(res1)) {
12874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12875 }
12876 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 (arg1)->DetachStream();
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 resultobj = SWIG_Py_Void();
12884 return resultobj;
12885 fail:
12886 return NULL;
12887 }
12888
12889
12890 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12891 PyObject *resultobj = 0;
12892 wxFSFile *arg1 = (wxFSFile *) 0 ;
12893 wxString *result = 0 ;
12894 void *argp1 = 0 ;
12895 int res1 = 0 ;
12896 PyObject *swig_obj[1] ;
12897
12898 if (!args) SWIG_fail;
12899 swig_obj[0] = args;
12900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12901 if (!SWIG_IsOK(res1)) {
12902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12903 }
12904 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 {
12908 wxString const &_result_ref = (arg1)->GetMimeType();
12909 result = (wxString *) &_result_ref;
12910 }
12911 wxPyEndAllowThreads(__tstate);
12912 if (PyErr_Occurred()) SWIG_fail;
12913 }
12914 {
12915 #if wxUSE_UNICODE
12916 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12917 #else
12918 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12919 #endif
12920 }
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *resultobj = 0;
12929 wxFSFile *arg1 = (wxFSFile *) 0 ;
12930 wxString *result = 0 ;
12931 void *argp1 = 0 ;
12932 int res1 = 0 ;
12933 PyObject *swig_obj[1] ;
12934
12935 if (!args) SWIG_fail;
12936 swig_obj[0] = args;
12937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12938 if (!SWIG_IsOK(res1)) {
12939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12940 }
12941 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12942 {
12943 PyThreadState* __tstate = wxPyBeginAllowThreads();
12944 {
12945 wxString const &_result_ref = (arg1)->GetLocation();
12946 result = (wxString *) &_result_ref;
12947 }
12948 wxPyEndAllowThreads(__tstate);
12949 if (PyErr_Occurred()) SWIG_fail;
12950 }
12951 {
12952 #if wxUSE_UNICODE
12953 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12954 #else
12955 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12956 #endif
12957 }
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12965 PyObject *resultobj = 0;
12966 wxFSFile *arg1 = (wxFSFile *) 0 ;
12967 wxString *result = 0 ;
12968 void *argp1 = 0 ;
12969 int res1 = 0 ;
12970 PyObject *swig_obj[1] ;
12971
12972 if (!args) SWIG_fail;
12973 swig_obj[0] = args;
12974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12975 if (!SWIG_IsOK(res1)) {
12976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12977 }
12978 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12979 {
12980 PyThreadState* __tstate = wxPyBeginAllowThreads();
12981 {
12982 wxString const &_result_ref = (arg1)->GetAnchor();
12983 result = (wxString *) &_result_ref;
12984 }
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 {
12989 #if wxUSE_UNICODE
12990 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12991 #else
12992 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12993 #endif
12994 }
12995 return resultobj;
12996 fail:
12997 return NULL;
12998 }
12999
13000
13001 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13002 PyObject *resultobj = 0;
13003 wxFSFile *arg1 = (wxFSFile *) 0 ;
13004 wxDateTime result;
13005 void *argp1 = 0 ;
13006 int res1 = 0 ;
13007 PyObject *swig_obj[1] ;
13008
13009 if (!args) SWIG_fail;
13010 swig_obj[0] = args;
13011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
13012 if (!SWIG_IsOK(res1)) {
13013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
13014 }
13015 arg1 = reinterpret_cast< wxFSFile * >(argp1);
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = (arg1)->GetModificationTime();
13019 wxPyEndAllowThreads(__tstate);
13020 if (PyErr_Occurred()) SWIG_fail;
13021 }
13022 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
13023 return resultobj;
13024 fail:
13025 return NULL;
13026 }
13027
13028
13029 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13030 PyObject *obj;
13031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13032 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
13033 return SWIG_Py_Void();
13034 }
13035
13036 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13037 return SWIG_Python_InitShadowInstance(args);
13038 }
13039
13040 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13041 PyObject *resultobj = 0;
13042 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13043 void *argp1 = 0 ;
13044 int res1 = 0 ;
13045 PyObject *swig_obj[1] ;
13046
13047 if (!args) SWIG_fail;
13048 swig_obj[0] = args;
13049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13050 if (!SWIG_IsOK(res1)) {
13051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13052 }
13053 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13054 {
13055 PyThreadState* __tstate = wxPyBeginAllowThreads();
13056 delete arg1;
13057
13058 wxPyEndAllowThreads(__tstate);
13059 if (PyErr_Occurred()) SWIG_fail;
13060 }
13061 resultobj = SWIG_Py_Void();
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *obj;
13070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13071 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
13072 return SWIG_Py_Void();
13073 }
13074
13075 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076 PyObject *resultobj = 0;
13077 wxPyFileSystemHandler *result = 0 ;
13078
13079 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
13080 {
13081 PyThreadState* __tstate = wxPyBeginAllowThreads();
13082 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
13083 wxPyEndAllowThreads(__tstate);
13084 if (PyErr_Occurred()) SWIG_fail;
13085 }
13086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
13087 return resultobj;
13088 fail:
13089 return NULL;
13090 }
13091
13092
13093 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13094 PyObject *resultobj = 0;
13095 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13096 PyObject *arg2 = (PyObject *) 0 ;
13097 PyObject *arg3 = (PyObject *) 0 ;
13098 void *argp1 = 0 ;
13099 int res1 = 0 ;
13100 PyObject * obj0 = 0 ;
13101 PyObject * obj1 = 0 ;
13102 PyObject * obj2 = 0 ;
13103 char * kwnames[] = {
13104 (char *) "self",(char *) "self",(char *) "_class", NULL
13105 };
13106
13107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13109 if (!SWIG_IsOK(res1)) {
13110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13111 }
13112 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13113 arg2 = obj1;
13114 arg3 = obj2;
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 (arg1)->_setCallbackInfo(arg2,arg3);
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 resultobj = SWIG_Py_Void();
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13131 wxString *arg2 = 0 ;
13132 bool result;
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:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13144 if (!SWIG_IsOK(res1)) {
13145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13146 }
13147 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(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 = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 {
13160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
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_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj = 0;
13178 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13179 wxFileSystem *arg2 = 0 ;
13180 wxString *arg3 = 0 ;
13181 wxFSFile *result = 0 ;
13182 void *argp1 = 0 ;
13183 int res1 = 0 ;
13184 void *argp2 = 0 ;
13185 int res2 = 0 ;
13186 bool temp3 = false ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "self",(char *) "fs",(char *) "location", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13198 }
13199 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13200 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13201 if (!SWIG_IsOK(res2)) {
13202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13203 }
13204 if (!argp2) {
13205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13206 }
13207 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13208 {
13209 arg3 = wxString_in_helper(obj2);
13210 if (arg3 == NULL) SWIG_fail;
13211 temp3 = true;
13212 }
13213 {
13214 PyThreadState* __tstate = wxPyBeginAllowThreads();
13215 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13216 wxPyEndAllowThreads(__tstate);
13217 if (PyErr_Occurred()) SWIG_fail;
13218 }
13219 {
13220 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13221 }
13222 {
13223 if (temp3)
13224 delete arg3;
13225 }
13226 return resultobj;
13227 fail:
13228 {
13229 if (temp3)
13230 delete arg3;
13231 }
13232 return NULL;
13233 }
13234
13235
13236 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13237 PyObject *resultobj = 0;
13238 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13239 wxString *arg2 = 0 ;
13240 int arg3 = (int) 0 ;
13241 wxString result;
13242 void *argp1 = 0 ;
13243 int res1 = 0 ;
13244 bool temp2 = false ;
13245 int val3 ;
13246 int ecode3 = 0 ;
13247 PyObject * obj0 = 0 ;
13248 PyObject * obj1 = 0 ;
13249 PyObject * obj2 = 0 ;
13250 char * kwnames[] = {
13251 (char *) "self",(char *) "spec",(char *) "flags", NULL
13252 };
13253
13254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13256 if (!SWIG_IsOK(res1)) {
13257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13258 }
13259 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13260 {
13261 arg2 = wxString_in_helper(obj1);
13262 if (arg2 == NULL) SWIG_fail;
13263 temp2 = true;
13264 }
13265 if (obj2) {
13266 ecode3 = SWIG_AsVal_int(obj2, &val3);
13267 if (!SWIG_IsOK(ecode3)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13269 }
13270 arg3 = static_cast< int >(val3);
13271 }
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13275 wxPyEndAllowThreads(__tstate);
13276 if (PyErr_Occurred()) SWIG_fail;
13277 }
13278 {
13279 #if wxUSE_UNICODE
13280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13281 #else
13282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13283 #endif
13284 }
13285 {
13286 if (temp2)
13287 delete arg2;
13288 }
13289 return resultobj;
13290 fail:
13291 {
13292 if (temp2)
13293 delete arg2;
13294 }
13295 return NULL;
13296 }
13297
13298
13299 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13300 PyObject *resultobj = 0;
13301 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13302 wxString result;
13303 void *argp1 = 0 ;
13304 int res1 = 0 ;
13305 PyObject *swig_obj[1] ;
13306
13307 if (!args) SWIG_fail;
13308 swig_obj[0] = args;
13309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13310 if (!SWIG_IsOK(res1)) {
13311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13312 }
13313 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 result = (arg1)->FindNext();
13317 wxPyEndAllowThreads(__tstate);
13318 if (PyErr_Occurred()) SWIG_fail;
13319 }
13320 {
13321 #if wxUSE_UNICODE
13322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13323 #else
13324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13325 #endif
13326 }
13327 return resultobj;
13328 fail:
13329 return NULL;
13330 }
13331
13332
13333 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13334 PyObject *resultobj = 0;
13335 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13336 wxString *arg2 = 0 ;
13337 wxString result;
13338 void *argp1 = 0 ;
13339 int res1 = 0 ;
13340 bool temp2 = false ;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "self",(char *) "location", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
13348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13349 if (!SWIG_IsOK(res1)) {
13350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13351 }
13352 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13353 {
13354 arg2 = wxString_in_helper(obj1);
13355 if (arg2 == NULL) SWIG_fail;
13356 temp2 = true;
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (arg1)->GetProtocol((wxString const &)*arg2);
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 {
13365 #if wxUSE_UNICODE
13366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13367 #else
13368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13369 #endif
13370 }
13371 {
13372 if (temp2)
13373 delete arg2;
13374 }
13375 return resultobj;
13376 fail:
13377 {
13378 if (temp2)
13379 delete arg2;
13380 }
13381 return NULL;
13382 }
13383
13384
13385 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj = 0;
13387 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13388 wxString *arg2 = 0 ;
13389 wxString result;
13390 void *argp1 = 0 ;
13391 int res1 = 0 ;
13392 bool temp2 = false ;
13393 PyObject * obj0 = 0 ;
13394 PyObject * obj1 = 0 ;
13395 char * kwnames[] = {
13396 (char *) "self",(char *) "location", NULL
13397 };
13398
13399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13401 if (!SWIG_IsOK(res1)) {
13402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13403 }
13404 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13405 {
13406 arg2 = wxString_in_helper(obj1);
13407 if (arg2 == NULL) SWIG_fail;
13408 temp2 = true;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 #if wxUSE_UNICODE
13418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13419 #else
13420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13421 #endif
13422 }
13423 {
13424 if (temp2)
13425 delete arg2;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp2)
13431 delete arg2;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj = 0;
13439 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13440 wxString *arg2 = 0 ;
13441 wxString result;
13442 void *argp1 = 0 ;
13443 int res1 = 0 ;
13444 bool temp2 = false ;
13445 PyObject * obj0 = 0 ;
13446 PyObject * obj1 = 0 ;
13447 char * kwnames[] = {
13448 (char *) "self",(char *) "location", NULL
13449 };
13450
13451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
13452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13453 if (!SWIG_IsOK(res1)) {
13454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13455 }
13456 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13457 {
13458 arg2 = wxString_in_helper(obj1);
13459 if (arg2 == NULL) SWIG_fail;
13460 temp2 = true;
13461 }
13462 {
13463 PyThreadState* __tstate = wxPyBeginAllowThreads();
13464 result = (arg1)->GetAnchor((wxString const &)*arg2);
13465 wxPyEndAllowThreads(__tstate);
13466 if (PyErr_Occurred()) SWIG_fail;
13467 }
13468 {
13469 #if wxUSE_UNICODE
13470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13471 #else
13472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13473 #endif
13474 }
13475 {
13476 if (temp2)
13477 delete arg2;
13478 }
13479 return resultobj;
13480 fail:
13481 {
13482 if (temp2)
13483 delete arg2;
13484 }
13485 return NULL;
13486 }
13487
13488
13489 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13490 PyObject *resultobj = 0;
13491 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13492 wxString *arg2 = 0 ;
13493 wxString result;
13494 void *argp1 = 0 ;
13495 int res1 = 0 ;
13496 bool temp2 = false ;
13497 PyObject * obj0 = 0 ;
13498 PyObject * obj1 = 0 ;
13499 char * kwnames[] = {
13500 (char *) "self",(char *) "location", NULL
13501 };
13502
13503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13505 if (!SWIG_IsOK(res1)) {
13506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13507 }
13508 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13509 {
13510 arg2 = wxString_in_helper(obj1);
13511 if (arg2 == NULL) SWIG_fail;
13512 temp2 = true;
13513 }
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 result = (arg1)->GetRightLocation((wxString const &)*arg2);
13517 wxPyEndAllowThreads(__tstate);
13518 if (PyErr_Occurred()) SWIG_fail;
13519 }
13520 {
13521 #if wxUSE_UNICODE
13522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13523 #else
13524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13525 #endif
13526 }
13527 {
13528 if (temp2)
13529 delete arg2;
13530 }
13531 return resultobj;
13532 fail:
13533 {
13534 if (temp2)
13535 delete arg2;
13536 }
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13544 wxString *arg2 = 0 ;
13545 wxString result;
13546 void *argp1 = 0 ;
13547 int res1 = 0 ;
13548 bool temp2 = false ;
13549 PyObject * obj0 = 0 ;
13550 PyObject * obj1 = 0 ;
13551 char * kwnames[] = {
13552 (char *) "self",(char *) "location", NULL
13553 };
13554
13555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13557 if (!SWIG_IsOK(res1)) {
13558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13559 }
13560 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13561 {
13562 arg2 = wxString_in_helper(obj1);
13563 if (arg2 == NULL) SWIG_fail;
13564 temp2 = true;
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
13573 #if wxUSE_UNICODE
13574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13575 #else
13576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13577 #endif
13578 }
13579 {
13580 if (temp2)
13581 delete arg2;
13582 }
13583 return resultobj;
13584 fail:
13585 {
13586 if (temp2)
13587 delete arg2;
13588 }
13589 return NULL;
13590 }
13591
13592
13593 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594 PyObject *obj;
13595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13596 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13597 return SWIG_Py_Void();
13598 }
13599
13600 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13601 return SWIG_Python_InitShadowInstance(args);
13602 }
13603
13604 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13605 PyObject *resultobj = 0;
13606 wxFileSystem *result = 0 ;
13607
13608 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 result = (wxFileSystem *)new wxFileSystem();
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13623 PyObject *resultobj = 0;
13624 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13634 }
13635 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 delete arg1;
13639
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_Py_Void();
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj = 0;
13652 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13653 wxString *arg2 = 0 ;
13654 bool arg3 = (bool) false ;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 bool temp2 = false ;
13658 bool val3 ;
13659 int ecode3 = 0 ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 char * kwnames[] = {
13664 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13665 };
13666
13667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13671 }
13672 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13673 {
13674 arg2 = wxString_in_helper(obj1);
13675 if (arg2 == NULL) SWIG_fail;
13676 temp2 = true;
13677 }
13678 if (obj2) {
13679 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13680 if (!SWIG_IsOK(ecode3)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13682 }
13683 arg3 = static_cast< bool >(val3);
13684 }
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 resultobj = SWIG_Py_Void();
13692 {
13693 if (temp2)
13694 delete arg2;
13695 }
13696 return resultobj;
13697 fail:
13698 {
13699 if (temp2)
13700 delete arg2;
13701 }
13702 return NULL;
13703 }
13704
13705
13706 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13707 PyObject *resultobj = 0;
13708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13709 wxString result;
13710 void *argp1 = 0 ;
13711 int res1 = 0 ;
13712 PyObject *swig_obj[1] ;
13713
13714 if (!args) SWIG_fail;
13715 swig_obj[0] = args;
13716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13717 if (!SWIG_IsOK(res1)) {
13718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13719 }
13720 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13721 {
13722 PyThreadState* __tstate = wxPyBeginAllowThreads();
13723 result = (arg1)->GetPath();
13724 wxPyEndAllowThreads(__tstate);
13725 if (PyErr_Occurred()) SWIG_fail;
13726 }
13727 {
13728 #if wxUSE_UNICODE
13729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13730 #else
13731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13732 #endif
13733 }
13734 return resultobj;
13735 fail:
13736 return NULL;
13737 }
13738
13739
13740 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj = 0;
13742 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13743 wxString *arg2 = 0 ;
13744 wxFSFile *result = 0 ;
13745 void *argp1 = 0 ;
13746 int res1 = 0 ;
13747 bool temp2 = false ;
13748 PyObject * obj0 = 0 ;
13749 PyObject * obj1 = 0 ;
13750 char * kwnames[] = {
13751 (char *) "self",(char *) "location", NULL
13752 };
13753
13754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13756 if (!SWIG_IsOK(res1)) {
13757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13758 }
13759 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13760 {
13761 arg2 = wxString_in_helper(obj1);
13762 if (arg2 == NULL) SWIG_fail;
13763 temp2 = true;
13764 }
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 {
13772 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13773 }
13774 {
13775 if (temp2)
13776 delete arg2;
13777 }
13778 return resultobj;
13779 fail:
13780 {
13781 if (temp2)
13782 delete arg2;
13783 }
13784 return NULL;
13785 }
13786
13787
13788 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13789 PyObject *resultobj = 0;
13790 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13791 wxString *arg2 = 0 ;
13792 int arg3 = (int) 0 ;
13793 wxString result;
13794 void *argp1 = 0 ;
13795 int res1 = 0 ;
13796 bool temp2 = false ;
13797 int val3 ;
13798 int ecode3 = 0 ;
13799 PyObject * obj0 = 0 ;
13800 PyObject * obj1 = 0 ;
13801 PyObject * obj2 = 0 ;
13802 char * kwnames[] = {
13803 (char *) "self",(char *) "spec",(char *) "flags", NULL
13804 };
13805
13806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13808 if (!SWIG_IsOK(res1)) {
13809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13810 }
13811 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13812 {
13813 arg2 = wxString_in_helper(obj1);
13814 if (arg2 == NULL) SWIG_fail;
13815 temp2 = true;
13816 }
13817 if (obj2) {
13818 ecode3 = SWIG_AsVal_int(obj2, &val3);
13819 if (!SWIG_IsOK(ecode3)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13821 }
13822 arg3 = static_cast< int >(val3);
13823 }
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 {
13831 #if wxUSE_UNICODE
13832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13833 #else
13834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13835 #endif
13836 }
13837 {
13838 if (temp2)
13839 delete arg2;
13840 }
13841 return resultobj;
13842 fail:
13843 {
13844 if (temp2)
13845 delete arg2;
13846 }
13847 return NULL;
13848 }
13849
13850
13851 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13852 PyObject *resultobj = 0;
13853 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13854 wxString result;
13855 void *argp1 = 0 ;
13856 int res1 = 0 ;
13857 PyObject *swig_obj[1] ;
13858
13859 if (!args) SWIG_fail;
13860 swig_obj[0] = args;
13861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13862 if (!SWIG_IsOK(res1)) {
13863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13864 }
13865 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13866 {
13867 PyThreadState* __tstate = wxPyBeginAllowThreads();
13868 result = (arg1)->FindNext();
13869 wxPyEndAllowThreads(__tstate);
13870 if (PyErr_Occurred()) SWIG_fail;
13871 }
13872 {
13873 #if wxUSE_UNICODE
13874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13875 #else
13876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13877 #endif
13878 }
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13888 int res1 = 0 ;
13889 PyObject * obj0 = 0 ;
13890 char * kwnames[] = {
13891 (char *) "handler", NULL
13892 };
13893
13894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13895 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13896 if (!SWIG_IsOK(res1)) {
13897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13898 }
13899 {
13900 PyThreadState* __tstate = wxPyBeginAllowThreads();
13901 wxFileSystem::AddHandler(arg1);
13902 wxPyEndAllowThreads(__tstate);
13903 if (PyErr_Occurred()) SWIG_fail;
13904 }
13905 resultobj = SWIG_Py_Void();
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj = 0;
13914 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13915 wxFileSystemHandler *result = 0 ;
13916 void *argp1 = 0 ;
13917 int res1 = 0 ;
13918 PyObject * obj0 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "handler", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13925 if (!SWIG_IsOK(res1)) {
13926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13927 }
13928 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13929 {
13930 PyThreadState* __tstate = wxPyBeginAllowThreads();
13931 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13932 wxPyEndAllowThreads(__tstate);
13933 if (PyErr_Occurred()) SWIG_fail;
13934 }
13935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13943 PyObject *resultobj = 0;
13944
13945 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13946 {
13947 PyThreadState* __tstate = wxPyBeginAllowThreads();
13948 wxFileSystem::CleanUpHandlers();
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13960 PyObject *resultobj = 0;
13961 wxString *arg1 = 0 ;
13962 wxString result;
13963 bool temp1 = false ;
13964 PyObject * obj0 = 0 ;
13965 char * kwnames[] = {
13966 (char *) "filename", NULL
13967 };
13968
13969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13970 {
13971 arg1 = wxString_in_helper(obj0);
13972 if (arg1 == NULL) SWIG_fail;
13973 temp1 = true;
13974 }
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 {
13982 #if wxUSE_UNICODE
13983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13984 #else
13985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13986 #endif
13987 }
13988 {
13989 if (temp1)
13990 delete arg1;
13991 }
13992 return resultobj;
13993 fail:
13994 {
13995 if (temp1)
13996 delete arg1;
13997 }
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14003 PyObject *resultobj = 0;
14004 wxString *arg1 = 0 ;
14005 wxString result;
14006 bool temp1 = false ;
14007 PyObject * obj0 = 0 ;
14008 char * kwnames[] = {
14009 (char *) "url", NULL
14010 };
14011
14012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
14013 {
14014 arg1 = wxString_in_helper(obj0);
14015 if (arg1 == NULL) SWIG_fail;
14016 temp1 = true;
14017 }
14018 {
14019 PyThreadState* __tstate = wxPyBeginAllowThreads();
14020 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 #if wxUSE_UNICODE
14026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14027 #else
14028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14029 #endif
14030 }
14031 {
14032 if (temp1)
14033 delete arg1;
14034 }
14035 return resultobj;
14036 fail:
14037 {
14038 if (temp1)
14039 delete arg1;
14040 }
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14046 PyObject *obj;
14047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14048 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
14049 return SWIG_Py_Void();
14050 }
14051
14052 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14053 return SWIG_Python_InitShadowInstance(args);
14054 }
14055
14056 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14057 PyObject *resultobj = 0;
14058 wxInternetFSHandler *result = 0 ;
14059
14060 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
14061 {
14062 PyThreadState* __tstate = wxPyBeginAllowThreads();
14063 result = (wxInternetFSHandler *)new wxInternetFSHandler();
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
14068 return resultobj;
14069 fail:
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14077 wxString *arg2 = 0 ;
14078 bool result;
14079 void *argp1 = 0 ;
14080 int res1 = 0 ;
14081 bool temp2 = false ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 char * kwnames[] = {
14085 (char *) "self",(char *) "location", NULL
14086 };
14087
14088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14090 if (!SWIG_IsOK(res1)) {
14091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14092 }
14093 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14094 {
14095 arg2 = wxString_in_helper(obj1);
14096 if (arg2 == NULL) SWIG_fail;
14097 temp2 = true;
14098 }
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 {
14106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14107 }
14108 {
14109 if (temp2)
14110 delete arg2;
14111 }
14112 return resultobj;
14113 fail:
14114 {
14115 if (temp2)
14116 delete arg2;
14117 }
14118 return NULL;
14119 }
14120
14121
14122 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14123 PyObject *resultobj = 0;
14124 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14125 wxFileSystem *arg2 = 0 ;
14126 wxString *arg3 = 0 ;
14127 wxFSFile *result = 0 ;
14128 void *argp1 = 0 ;
14129 int res1 = 0 ;
14130 void *argp2 = 0 ;
14131 int res2 = 0 ;
14132 bool temp3 = false ;
14133 PyObject * obj0 = 0 ;
14134 PyObject * obj1 = 0 ;
14135 PyObject * obj2 = 0 ;
14136 char * kwnames[] = {
14137 (char *) "self",(char *) "fs",(char *) "location", NULL
14138 };
14139
14140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14142 if (!SWIG_IsOK(res1)) {
14143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14144 }
14145 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14147 if (!SWIG_IsOK(res2)) {
14148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14149 }
14150 if (!argp2) {
14151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14152 }
14153 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14154 {
14155 arg3 = wxString_in_helper(obj2);
14156 if (arg3 == NULL) SWIG_fail;
14157 temp3 = true;
14158 }
14159 {
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 {
14166 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14167 }
14168 {
14169 if (temp3)
14170 delete arg3;
14171 }
14172 return resultobj;
14173 fail:
14174 {
14175 if (temp3)
14176 delete arg3;
14177 }
14178 return NULL;
14179 }
14180
14181
14182 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 PyObject *obj;
14184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14185 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
14186 return SWIG_Py_Void();
14187 }
14188
14189 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14190 return SWIG_Python_InitShadowInstance(args);
14191 }
14192
14193 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14194 PyObject *resultobj = 0;
14195 wxZipFSHandler *result = 0 ;
14196
14197 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
14198 {
14199 PyThreadState* __tstate = wxPyBeginAllowThreads();
14200 result = (wxZipFSHandler *)new wxZipFSHandler();
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj = 0;
14213 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14214 wxString *arg2 = 0 ;
14215 bool result;
14216 void *argp1 = 0 ;
14217 int res1 = 0 ;
14218 bool temp2 = false ;
14219 PyObject * obj0 = 0 ;
14220 PyObject * obj1 = 0 ;
14221 char * kwnames[] = {
14222 (char *) "self",(char *) "location", NULL
14223 };
14224
14225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14227 if (!SWIG_IsOK(res1)) {
14228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14229 }
14230 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14231 {
14232 arg2 = wxString_in_helper(obj1);
14233 if (arg2 == NULL) SWIG_fail;
14234 temp2 = true;
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 {
14243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14244 }
14245 {
14246 if (temp2)
14247 delete arg2;
14248 }
14249 return resultobj;
14250 fail:
14251 {
14252 if (temp2)
14253 delete arg2;
14254 }
14255 return NULL;
14256 }
14257
14258
14259 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj = 0;
14261 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14262 wxFileSystem *arg2 = 0 ;
14263 wxString *arg3 = 0 ;
14264 wxFSFile *result = 0 ;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 void *argp2 = 0 ;
14268 int res2 = 0 ;
14269 bool temp3 = false ;
14270 PyObject * obj0 = 0 ;
14271 PyObject * obj1 = 0 ;
14272 PyObject * obj2 = 0 ;
14273 char * kwnames[] = {
14274 (char *) "self",(char *) "fs",(char *) "location", NULL
14275 };
14276
14277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14279 if (!SWIG_IsOK(res1)) {
14280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14281 }
14282 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14284 if (!SWIG_IsOK(res2)) {
14285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14286 }
14287 if (!argp2) {
14288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14289 }
14290 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14291 {
14292 arg3 = wxString_in_helper(obj2);
14293 if (arg3 == NULL) SWIG_fail;
14294 temp3 = true;
14295 }
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14299 wxPyEndAllowThreads(__tstate);
14300 if (PyErr_Occurred()) SWIG_fail;
14301 }
14302 {
14303 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14304 }
14305 {
14306 if (temp3)
14307 delete arg3;
14308 }
14309 return resultobj;
14310 fail:
14311 {
14312 if (temp3)
14313 delete arg3;
14314 }
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14322 wxString *arg2 = 0 ;
14323 int arg3 = (int) 0 ;
14324 wxString result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 bool temp2 = false ;
14328 int val3 ;
14329 int ecode3 = 0 ;
14330 PyObject * obj0 = 0 ;
14331 PyObject * obj1 = 0 ;
14332 PyObject * obj2 = 0 ;
14333 char * kwnames[] = {
14334 (char *) "self",(char *) "spec",(char *) "flags", NULL
14335 };
14336
14337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14339 if (!SWIG_IsOK(res1)) {
14340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14341 }
14342 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14343 {
14344 arg2 = wxString_in_helper(obj1);
14345 if (arg2 == NULL) SWIG_fail;
14346 temp2 = true;
14347 }
14348 if (obj2) {
14349 ecode3 = SWIG_AsVal_int(obj2, &val3);
14350 if (!SWIG_IsOK(ecode3)) {
14351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14352 }
14353 arg3 = static_cast< int >(val3);
14354 }
14355 {
14356 PyThreadState* __tstate = wxPyBeginAllowThreads();
14357 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14358 wxPyEndAllowThreads(__tstate);
14359 if (PyErr_Occurred()) SWIG_fail;
14360 }
14361 {
14362 #if wxUSE_UNICODE
14363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14364 #else
14365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14366 #endif
14367 }
14368 {
14369 if (temp2)
14370 delete arg2;
14371 }
14372 return resultobj;
14373 fail:
14374 {
14375 if (temp2)
14376 delete arg2;
14377 }
14378 return NULL;
14379 }
14380
14381
14382 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14383 PyObject *resultobj = 0;
14384 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14385 wxString result;
14386 void *argp1 = 0 ;
14387 int res1 = 0 ;
14388 PyObject *swig_obj[1] ;
14389
14390 if (!args) SWIG_fail;
14391 swig_obj[0] = args;
14392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14393 if (!SWIG_IsOK(res1)) {
14394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14395 }
14396 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (arg1)->FindNext();
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 #if wxUSE_UNICODE
14405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14406 #else
14407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14408 #endif
14409 }
14410 return resultobj;
14411 fail:
14412 return NULL;
14413 }
14414
14415
14416 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14417 PyObject *obj;
14418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14419 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
14420 return SWIG_Py_Void();
14421 }
14422
14423 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14424 return SWIG_Python_InitShadowInstance(args);
14425 }
14426
14427 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14428 PyObject *resultobj = 0;
14429 wxString *arg1 = 0 ;
14430 wxImage *arg2 = 0 ;
14431 long arg3 ;
14432 bool temp1 = false ;
14433 void *argp2 = 0 ;
14434 int res2 = 0 ;
14435 long val3 ;
14436 int ecode3 = 0 ;
14437 PyObject * obj0 = 0 ;
14438 PyObject * obj1 = 0 ;
14439 PyObject * obj2 = 0 ;
14440 char * kwnames[] = {
14441 (char *) "filename",(char *) "image",(char *) "type", NULL
14442 };
14443
14444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14445 {
14446 arg1 = wxString_in_helper(obj0);
14447 if (arg1 == NULL) SWIG_fail;
14448 temp1 = true;
14449 }
14450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
14451 if (!SWIG_IsOK(res2)) {
14452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14453 }
14454 if (!argp2) {
14455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14456 }
14457 arg2 = reinterpret_cast< wxImage * >(argp2);
14458 ecode3 = SWIG_AsVal_long(obj2, &val3);
14459 if (!SWIG_IsOK(ecode3)) {
14460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
14461 }
14462 arg3 = static_cast< long >(val3);
14463 {
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 resultobj = SWIG_Py_Void();
14470 {
14471 if (temp1)
14472 delete arg1;
14473 }
14474 return resultobj;
14475 fail:
14476 {
14477 if (temp1)
14478 delete arg1;
14479 }
14480 return NULL;
14481 }
14482
14483
14484 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14485 PyObject *resultobj = 0;
14486 wxString *arg1 = 0 ;
14487 wxBitmap *arg2 = 0 ;
14488 long arg3 ;
14489 bool temp1 = false ;
14490 void *argp2 = 0 ;
14491 int res2 = 0 ;
14492 long val3 ;
14493 int ecode3 = 0 ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 PyObject * obj2 = 0 ;
14497 char * kwnames[] = {
14498 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
14499 };
14500
14501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14502 {
14503 arg1 = wxString_in_helper(obj0);
14504 if (arg1 == NULL) SWIG_fail;
14505 temp1 = true;
14506 }
14507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
14508 if (!SWIG_IsOK(res2)) {
14509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14510 }
14511 if (!argp2) {
14512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14513 }
14514 arg2 = reinterpret_cast< wxBitmap * >(argp2);
14515 ecode3 = SWIG_AsVal_long(obj2, &val3);
14516 if (!SWIG_IsOK(ecode3)) {
14517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
14518 }
14519 arg3 = static_cast< long >(val3);
14520 {
14521 PyThreadState* __tstate = wxPyBeginAllowThreads();
14522 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14523 wxPyEndAllowThreads(__tstate);
14524 if (PyErr_Occurred()) SWIG_fail;
14525 }
14526 resultobj = SWIG_Py_Void();
14527 {
14528 if (temp1)
14529 delete arg1;
14530 }
14531 return resultobj;
14532 fail:
14533 {
14534 if (temp1)
14535 delete arg1;
14536 }
14537 return NULL;
14538 }
14539
14540
14541 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14542 PyObject *resultobj = 0;
14543 wxString *arg1 = 0 ;
14544 PyObject *arg2 = (PyObject *) 0 ;
14545 bool temp1 = false ;
14546 PyObject * obj0 = 0 ;
14547 PyObject * obj1 = 0 ;
14548 char * kwnames[] = {
14549 (char *) "filename",(char *) "data", NULL
14550 };
14551
14552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14553 {
14554 arg1 = wxString_in_helper(obj0);
14555 if (arg1 == NULL) SWIG_fail;
14556 temp1 = true;
14557 }
14558 arg2 = obj1;
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 resultobj = SWIG_Py_Void();
14566 {
14567 if (temp1)
14568 delete arg1;
14569 }
14570 return resultobj;
14571 fail:
14572 {
14573 if (temp1)
14574 delete arg1;
14575 }
14576 return NULL;
14577 }
14578
14579
14580 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14581 PyObject *resultobj = 0;
14582 wxMemoryFSHandler *result = 0 ;
14583
14584 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14588 wxPyEndAllowThreads(__tstate);
14589 if (PyErr_Occurred()) SWIG_fail;
14590 }
14591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14599 PyObject *resultobj = 0;
14600 wxString *arg1 = 0 ;
14601 bool temp1 = false ;
14602 PyObject * obj0 = 0 ;
14603 char * kwnames[] = {
14604 (char *) "filename", NULL
14605 };
14606
14607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14608 {
14609 arg1 = wxString_in_helper(obj0);
14610 if (arg1 == NULL) SWIG_fail;
14611 temp1 = true;
14612 }
14613 {
14614 PyThreadState* __tstate = wxPyBeginAllowThreads();
14615 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14616 wxPyEndAllowThreads(__tstate);
14617 if (PyErr_Occurred()) SWIG_fail;
14618 }
14619 resultobj = SWIG_Py_Void();
14620 {
14621 if (temp1)
14622 delete arg1;
14623 }
14624 return resultobj;
14625 fail:
14626 {
14627 if (temp1)
14628 delete arg1;
14629 }
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14635 PyObject *resultobj = 0;
14636 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14637 wxString *arg2 = 0 ;
14638 bool result;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 bool temp2 = false ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 char * kwnames[] = {
14645 (char *) "self",(char *) "location", NULL
14646 };
14647
14648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14650 if (!SWIG_IsOK(res1)) {
14651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14652 }
14653 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14654 {
14655 arg2 = wxString_in_helper(obj1);
14656 if (arg2 == NULL) SWIG_fail;
14657 temp2 = true;
14658 }
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14667 }
14668 {
14669 if (temp2)
14670 delete arg2;
14671 }
14672 return resultobj;
14673 fail:
14674 {
14675 if (temp2)
14676 delete arg2;
14677 }
14678 return NULL;
14679 }
14680
14681
14682 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14683 PyObject *resultobj = 0;
14684 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14685 wxFileSystem *arg2 = 0 ;
14686 wxString *arg3 = 0 ;
14687 wxFSFile *result = 0 ;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 void *argp2 = 0 ;
14691 int res2 = 0 ;
14692 bool temp3 = false ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "self",(char *) "fs",(char *) "location", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14702 if (!SWIG_IsOK(res1)) {
14703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14704 }
14705 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14707 if (!SWIG_IsOK(res2)) {
14708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14709 }
14710 if (!argp2) {
14711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14712 }
14713 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14714 {
14715 arg3 = wxString_in_helper(obj2);
14716 if (arg3 == NULL) SWIG_fail;
14717 temp3 = true;
14718 }
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 {
14726 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14727 }
14728 {
14729 if (temp3)
14730 delete arg3;
14731 }
14732 return resultobj;
14733 fail:
14734 {
14735 if (temp3)
14736 delete arg3;
14737 }
14738 return NULL;
14739 }
14740
14741
14742 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj = 0;
14744 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14745 wxString *arg2 = 0 ;
14746 int arg3 = (int) 0 ;
14747 wxString result;
14748 void *argp1 = 0 ;
14749 int res1 = 0 ;
14750 bool temp2 = false ;
14751 int val3 ;
14752 int ecode3 = 0 ;
14753 PyObject * obj0 = 0 ;
14754 PyObject * obj1 = 0 ;
14755 PyObject * obj2 = 0 ;
14756 char * kwnames[] = {
14757 (char *) "self",(char *) "spec",(char *) "flags", NULL
14758 };
14759
14760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14762 if (!SWIG_IsOK(res1)) {
14763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14764 }
14765 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14766 {
14767 arg2 = wxString_in_helper(obj1);
14768 if (arg2 == NULL) SWIG_fail;
14769 temp2 = true;
14770 }
14771 if (obj2) {
14772 ecode3 = SWIG_AsVal_int(obj2, &val3);
14773 if (!SWIG_IsOK(ecode3)) {
14774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14775 }
14776 arg3 = static_cast< int >(val3);
14777 }
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 {
14785 #if wxUSE_UNICODE
14786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14787 #else
14788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14789 #endif
14790 }
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 return resultobj;
14796 fail:
14797 {
14798 if (temp2)
14799 delete arg2;
14800 }
14801 return NULL;
14802 }
14803
14804
14805 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14806 PyObject *resultobj = 0;
14807 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14808 wxString result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 PyObject *swig_obj[1] ;
14812
14813 if (!args) SWIG_fail;
14814 swig_obj[0] = args;
14815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14816 if (!SWIG_IsOK(res1)) {
14817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14818 }
14819 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 result = (arg1)->FindNext();
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 #if wxUSE_UNICODE
14828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14829 #else
14830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14831 #endif
14832 }
14833 return resultobj;
14834 fail:
14835 return NULL;
14836 }
14837
14838
14839 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14840 PyObject *obj;
14841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14842 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14843 return SWIG_Py_Void();
14844 }
14845
14846 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14847 return SWIG_Python_InitShadowInstance(args);
14848 }
14849
14850 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14851 PyObject *resultobj = 0;
14852 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14853 wxString result;
14854 void *argp1 = 0 ;
14855 int res1 = 0 ;
14856 PyObject *swig_obj[1] ;
14857
14858 if (!args) SWIG_fail;
14859 swig_obj[0] = args;
14860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14861 if (!SWIG_IsOK(res1)) {
14862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14863 }
14864 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14865 {
14866 PyThreadState* __tstate = wxPyBeginAllowThreads();
14867 result = (arg1)->GetName();
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 {
14872 #if wxUSE_UNICODE
14873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14874 #else
14875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14876 #endif
14877 }
14878 return resultobj;
14879 fail:
14880 return NULL;
14881 }
14882
14883
14884 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14885 PyObject *resultobj = 0;
14886 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14887 wxString result;
14888 void *argp1 = 0 ;
14889 int res1 = 0 ;
14890 PyObject *swig_obj[1] ;
14891
14892 if (!args) SWIG_fail;
14893 swig_obj[0] = args;
14894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14899 {
14900 PyThreadState* __tstate = wxPyBeginAllowThreads();
14901 result = (arg1)->GetExtension();
14902 wxPyEndAllowThreads(__tstate);
14903 if (PyErr_Occurred()) SWIG_fail;
14904 }
14905 {
14906 #if wxUSE_UNICODE
14907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14908 #else
14909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14910 #endif
14911 }
14912 return resultobj;
14913 fail:
14914 return NULL;
14915 }
14916
14917
14918 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14919 PyObject *resultobj = 0;
14920 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14921 long result;
14922 void *argp1 = 0 ;
14923 int res1 = 0 ;
14924 PyObject *swig_obj[1] ;
14925
14926 if (!args) SWIG_fail;
14927 swig_obj[0] = args;
14928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14929 if (!SWIG_IsOK(res1)) {
14930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14931 }
14932 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (long)(arg1)->GetType();
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 resultobj = SWIG_From_long(static_cast< long >(result));
14940 return resultobj;
14941 fail:
14942 return NULL;
14943 }
14944
14945
14946 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14947 PyObject *resultobj = 0;
14948 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14949 wxString result;
14950 void *argp1 = 0 ;
14951 int res1 = 0 ;
14952 PyObject *swig_obj[1] ;
14953
14954 if (!args) SWIG_fail;
14955 swig_obj[0] = args;
14956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14959 }
14960 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (arg1)->GetMimeType();
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 {
14968 #if wxUSE_UNICODE
14969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14970 #else
14971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14972 #endif
14973 }
14974 return resultobj;
14975 fail:
14976 return NULL;
14977 }
14978
14979
14980 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14981 PyObject *resultobj = 0;
14982 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14983 wxString *arg2 = 0 ;
14984 bool result;
14985 void *argp1 = 0 ;
14986 int res1 = 0 ;
14987 bool temp2 = false ;
14988 PyObject * obj0 = 0 ;
14989 PyObject * obj1 = 0 ;
14990 char * kwnames[] = {
14991 (char *) "self",(char *) "name", NULL
14992 };
14993
14994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14998 }
14999 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15000 {
15001 arg2 = wxString_in_helper(obj1);
15002 if (arg2 == NULL) SWIG_fail;
15003 temp2 = true;
15004 }
15005 {
15006 PyThreadState* __tstate = wxPyBeginAllowThreads();
15007 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
15008 wxPyEndAllowThreads(__tstate);
15009 if (PyErr_Occurred()) SWIG_fail;
15010 }
15011 {
15012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15013 }
15014 {
15015 if (temp2)
15016 delete arg2;
15017 }
15018 return resultobj;
15019 fail:
15020 {
15021 if (temp2)
15022 delete arg2;
15023 }
15024 return NULL;
15025 }
15026
15027
15028 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15029 PyObject *resultobj = 0;
15030 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15031 wxInputStream *arg2 = 0 ;
15032 bool result;
15033 void *argp1 = 0 ;
15034 int res1 = 0 ;
15035 wxPyInputStream *temp2 ;
15036 bool created2 ;
15037 PyObject * obj0 = 0 ;
15038 PyObject * obj1 = 0 ;
15039 char * kwnames[] = {
15040 (char *) "self",(char *) "stream", NULL
15041 };
15042
15043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
15044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15045 if (!SWIG_IsOK(res1)) {
15046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15047 }
15048 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15049 {
15050 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15051 arg2 = temp2->m_wxis;
15052 created2 = false;
15053 } else {
15054 PyErr_Clear(); // clear the failure of the wxPyConvert above
15055 arg2 = wxPyCBInputStream_create(obj1, false);
15056 if (arg2 == NULL) {
15057 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15058 SWIG_fail;
15059 }
15060 created2 = true;
15061 }
15062 }
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (bool)(arg1)->CanRead(*arg2);
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 {
15070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15071 }
15072 {
15073 if (created2) delete arg2;
15074 }
15075 return resultobj;
15076 fail:
15077 {
15078 if (created2) delete arg2;
15079 }
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15085 PyObject *resultobj = 0;
15086 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15087 wxString *arg2 = 0 ;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 bool temp2 = false ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char * kwnames[] = {
15094 (char *) "self",(char *) "name", NULL
15095 };
15096
15097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
15098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15099 if (!SWIG_IsOK(res1)) {
15100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15101 }
15102 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15103 {
15104 arg2 = wxString_in_helper(obj1);
15105 if (arg2 == NULL) SWIG_fail;
15106 temp2 = true;
15107 }
15108 {
15109 PyThreadState* __tstate = wxPyBeginAllowThreads();
15110 (arg1)->SetName((wxString const &)*arg2);
15111 wxPyEndAllowThreads(__tstate);
15112 if (PyErr_Occurred()) SWIG_fail;
15113 }
15114 resultobj = SWIG_Py_Void();
15115 {
15116 if (temp2)
15117 delete arg2;
15118 }
15119 return resultobj;
15120 fail:
15121 {
15122 if (temp2)
15123 delete arg2;
15124 }
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15130 PyObject *resultobj = 0;
15131 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15132 wxString *arg2 = 0 ;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 bool temp2 = false ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 char * kwnames[] = {
15139 (char *) "self",(char *) "extension", NULL
15140 };
15141
15142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
15143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15144 if (!SWIG_IsOK(res1)) {
15145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15146 }
15147 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15148 {
15149 arg2 = wxString_in_helper(obj1);
15150 if (arg2 == NULL) SWIG_fail;
15151 temp2 = true;
15152 }
15153 {
15154 PyThreadState* __tstate = wxPyBeginAllowThreads();
15155 (arg1)->SetExtension((wxString const &)*arg2);
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 resultobj = SWIG_Py_Void();
15160 {
15161 if (temp2)
15162 delete arg2;
15163 }
15164 return resultobj;
15165 fail:
15166 {
15167 if (temp2)
15168 delete arg2;
15169 }
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj = 0;
15176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15177 long arg2 ;
15178 void *argp1 = 0 ;
15179 int res1 = 0 ;
15180 long val2 ;
15181 int ecode2 = 0 ;
15182 PyObject * obj0 = 0 ;
15183 PyObject * obj1 = 0 ;
15184 char * kwnames[] = {
15185 (char *) "self",(char *) "type", NULL
15186 };
15187
15188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
15189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15190 if (!SWIG_IsOK(res1)) {
15191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15192 }
15193 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15194 ecode2 = SWIG_AsVal_long(obj1, &val2);
15195 if (!SWIG_IsOK(ecode2)) {
15196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
15197 }
15198 arg2 = static_cast< long >(val2);
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 (arg1)->SetType(arg2);
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_Py_Void();
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15213 PyObject *resultobj = 0;
15214 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15215 wxString *arg2 = 0 ;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 bool temp2 = false ;
15219 PyObject * obj0 = 0 ;
15220 PyObject * obj1 = 0 ;
15221 char * kwnames[] = {
15222 (char *) "self",(char *) "mimetype", NULL
15223 };
15224
15225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
15226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15229 }
15230 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15231 {
15232 arg2 = wxString_in_helper(obj1);
15233 if (arg2 == NULL) SWIG_fail;
15234 temp2 = true;
15235 }
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 (arg1)->SetMimeType((wxString const &)*arg2);
15239 wxPyEndAllowThreads(__tstate);
15240 if (PyErr_Occurred()) SWIG_fail;
15241 }
15242 resultobj = SWIG_Py_Void();
15243 {
15244 if (temp2)
15245 delete arg2;
15246 }
15247 return resultobj;
15248 fail:
15249 {
15250 if (temp2)
15251 delete arg2;
15252 }
15253 return NULL;
15254 }
15255
15256
15257 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15258 PyObject *obj;
15259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15260 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
15261 return SWIG_Py_Void();
15262 }
15263
15264 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15265 PyObject *resultobj = 0;
15266 wxPyImageHandler *result = 0 ;
15267
15268 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
15269 {
15270 PyThreadState* __tstate = wxPyBeginAllowThreads();
15271 result = (wxPyImageHandler *)new wxPyImageHandler();
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15283 PyObject *resultobj = 0;
15284 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
15285 PyObject *arg2 = (PyObject *) 0 ;
15286 void *argp1 = 0 ;
15287 int res1 = 0 ;
15288 PyObject * obj0 = 0 ;
15289 PyObject * obj1 = 0 ;
15290 char * kwnames[] = {
15291 (char *) "self",(char *) "self", NULL
15292 };
15293
15294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
15295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
15296 if (!SWIG_IsOK(res1)) {
15297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
15298 }
15299 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
15300 arg2 = obj1;
15301 {
15302 PyThreadState* __tstate = wxPyBeginAllowThreads();
15303 (arg1)->_SetSelf(arg2);
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = SWIG_Py_Void();
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15315 PyObject *obj;
15316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
15318 return SWIG_Py_Void();
15319 }
15320
15321 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15322 return SWIG_Python_InitShadowInstance(args);
15323 }
15324
15325 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15326 PyObject *resultobj = 0;
15327 wxImageHistogram *result = 0 ;
15328
15329 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
15330 {
15331 PyThreadState* __tstate = wxPyBeginAllowThreads();
15332 result = (wxImageHistogram *)new wxImageHistogram();
15333 wxPyEndAllowThreads(__tstate);
15334 if (PyErr_Occurred()) SWIG_fail;
15335 }
15336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
15337 return resultobj;
15338 fail:
15339 return NULL;
15340 }
15341
15342
15343 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15344 PyObject *resultobj = 0;
15345 byte arg1 ;
15346 byte arg2 ;
15347 byte arg3 ;
15348 unsigned long result;
15349 unsigned char val1 ;
15350 int ecode1 = 0 ;
15351 unsigned char val2 ;
15352 int ecode2 = 0 ;
15353 unsigned char val3 ;
15354 int ecode3 = 0 ;
15355 PyObject * obj0 = 0 ;
15356 PyObject * obj1 = 0 ;
15357 PyObject * obj2 = 0 ;
15358 char * kwnames[] = {
15359 (char *) "r",(char *) "g",(char *) "b", NULL
15360 };
15361
15362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15363 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15364 if (!SWIG_IsOK(ecode1)) {
15365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
15366 }
15367 arg1 = static_cast< byte >(val1);
15368 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15369 if (!SWIG_IsOK(ecode2)) {
15370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
15371 }
15372 arg2 = static_cast< byte >(val2);
15373 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15374 if (!SWIG_IsOK(ecode3)) {
15375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
15376 }
15377 arg3 = static_cast< byte >(val3);
15378 {
15379 PyThreadState* __tstate = wxPyBeginAllowThreads();
15380 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
15381 wxPyEndAllowThreads(__tstate);
15382 if (PyErr_Occurred()) SWIG_fail;
15383 }
15384 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15385 return resultobj;
15386 fail:
15387 return NULL;
15388 }
15389
15390
15391 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15392 PyObject *resultobj = 0;
15393 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15394 byte *arg2 = (byte *) 0 ;
15395 byte *arg3 = (byte *) 0 ;
15396 byte *arg4 = (byte *) 0 ;
15397 byte arg5 = (byte) 1 ;
15398 byte arg6 = (byte) 0 ;
15399 byte arg7 = (byte) 0 ;
15400 bool result;
15401 void *argp1 = 0 ;
15402 int res1 = 0 ;
15403 byte temp2 ;
15404 int res2 = SWIG_TMPOBJ ;
15405 byte temp3 ;
15406 int res3 = SWIG_TMPOBJ ;
15407 byte temp4 ;
15408 int res4 = SWIG_TMPOBJ ;
15409 unsigned char val5 ;
15410 int ecode5 = 0 ;
15411 unsigned char val6 ;
15412 int ecode6 = 0 ;
15413 unsigned char val7 ;
15414 int ecode7 = 0 ;
15415 PyObject * obj0 = 0 ;
15416 PyObject * obj1 = 0 ;
15417 PyObject * obj2 = 0 ;
15418 PyObject * obj3 = 0 ;
15419 char * kwnames[] = {
15420 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
15421 };
15422
15423 arg2 = &temp2;
15424 arg3 = &temp3;
15425 arg4 = &temp4;
15426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
15430 }
15431 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15432 if (obj1) {
15433 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
15434 if (!SWIG_IsOK(ecode5)) {
15435 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
15436 }
15437 arg5 = static_cast< byte >(val5);
15438 }
15439 if (obj2) {
15440 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
15441 if (!SWIG_IsOK(ecode6)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
15443 }
15444 arg6 = static_cast< byte >(val6);
15445 }
15446 if (obj3) {
15447 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
15448 if (!SWIG_IsOK(ecode7)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
15450 }
15451 arg7 = static_cast< byte >(val7);
15452 }
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
15456 wxPyEndAllowThreads(__tstate);
15457 if (PyErr_Occurred()) SWIG_fail;
15458 }
15459 {
15460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15461 }
15462 if (SWIG_IsTmpObj(res2)) {
15463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15464 } else {
15465 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15467 }
15468 if (SWIG_IsTmpObj(res3)) {
15469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15470 } else {
15471 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15473 }
15474 if (SWIG_IsTmpObj(res4)) {
15475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15476 } else {
15477 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15479 }
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15489 unsigned long arg2 ;
15490 unsigned long result;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 unsigned long val2 ;
15494 int ecode2 = 0 ;
15495 PyObject * obj0 = 0 ;
15496 PyObject * obj1 = 0 ;
15497 char * kwnames[] = {
15498 (char *) "self",(char *) "key", NULL
15499 };
15500
15501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
15502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15503 if (!SWIG_IsOK(res1)) {
15504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15505 }
15506 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15507 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
15508 if (!SWIG_IsOK(ecode2)) {
15509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
15510 }
15511 arg2 = static_cast< unsigned long >(val2);
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15526 PyObject *resultobj = 0;
15527 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15528 byte arg2 ;
15529 byte arg3 ;
15530 byte arg4 ;
15531 unsigned long result;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 unsigned char val2 ;
15535 int ecode2 = 0 ;
15536 unsigned char val3 ;
15537 int ecode3 = 0 ;
15538 unsigned char val4 ;
15539 int ecode4 = 0 ;
15540 PyObject * obj0 = 0 ;
15541 PyObject * obj1 = 0 ;
15542 PyObject * obj2 = 0 ;
15543 PyObject * obj3 = 0 ;
15544 char * kwnames[] = {
15545 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15546 };
15547
15548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15552 }
15553 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15554 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15555 if (!SWIG_IsOK(ecode2)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15557 }
15558 arg2 = static_cast< byte >(val2);
15559 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15560 if (!SWIG_IsOK(ecode3)) {
15561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15562 }
15563 arg3 = static_cast< byte >(val3);
15564 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15565 if (!SWIG_IsOK(ecode4)) {
15566 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15567 }
15568 arg4 = static_cast< byte >(val4);
15569 {
15570 PyThreadState* __tstate = wxPyBeginAllowThreads();
15571 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15572 wxPyEndAllowThreads(__tstate);
15573 if (PyErr_Occurred()) SWIG_fail;
15574 }
15575 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15576 return resultobj;
15577 fail:
15578 return NULL;
15579 }
15580
15581
15582 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15583 PyObject *resultobj = 0;
15584 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15585 wxColour *arg2 = 0 ;
15586 unsigned long result;
15587 void *argp1 = 0 ;
15588 int res1 = 0 ;
15589 wxColour temp2 ;
15590 PyObject * obj0 = 0 ;
15591 PyObject * obj1 = 0 ;
15592 char * kwnames[] = {
15593 (char *) "self",(char *) "colour", NULL
15594 };
15595
15596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15598 if (!SWIG_IsOK(res1)) {
15599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15600 }
15601 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15602 {
15603 arg2 = &temp2;
15604 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15605 }
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15620 PyObject *obj;
15621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15622 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15623 return SWIG_Py_Void();
15624 }
15625
15626 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15627 return SWIG_Python_InitShadowInstance(args);
15628 }
15629
15630 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15631 PyObject *resultobj = 0;
15632 byte arg1 = (byte) 0 ;
15633 byte arg2 = (byte) 0 ;
15634 byte arg3 = (byte) 0 ;
15635 wxImage_RGBValue *result = 0 ;
15636 unsigned char val1 ;
15637 int ecode1 = 0 ;
15638 unsigned char val2 ;
15639 int ecode2 = 0 ;
15640 unsigned char val3 ;
15641 int ecode3 = 0 ;
15642 PyObject * obj0 = 0 ;
15643 PyObject * obj1 = 0 ;
15644 PyObject * obj2 = 0 ;
15645 char * kwnames[] = {
15646 (char *) "r",(char *) "g",(char *) "b", NULL
15647 };
15648
15649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15650 if (obj0) {
15651 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15652 if (!SWIG_IsOK(ecode1)) {
15653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15654 }
15655 arg1 = static_cast< byte >(val1);
15656 }
15657 if (obj1) {
15658 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15659 if (!SWIG_IsOK(ecode2)) {
15660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15661 }
15662 arg2 = static_cast< byte >(val2);
15663 }
15664 if (obj2) {
15665 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15666 if (!SWIG_IsOK(ecode3)) {
15667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15668 }
15669 arg3 = static_cast< byte >(val3);
15670 }
15671 {
15672 PyThreadState* __tstate = wxPyBeginAllowThreads();
15673 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15674 wxPyEndAllowThreads(__tstate);
15675 if (PyErr_Occurred()) SWIG_fail;
15676 }
15677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15678 return resultobj;
15679 fail:
15680 return NULL;
15681 }
15682
15683
15684 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15685 PyObject *resultobj = 0;
15686 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15687 byte arg2 ;
15688 void *argp1 = 0 ;
15689 int res1 = 0 ;
15690 unsigned char val2 ;
15691 int ecode2 = 0 ;
15692 PyObject *swig_obj[2] ;
15693
15694 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15696 if (!SWIG_IsOK(res1)) {
15697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15698 }
15699 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15700 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15701 if (!SWIG_IsOK(ecode2)) {
15702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15703 }
15704 arg2 = static_cast< byte >(val2);
15705 if (arg1) (arg1)->red = arg2;
15706
15707 resultobj = SWIG_Py_Void();
15708 return resultobj;
15709 fail:
15710 return NULL;
15711 }
15712
15713
15714 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15715 PyObject *resultobj = 0;
15716 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15717 byte result;
15718 void *argp1 = 0 ;
15719 int res1 = 0 ;
15720 PyObject *swig_obj[1] ;
15721
15722 if (!args) SWIG_fail;
15723 swig_obj[0] = args;
15724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15725 if (!SWIG_IsOK(res1)) {
15726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15727 }
15728 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15729 result = (byte) ((arg1)->red);
15730 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15740 byte arg2 ;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 unsigned char val2 ;
15744 int ecode2 = 0 ;
15745 PyObject *swig_obj[2] ;
15746
15747 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15751 }
15752 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15753 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15754 if (!SWIG_IsOK(ecode2)) {
15755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15756 }
15757 arg2 = static_cast< byte >(val2);
15758 if (arg1) (arg1)->green = arg2;
15759
15760 resultobj = SWIG_Py_Void();
15761 return resultobj;
15762 fail:
15763 return NULL;
15764 }
15765
15766
15767 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15768 PyObject *resultobj = 0;
15769 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15770 byte result;
15771 void *argp1 = 0 ;
15772 int res1 = 0 ;
15773 PyObject *swig_obj[1] ;
15774
15775 if (!args) SWIG_fail;
15776 swig_obj[0] = args;
15777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15778 if (!SWIG_IsOK(res1)) {
15779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15780 }
15781 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15782 result = (byte) ((arg1)->green);
15783 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15791 PyObject *resultobj = 0;
15792 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15793 byte arg2 ;
15794 void *argp1 = 0 ;
15795 int res1 = 0 ;
15796 unsigned char val2 ;
15797 int ecode2 = 0 ;
15798 PyObject *swig_obj[2] ;
15799
15800 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15802 if (!SWIG_IsOK(res1)) {
15803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15804 }
15805 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15806 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15807 if (!SWIG_IsOK(ecode2)) {
15808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15809 }
15810 arg2 = static_cast< byte >(val2);
15811 if (arg1) (arg1)->blue = arg2;
15812
15813 resultobj = SWIG_Py_Void();
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15821 PyObject *resultobj = 0;
15822 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15823 byte result;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 PyObject *swig_obj[1] ;
15827
15828 if (!args) SWIG_fail;
15829 swig_obj[0] = args;
15830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15835 result = (byte) ((arg1)->blue);
15836 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15844 PyObject *obj;
15845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15846 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15847 return SWIG_Py_Void();
15848 }
15849
15850 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15851 return SWIG_Python_InitShadowInstance(args);
15852 }
15853
15854 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15855 PyObject *resultobj = 0;
15856 double arg1 = (double) 0.0 ;
15857 double arg2 = (double) 0.0 ;
15858 double arg3 = (double) 0.0 ;
15859 wxImage_HSVValue *result = 0 ;
15860 double val1 ;
15861 int ecode1 = 0 ;
15862 double val2 ;
15863 int ecode2 = 0 ;
15864 double val3 ;
15865 int ecode3 = 0 ;
15866 PyObject * obj0 = 0 ;
15867 PyObject * obj1 = 0 ;
15868 PyObject * obj2 = 0 ;
15869 char * kwnames[] = {
15870 (char *) "h",(char *) "s",(char *) "v", NULL
15871 };
15872
15873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15874 if (obj0) {
15875 ecode1 = SWIG_AsVal_double(obj0, &val1);
15876 if (!SWIG_IsOK(ecode1)) {
15877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15878 }
15879 arg1 = static_cast< double >(val1);
15880 }
15881 if (obj1) {
15882 ecode2 = SWIG_AsVal_double(obj1, &val2);
15883 if (!SWIG_IsOK(ecode2)) {
15884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15885 }
15886 arg2 = static_cast< double >(val2);
15887 }
15888 if (obj2) {
15889 ecode3 = SWIG_AsVal_double(obj2, &val3);
15890 if (!SWIG_IsOK(ecode3)) {
15891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15892 }
15893 arg3 = static_cast< double >(val3);
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15909 PyObject *resultobj = 0;
15910 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15911 double arg2 ;
15912 void *argp1 = 0 ;
15913 int res1 = 0 ;
15914 double val2 ;
15915 int ecode2 = 0 ;
15916 PyObject *swig_obj[2] ;
15917
15918 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15920 if (!SWIG_IsOK(res1)) {
15921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15922 }
15923 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15924 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15925 if (!SWIG_IsOK(ecode2)) {
15926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15927 }
15928 arg2 = static_cast< double >(val2);
15929 if (arg1) (arg1)->hue = arg2;
15930
15931 resultobj = SWIG_Py_Void();
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15939 PyObject *resultobj = 0;
15940 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15941 double result;
15942 void *argp1 = 0 ;
15943 int res1 = 0 ;
15944 PyObject *swig_obj[1] ;
15945
15946 if (!args) SWIG_fail;
15947 swig_obj[0] = args;
15948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15949 if (!SWIG_IsOK(res1)) {
15950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15951 }
15952 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15953 result = (double) ((arg1)->hue);
15954 resultobj = SWIG_From_double(static_cast< double >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15964 double arg2 ;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 double val2 ;
15968 int ecode2 = 0 ;
15969 PyObject *swig_obj[2] ;
15970
15971 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15975 }
15976 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15977 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15978 if (!SWIG_IsOK(ecode2)) {
15979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15980 }
15981 arg2 = static_cast< double >(val2);
15982 if (arg1) (arg1)->saturation = arg2;
15983
15984 resultobj = SWIG_Py_Void();
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15992 PyObject *resultobj = 0;
15993 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15994 double result;
15995 void *argp1 = 0 ;
15996 int res1 = 0 ;
15997 PyObject *swig_obj[1] ;
15998
15999 if (!args) SWIG_fail;
16000 swig_obj[0] = args;
16001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16002 if (!SWIG_IsOK(res1)) {
16003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16004 }
16005 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16006 result = (double) ((arg1)->saturation);
16007 resultobj = SWIG_From_double(static_cast< double >(result));
16008 return resultobj;
16009 fail:
16010 return NULL;
16011 }
16012
16013
16014 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16015 PyObject *resultobj = 0;
16016 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16017 double arg2 ;
16018 void *argp1 = 0 ;
16019 int res1 = 0 ;
16020 double val2 ;
16021 int ecode2 = 0 ;
16022 PyObject *swig_obj[2] ;
16023
16024 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
16025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16026 if (!SWIG_IsOK(res1)) {
16027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16028 }
16029 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16030 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
16031 if (!SWIG_IsOK(ecode2)) {
16032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
16033 }
16034 arg2 = static_cast< double >(val2);
16035 if (arg1) (arg1)->value = arg2;
16036
16037 resultobj = SWIG_Py_Void();
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16045 PyObject *resultobj = 0;
16046 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16047 double result;
16048 void *argp1 = 0 ;
16049 int res1 = 0 ;
16050 PyObject *swig_obj[1] ;
16051
16052 if (!args) SWIG_fail;
16053 swig_obj[0] = args;
16054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16055 if (!SWIG_IsOK(res1)) {
16056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16057 }
16058 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16059 result = (double) ((arg1)->value);
16060 resultobj = SWIG_From_double(static_cast< double >(result));
16061 return resultobj;
16062 fail:
16063 return NULL;
16064 }
16065
16066
16067 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16068 PyObject *obj;
16069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16070 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
16071 return SWIG_Py_Void();
16072 }
16073
16074 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075 return SWIG_Python_InitShadowInstance(args);
16076 }
16077
16078 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16079 PyObject *resultobj = 0;
16080 wxString *arg1 = 0 ;
16081 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16082 int arg3 = (int) -1 ;
16083 wxImage *result = 0 ;
16084 bool temp1 = false ;
16085 long val2 ;
16086 int ecode2 = 0 ;
16087 int val3 ;
16088 int ecode3 = 0 ;
16089 PyObject * obj0 = 0 ;
16090 PyObject * obj1 = 0 ;
16091 PyObject * obj2 = 0 ;
16092 char * kwnames[] = {
16093 (char *) "name",(char *) "type",(char *) "index", NULL
16094 };
16095
16096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16097 {
16098 arg1 = wxString_in_helper(obj0);
16099 if (arg1 == NULL) SWIG_fail;
16100 temp1 = true;
16101 }
16102 if (obj1) {
16103 ecode2 = SWIG_AsVal_long(obj1, &val2);
16104 if (!SWIG_IsOK(ecode2)) {
16105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
16106 }
16107 arg2 = static_cast< long >(val2);
16108 }
16109 if (obj2) {
16110 ecode3 = SWIG_AsVal_int(obj2, &val3);
16111 if (!SWIG_IsOK(ecode3)) {
16112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
16113 }
16114 arg3 = static_cast< int >(val3);
16115 }
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
16123 {
16124 if (temp1)
16125 delete arg1;
16126 }
16127 return resultobj;
16128 fail:
16129 {
16130 if (temp1)
16131 delete arg1;
16132 }
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139 wxImage *arg1 = (wxImage *) 0 ;
16140 void *argp1 = 0 ;
16141 int res1 = 0 ;
16142 PyObject *swig_obj[1] ;
16143
16144 if (!args) SWIG_fail;
16145 swig_obj[0] = args;
16146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
16147 if (!SWIG_IsOK(res1)) {
16148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
16149 }
16150 arg1 = reinterpret_cast< wxImage * >(argp1);
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 delete arg1;
16154
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 resultobj = SWIG_Py_Void();
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj = 0;
16167 wxString *arg1 = 0 ;
16168 wxString *arg2 = 0 ;
16169 int arg3 = (int) -1 ;
16170 wxImage *result = 0 ;
16171 bool temp1 = false ;
16172 bool temp2 = false ;
16173 int val3 ;
16174 int ecode3 = 0 ;
16175 PyObject * obj0 = 0 ;
16176 PyObject * obj1 = 0 ;
16177 PyObject * obj2 = 0 ;
16178 char * kwnames[] = {
16179 (char *) "name",(char *) "mimetype",(char *) "index", NULL
16180 };
16181
16182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16183 {
16184 arg1 = wxString_in_helper(obj0);
16185 if (arg1 == NULL) SWIG_fail;
16186 temp1 = true;
16187 }
16188 {
16189 arg2 = wxString_in_helper(obj1);
16190 if (arg2 == NULL) SWIG_fail;
16191 temp2 = true;
16192 }
16193 if (obj2) {
16194 ecode3 = SWIG_AsVal_int(obj2, &val3);
16195 if (!SWIG_IsOK(ecode3)) {
16196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
16197 }
16198 arg3 = static_cast< int >(val3);
16199 }
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16207 {
16208 if (temp1)
16209 delete arg1;
16210 }
16211 {
16212 if (temp2)
16213 delete arg2;
16214 }
16215 return resultobj;
16216 fail:
16217 {
16218 if (temp1)
16219 delete arg1;
16220 }
16221 {
16222 if (temp2)
16223 delete arg2;
16224 }
16225 return NULL;
16226 }
16227
16228
16229 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj = 0;
16231 wxInputStream *arg1 = 0 ;
16232 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16233 int arg3 = (int) -1 ;
16234 wxImage *result = 0 ;
16235 wxPyInputStream *temp1 ;
16236 bool created1 ;
16237 long val2 ;
16238 int ecode2 = 0 ;
16239 int val3 ;
16240 int ecode3 = 0 ;
16241 PyObject * obj0 = 0 ;
16242 PyObject * obj1 = 0 ;
16243 PyObject * obj2 = 0 ;
16244 char * kwnames[] = {
16245 (char *) "stream",(char *) "type",(char *) "index", NULL
16246 };
16247
16248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16249 {
16250 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16251 arg1 = temp1->m_wxis;
16252 created1 = false;
16253 } else {
16254 PyErr_Clear(); // clear the failure of the wxPyConvert above
16255 arg1 = wxPyCBInputStream_create(obj0, false);
16256 if (arg1 == NULL) {
16257 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16258 SWIG_fail;
16259 }
16260 created1 = true;
16261 }
16262 }
16263 if (obj1) {
16264 ecode2 = SWIG_AsVal_long(obj1, &val2);
16265 if (!SWIG_IsOK(ecode2)) {
16266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
16267 }
16268 arg2 = static_cast< long >(val2);
16269 }
16270 if (obj2) {
16271 ecode3 = SWIG_AsVal_int(obj2, &val3);
16272 if (!SWIG_IsOK(ecode3)) {
16273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
16274 }
16275 arg3 = static_cast< int >(val3);
16276 }
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
16280 wxPyEndAllowThreads(__tstate);
16281 if (PyErr_Occurred()) SWIG_fail;
16282 }
16283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16284 {
16285 if (created1) delete arg1;
16286 }
16287 return resultobj;
16288 fail:
16289 {
16290 if (created1) delete arg1;
16291 }
16292 return NULL;
16293 }
16294
16295
16296 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16297 PyObject *resultobj = 0;
16298 wxInputStream *arg1 = 0 ;
16299 wxString *arg2 = 0 ;
16300 int arg3 = (int) -1 ;
16301 wxImage *result = 0 ;
16302 wxPyInputStream *temp1 ;
16303 bool created1 ;
16304 bool temp2 = false ;
16305 int val3 ;
16306 int ecode3 = 0 ;
16307 PyObject * obj0 = 0 ;
16308 PyObject * obj1 = 0 ;
16309 PyObject * obj2 = 0 ;
16310 char * kwnames[] = {
16311 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
16312 };
16313
16314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16315 {
16316 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16317 arg1 = temp1->m_wxis;
16318 created1 = false;
16319 } else {
16320 PyErr_Clear(); // clear the failure of the wxPyConvert above
16321 arg1 = wxPyCBInputStream_create(obj0, false);
16322 if (arg1 == NULL) {
16323 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16324 SWIG_fail;
16325 }
16326 created1 = true;
16327 }
16328 }
16329 {
16330 arg2 = wxString_in_helper(obj1);
16331 if (arg2 == NULL) SWIG_fail;
16332 temp2 = true;
16333 }
16334 if (obj2) {
16335 ecode3 = SWIG_AsVal_int(obj2, &val3);
16336 if (!SWIG_IsOK(ecode3)) {
16337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
16338 }
16339 arg3 = static_cast< int >(val3);
16340 }
16341 {
16342 PyThreadState* __tstate = wxPyBeginAllowThreads();
16343 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
16344 wxPyEndAllowThreads(__tstate);
16345 if (PyErr_Occurred()) SWIG_fail;
16346 }
16347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16348 {
16349 if (created1) delete arg1;
16350 }
16351 {
16352 if (temp2)
16353 delete arg2;
16354 }
16355 return resultobj;
16356 fail:
16357 {
16358 if (created1) delete arg1;
16359 }
16360 {
16361 if (temp2)
16362 delete arg2;
16363 }
16364 return NULL;
16365 }
16366
16367
16368 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16369 PyObject *resultobj = 0;
16370 int arg1 = (int) 0 ;
16371 int arg2 = (int) 0 ;
16372 bool arg3 = (bool) true ;
16373 wxImage *result = 0 ;
16374 int val1 ;
16375 int ecode1 = 0 ;
16376 int val2 ;
16377 int ecode2 = 0 ;
16378 bool val3 ;
16379 int ecode3 = 0 ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 PyObject * obj2 = 0 ;
16383 char * kwnames[] = {
16384 (char *) "width",(char *) "height",(char *) "clear", NULL
16385 };
16386
16387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16388 if (obj0) {
16389 ecode1 = SWIG_AsVal_int(obj0, &val1);
16390 if (!SWIG_IsOK(ecode1)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
16392 }
16393 arg1 = static_cast< int >(val1);
16394 }
16395 if (obj1) {
16396 ecode2 = SWIG_AsVal_int(obj1, &val2);
16397 if (!SWIG_IsOK(ecode2)) {
16398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
16399 }
16400 arg2 = static_cast< int >(val2);
16401 }
16402 if (obj2) {
16403 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16404 if (!SWIG_IsOK(ecode3)) {
16405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
16406 }
16407 arg3 = static_cast< bool >(val3);
16408 }
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16423 PyObject *resultobj = 0;
16424 wxBitmap *arg1 = 0 ;
16425 wxImage *result = 0 ;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 PyObject * obj0 = 0 ;
16429 char * kwnames[] = {
16430 (char *) "bitmap", NULL
16431 };
16432
16433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
16434 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
16435 if (!SWIG_IsOK(res1)) {
16436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16437 }
16438 if (!argp1) {
16439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16440 }
16441 arg1 = reinterpret_cast< wxBitmap * >(argp1);
16442 {
16443 if (!wxPyCheckForApp()) SWIG_fail;
16444 PyThreadState* __tstate = wxPyBeginAllowThreads();
16445 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj = 0;
16458 int arg1 ;
16459 int arg2 ;
16460 buffer arg3 ;
16461 int arg4 ;
16462 wxImage *result = 0 ;
16463 int val1 ;
16464 int ecode1 = 0 ;
16465 int val2 ;
16466 int ecode2 = 0 ;
16467 Py_ssize_t temp3 ;
16468 PyObject * obj0 = 0 ;
16469 PyObject * obj1 = 0 ;
16470 PyObject * obj2 = 0 ;
16471 char * kwnames[] = {
16472 (char *) "width",(char *) "height",(char *) "data", NULL
16473 };
16474
16475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16476 ecode1 = SWIG_AsVal_int(obj0, &val1);
16477 if (!SWIG_IsOK(ecode1)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
16479 }
16480 arg1 = static_cast< int >(val1);
16481 ecode2 = SWIG_AsVal_int(obj1, &val2);
16482 if (!SWIG_IsOK(ecode2)) {
16483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
16484 }
16485 arg2 = static_cast< int >(val2);
16486 {
16487 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16488 arg4 = (int)temp3;
16489 }
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = 0;
16505 int arg1 ;
16506 int arg2 ;
16507 buffer arg3 ;
16508 int arg4 ;
16509 buffer arg5 ;
16510 int arg6 ;
16511 wxImage *result = 0 ;
16512 int val1 ;
16513 int ecode1 = 0 ;
16514 int val2 ;
16515 int ecode2 = 0 ;
16516 Py_ssize_t temp3 ;
16517 Py_ssize_t temp5 ;
16518 PyObject * obj0 = 0 ;
16519 PyObject * obj1 = 0 ;
16520 PyObject * obj2 = 0 ;
16521 PyObject * obj3 = 0 ;
16522 char * kwnames[] = {
16523 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16524 };
16525
16526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16527 ecode1 = SWIG_AsVal_int(obj0, &val1);
16528 if (!SWIG_IsOK(ecode1)) {
16529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16530 }
16531 arg1 = static_cast< int >(val1);
16532 ecode2 = SWIG_AsVal_int(obj1, &val2);
16533 if (!SWIG_IsOK(ecode2)) {
16534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16535 }
16536 arg2 = static_cast< int >(val2);
16537 {
16538 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16539 arg4 = (int)temp3;
16540 }
16541 {
16542 if (obj3 != Py_None) {
16543 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16544 arg6 = (int)temp5;
16545 }
16546 }
16547 {
16548 PyThreadState* __tstate = wxPyBeginAllowThreads();
16549 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16550 wxPyEndAllowThreads(__tstate);
16551 if (PyErr_Occurred()) SWIG_fail;
16552 }
16553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16554 return resultobj;
16555 fail:
16556 return NULL;
16557 }
16558
16559
16560 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16561 PyObject *resultobj = 0;
16562 wxImage *arg1 = (wxImage *) 0 ;
16563 int arg2 ;
16564 int arg3 ;
16565 bool arg4 = (bool) true ;
16566 void *argp1 = 0 ;
16567 int res1 = 0 ;
16568 int val2 ;
16569 int ecode2 = 0 ;
16570 int val3 ;
16571 int ecode3 = 0 ;
16572 bool val4 ;
16573 int ecode4 = 0 ;
16574 PyObject * obj0 = 0 ;
16575 PyObject * obj1 = 0 ;
16576 PyObject * obj2 = 0 ;
16577 PyObject * obj3 = 0 ;
16578 char * kwnames[] = {
16579 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16580 };
16581
16582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16584 if (!SWIG_IsOK(res1)) {
16585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16586 }
16587 arg1 = reinterpret_cast< wxImage * >(argp1);
16588 ecode2 = SWIG_AsVal_int(obj1, &val2);
16589 if (!SWIG_IsOK(ecode2)) {
16590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16591 }
16592 arg2 = static_cast< int >(val2);
16593 ecode3 = SWIG_AsVal_int(obj2, &val3);
16594 if (!SWIG_IsOK(ecode3)) {
16595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16596 }
16597 arg3 = static_cast< int >(val3);
16598 if (obj3) {
16599 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16600 if (!SWIG_IsOK(ecode4)) {
16601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16602 }
16603 arg4 = static_cast< bool >(val4);
16604 }
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 (arg1)->Create(arg2,arg3,arg4);
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = SWIG_Py_Void();
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxImage *arg1 = (wxImage *) 0 ;
16621 void *argp1 = 0 ;
16622 int res1 = 0 ;
16623 PyObject *swig_obj[1] ;
16624
16625 if (!args) SWIG_fail;
16626 swig_obj[0] = args;
16627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16628 if (!SWIG_IsOK(res1)) {
16629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16630 }
16631 arg1 = reinterpret_cast< wxImage * >(argp1);
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 (arg1)->Destroy();
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_Py_Void();
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj = 0;
16647 wxImage *arg1 = (wxImage *) 0 ;
16648 int arg2 ;
16649 int arg3 ;
16650 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16651 SwigValueWrapper<wxImage > result;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 int val2 ;
16655 int ecode2 = 0 ;
16656 int val3 ;
16657 int ecode3 = 0 ;
16658 int val4 ;
16659 int ecode4 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 PyObject * obj2 = 0 ;
16663 PyObject * obj3 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16670 if (!SWIG_IsOK(res1)) {
16671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16672 }
16673 arg1 = reinterpret_cast< wxImage * >(argp1);
16674 ecode2 = SWIG_AsVal_int(obj1, &val2);
16675 if (!SWIG_IsOK(ecode2)) {
16676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16677 }
16678 arg2 = static_cast< int >(val2);
16679 ecode3 = SWIG_AsVal_int(obj2, &val3);
16680 if (!SWIG_IsOK(ecode3)) {
16681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16682 }
16683 arg3 = static_cast< int >(val3);
16684 if (obj3) {
16685 ecode4 = SWIG_AsVal_int(obj3, &val4);
16686 if (!SWIG_IsOK(ecode4)) {
16687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16688 }
16689 arg4 = static_cast< int >(val4);
16690 }
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 result = (arg1)->Scale(arg2,arg3,arg4);
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16705 PyObject *resultobj = 0;
16706 wxImage *arg1 = (wxImage *) 0 ;
16707 int arg2 ;
16708 int arg3 ;
16709 SwigValueWrapper<wxImage > result;
16710 void *argp1 = 0 ;
16711 int res1 = 0 ;
16712 int val2 ;
16713 int ecode2 = 0 ;
16714 int val3 ;
16715 int ecode3 = 0 ;
16716 PyObject * obj0 = 0 ;
16717 PyObject * obj1 = 0 ;
16718 PyObject * obj2 = 0 ;
16719 char * kwnames[] = {
16720 (char *) "self",(char *) "width",(char *) "height", NULL
16721 };
16722
16723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16725 if (!SWIG_IsOK(res1)) {
16726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16727 }
16728 arg1 = reinterpret_cast< wxImage * >(argp1);
16729 ecode2 = SWIG_AsVal_int(obj1, &val2);
16730 if (!SWIG_IsOK(ecode2)) {
16731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16732 }
16733 arg2 = static_cast< int >(val2);
16734 ecode3 = SWIG_AsVal_int(obj2, &val3);
16735 if (!SWIG_IsOK(ecode3)) {
16736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16737 }
16738 arg3 = static_cast< int >(val3);
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = 0;
16754 wxImage *arg1 = (wxImage *) 0 ;
16755 int arg2 ;
16756 int arg3 ;
16757 SwigValueWrapper<wxImage > result;
16758 void *argp1 = 0 ;
16759 int res1 = 0 ;
16760 int val2 ;
16761 int ecode2 = 0 ;
16762 int val3 ;
16763 int ecode3 = 0 ;
16764 PyObject * obj0 = 0 ;
16765 PyObject * obj1 = 0 ;
16766 PyObject * obj2 = 0 ;
16767 char * kwnames[] = {
16768 (char *) "self",(char *) "width",(char *) "height", NULL
16769 };
16770
16771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16775 }
16776 arg1 = reinterpret_cast< wxImage * >(argp1);
16777 ecode2 = SWIG_AsVal_int(obj1, &val2);
16778 if (!SWIG_IsOK(ecode2)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16780 }
16781 arg2 = static_cast< int >(val2);
16782 ecode3 = SWIG_AsVal_int(obj2, &val3);
16783 if (!SWIG_IsOK(ecode3)) {
16784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16785 }
16786 arg3 = static_cast< int >(val3);
16787 {
16788 PyThreadState* __tstate = wxPyBeginAllowThreads();
16789 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16790 wxPyEndAllowThreads(__tstate);
16791 if (PyErr_Occurred()) SWIG_fail;
16792 }
16793 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj = 0;
16802 wxImage *arg1 = (wxImage *) 0 ;
16803 int arg2 ;
16804 SwigValueWrapper<wxImage > result;
16805 void *argp1 = 0 ;
16806 int res1 = 0 ;
16807 int val2 ;
16808 int ecode2 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 PyObject * obj1 = 0 ;
16811 char * kwnames[] = {
16812 (char *) "self",(char *) "radius", NULL
16813 };
16814
16815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16817 if (!SWIG_IsOK(res1)) {
16818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16819 }
16820 arg1 = reinterpret_cast< wxImage * >(argp1);
16821 ecode2 = SWIG_AsVal_int(obj1, &val2);
16822 if (!SWIG_IsOK(ecode2)) {
16823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16824 }
16825 arg2 = static_cast< int >(val2);
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = (arg1)->Blur(arg2);
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16840 PyObject *resultobj = 0;
16841 wxImage *arg1 = (wxImage *) 0 ;
16842 int arg2 ;
16843 SwigValueWrapper<wxImage > result;
16844 void *argp1 = 0 ;
16845 int res1 = 0 ;
16846 int val2 ;
16847 int ecode2 = 0 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 char * kwnames[] = {
16851 (char *) "self",(char *) "radius", NULL
16852 };
16853
16854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16856 if (!SWIG_IsOK(res1)) {
16857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16858 }
16859 arg1 = reinterpret_cast< wxImage * >(argp1);
16860 ecode2 = SWIG_AsVal_int(obj1, &val2);
16861 if (!SWIG_IsOK(ecode2)) {
16862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16863 }
16864 arg2 = static_cast< int >(val2);
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = (arg1)->BlurHorizontal(arg2);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj = 0;
16880 wxImage *arg1 = (wxImage *) 0 ;
16881 int arg2 ;
16882 SwigValueWrapper<wxImage > result;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 int val2 ;
16886 int ecode2 = 0 ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 char * kwnames[] = {
16890 (char *) "self",(char *) "radius", NULL
16891 };
16892
16893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16897 }
16898 arg1 = reinterpret_cast< wxImage * >(argp1);
16899 ecode2 = SWIG_AsVal_int(obj1, &val2);
16900 if (!SWIG_IsOK(ecode2)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16902 }
16903 arg2 = static_cast< int >(val2);
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 result = (arg1)->BlurVertical(arg2);
16907 wxPyEndAllowThreads(__tstate);
16908 if (PyErr_Occurred()) SWIG_fail;
16909 }
16910 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16911 return resultobj;
16912 fail:
16913 return NULL;
16914 }
16915
16916
16917 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16918 PyObject *resultobj = 0;
16919 wxImage *arg1 = (wxImage *) 0 ;
16920 int arg2 ;
16921 int arg3 ;
16922 SwigValueWrapper<wxImage > result;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 int val2 ;
16926 int ecode2 = 0 ;
16927 int val3 ;
16928 int ecode3 = 0 ;
16929 PyObject * obj0 = 0 ;
16930 PyObject * obj1 = 0 ;
16931 PyObject * obj2 = 0 ;
16932 char * kwnames[] = {
16933 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16934 };
16935
16936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16938 if (!SWIG_IsOK(res1)) {
16939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16940 }
16941 arg1 = reinterpret_cast< wxImage * >(argp1);
16942 ecode2 = SWIG_AsVal_int(obj1, &val2);
16943 if (!SWIG_IsOK(ecode2)) {
16944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16945 }
16946 arg2 = static_cast< int >(val2);
16947 ecode3 = SWIG_AsVal_int(obj2, &val3);
16948 if (!SWIG_IsOK(ecode3)) {
16949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16950 }
16951 arg3 = static_cast< int >(val3);
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj = 0;
16967 wxImage *arg1 = (wxImage *) 0 ;
16968 int arg2 ;
16969 int arg3 ;
16970 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16971 wxImage *result = 0 ;
16972 void *argp1 = 0 ;
16973 int res1 = 0 ;
16974 int val2 ;
16975 int ecode2 = 0 ;
16976 int val3 ;
16977 int ecode3 = 0 ;
16978 int val4 ;
16979 int ecode4 = 0 ;
16980 PyObject * obj0 = 0 ;
16981 PyObject * obj1 = 0 ;
16982 PyObject * obj2 = 0 ;
16983 PyObject * obj3 = 0 ;
16984 char * kwnames[] = {
16985 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16986 };
16987
16988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16990 if (!SWIG_IsOK(res1)) {
16991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16992 }
16993 arg1 = reinterpret_cast< wxImage * >(argp1);
16994 ecode2 = SWIG_AsVal_int(obj1, &val2);
16995 if (!SWIG_IsOK(ecode2)) {
16996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16997 }
16998 arg2 = static_cast< int >(val2);
16999 ecode3 = SWIG_AsVal_int(obj2, &val3);
17000 if (!SWIG_IsOK(ecode3)) {
17001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
17002 }
17003 arg3 = static_cast< int >(val3);
17004 if (obj3) {
17005 ecode4 = SWIG_AsVal_int(obj3, &val4);
17006 if (!SWIG_IsOK(ecode4)) {
17007 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
17008 }
17009 arg4 = static_cast< int >(val4);
17010 }
17011 {
17012 PyThreadState* __tstate = wxPyBeginAllowThreads();
17013 {
17014 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
17015 result = (wxImage *) &_result_ref;
17016 }
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxImage *arg1 = (wxImage *) 0 ;
17030 wxSize *arg2 = 0 ;
17031 wxPoint *arg3 = 0 ;
17032 int arg4 = (int) -1 ;
17033 int arg5 = (int) -1 ;
17034 int arg6 = (int) -1 ;
17035 wxImage *result = 0 ;
17036 void *argp1 = 0 ;
17037 int res1 = 0 ;
17038 wxSize temp2 ;
17039 wxPoint temp3 ;
17040 int val4 ;
17041 int ecode4 = 0 ;
17042 int val5 ;
17043 int ecode5 = 0 ;
17044 int val6 ;
17045 int ecode6 = 0 ;
17046 PyObject * obj0 = 0 ;
17047 PyObject * obj1 = 0 ;
17048 PyObject * obj2 = 0 ;
17049 PyObject * obj3 = 0 ;
17050 PyObject * obj4 = 0 ;
17051 PyObject * obj5 = 0 ;
17052 char * kwnames[] = {
17053 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17054 };
17055
17056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17058 if (!SWIG_IsOK(res1)) {
17059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
17060 }
17061 arg1 = reinterpret_cast< wxImage * >(argp1);
17062 {
17063 arg2 = &temp2;
17064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17065 }
17066 {
17067 arg3 = &temp3;
17068 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17069 }
17070 if (obj3) {
17071 ecode4 = SWIG_AsVal_int(obj3, &val4);
17072 if (!SWIG_IsOK(ecode4)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
17074 }
17075 arg4 = static_cast< int >(val4);
17076 }
17077 if (obj4) {
17078 ecode5 = SWIG_AsVal_int(obj4, &val5);
17079 if (!SWIG_IsOK(ecode5)) {
17080 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
17081 }
17082 arg5 = static_cast< int >(val5);
17083 }
17084 if (obj5) {
17085 ecode6 = SWIG_AsVal_int(obj5, &val6);
17086 if (!SWIG_IsOK(ecode6)) {
17087 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
17088 }
17089 arg6 = static_cast< int >(val6);
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 {
17094 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
17095 result = (wxImage *) &_result_ref;
17096 }
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj = 0;
17109 wxImage *arg1 = (wxImage *) 0 ;
17110 int arg2 ;
17111 int arg3 ;
17112 byte arg4 ;
17113 byte arg5 ;
17114 byte arg6 ;
17115 void *argp1 = 0 ;
17116 int res1 = 0 ;
17117 int val2 ;
17118 int ecode2 = 0 ;
17119 int val3 ;
17120 int ecode3 = 0 ;
17121 unsigned char val4 ;
17122 int ecode4 = 0 ;
17123 unsigned char val5 ;
17124 int ecode5 = 0 ;
17125 unsigned char val6 ;
17126 int ecode6 = 0 ;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 PyObject * obj2 = 0 ;
17130 PyObject * obj3 = 0 ;
17131 PyObject * obj4 = 0 ;
17132 PyObject * obj5 = 0 ;
17133 char * kwnames[] = {
17134 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
17135 };
17136
17137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17139 if (!SWIG_IsOK(res1)) {
17140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
17141 }
17142 arg1 = reinterpret_cast< wxImage * >(argp1);
17143 ecode2 = SWIG_AsVal_int(obj1, &val2);
17144 if (!SWIG_IsOK(ecode2)) {
17145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
17146 }
17147 arg2 = static_cast< int >(val2);
17148 ecode3 = SWIG_AsVal_int(obj2, &val3);
17149 if (!SWIG_IsOK(ecode3)) {
17150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
17151 }
17152 arg3 = static_cast< int >(val3);
17153 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17154 if (!SWIG_IsOK(ecode4)) {
17155 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
17156 }
17157 arg4 = static_cast< byte >(val4);
17158 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17159 if (!SWIG_IsOK(ecode5)) {
17160 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
17161 }
17162 arg5 = static_cast< byte >(val5);
17163 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
17164 if (!SWIG_IsOK(ecode6)) {
17165 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
17166 }
17167 arg6 = static_cast< byte >(val6);
17168 {
17169 PyThreadState* __tstate = wxPyBeginAllowThreads();
17170 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
17171 wxPyEndAllowThreads(__tstate);
17172 if (PyErr_Occurred()) SWIG_fail;
17173 }
17174 resultobj = SWIG_Py_Void();
17175 return resultobj;
17176 fail:
17177 return NULL;
17178 }
17179
17180
17181 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17182 PyObject *resultobj = 0;
17183 wxImage *arg1 = (wxImage *) 0 ;
17184 wxRect *arg2 = 0 ;
17185 byte arg3 ;
17186 byte arg4 ;
17187 byte arg5 ;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 wxRect temp2 ;
17191 unsigned char val3 ;
17192 int ecode3 = 0 ;
17193 unsigned char val4 ;
17194 int ecode4 = 0 ;
17195 unsigned char val5 ;
17196 int ecode5 = 0 ;
17197 PyObject * obj0 = 0 ;
17198 PyObject * obj1 = 0 ;
17199 PyObject * obj2 = 0 ;
17200 PyObject * obj3 = 0 ;
17201 PyObject * obj4 = 0 ;
17202 char * kwnames[] = {
17203 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
17204 };
17205
17206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17208 if (!SWIG_IsOK(res1)) {
17209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
17210 }
17211 arg1 = reinterpret_cast< wxImage * >(argp1);
17212 {
17213 arg2 = &temp2;
17214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17215 }
17216 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17217 if (!SWIG_IsOK(ecode3)) {
17218 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
17219 }
17220 arg3 = static_cast< byte >(val3);
17221 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17222 if (!SWIG_IsOK(ecode4)) {
17223 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
17224 }
17225 arg4 = static_cast< byte >(val4);
17226 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17227 if (!SWIG_IsOK(ecode5)) {
17228 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
17229 }
17230 arg5 = static_cast< byte >(val5);
17231 {
17232 PyThreadState* __tstate = wxPyBeginAllowThreads();
17233 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 resultobj = SWIG_Py_Void();
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17245 PyObject *resultobj = 0;
17246 wxImage *arg1 = (wxImage *) 0 ;
17247 int arg2 ;
17248 int arg3 ;
17249 byte result;
17250 void *argp1 = 0 ;
17251 int res1 = 0 ;
17252 int val2 ;
17253 int ecode2 = 0 ;
17254 int val3 ;
17255 int ecode3 = 0 ;
17256 PyObject * obj0 = 0 ;
17257 PyObject * obj1 = 0 ;
17258 PyObject * obj2 = 0 ;
17259 char * kwnames[] = {
17260 (char *) "self",(char *) "x",(char *) "y", NULL
17261 };
17262
17263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17265 if (!SWIG_IsOK(res1)) {
17266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
17267 }
17268 arg1 = reinterpret_cast< wxImage * >(argp1);
17269 ecode2 = SWIG_AsVal_int(obj1, &val2);
17270 if (!SWIG_IsOK(ecode2)) {
17271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
17272 }
17273 arg2 = static_cast< int >(val2);
17274 ecode3 = SWIG_AsVal_int(obj2, &val3);
17275 if (!SWIG_IsOK(ecode3)) {
17276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
17277 }
17278 arg3 = static_cast< int >(val3);
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (byte)(arg1)->GetRed(arg2,arg3);
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj = 0;
17294 wxImage *arg1 = (wxImage *) 0 ;
17295 int arg2 ;
17296 int arg3 ;
17297 byte result;
17298 void *argp1 = 0 ;
17299 int res1 = 0 ;
17300 int val2 ;
17301 int ecode2 = 0 ;
17302 int val3 ;
17303 int ecode3 = 0 ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 PyObject * obj2 = 0 ;
17307 char * kwnames[] = {
17308 (char *) "self",(char *) "x",(char *) "y", NULL
17309 };
17310
17311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17313 if (!SWIG_IsOK(res1)) {
17314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
17315 }
17316 arg1 = reinterpret_cast< wxImage * >(argp1);
17317 ecode2 = SWIG_AsVal_int(obj1, &val2);
17318 if (!SWIG_IsOK(ecode2)) {
17319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
17320 }
17321 arg2 = static_cast< int >(val2);
17322 ecode3 = SWIG_AsVal_int(obj2, &val3);
17323 if (!SWIG_IsOK(ecode3)) {
17324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
17325 }
17326 arg3 = static_cast< int >(val3);
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = (byte)(arg1)->GetGreen(arg2,arg3);
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17341 PyObject *resultobj = 0;
17342 wxImage *arg1 = (wxImage *) 0 ;
17343 int arg2 ;
17344 int arg3 ;
17345 byte result;
17346 void *argp1 = 0 ;
17347 int res1 = 0 ;
17348 int val2 ;
17349 int ecode2 = 0 ;
17350 int val3 ;
17351 int ecode3 = 0 ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 PyObject * obj2 = 0 ;
17355 char * kwnames[] = {
17356 (char *) "self",(char *) "x",(char *) "y", NULL
17357 };
17358
17359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17361 if (!SWIG_IsOK(res1)) {
17362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
17363 }
17364 arg1 = reinterpret_cast< wxImage * >(argp1);
17365 ecode2 = SWIG_AsVal_int(obj1, &val2);
17366 if (!SWIG_IsOK(ecode2)) {
17367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
17368 }
17369 arg2 = static_cast< int >(val2);
17370 ecode3 = SWIG_AsVal_int(obj2, &val3);
17371 if (!SWIG_IsOK(ecode3)) {
17372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
17373 }
17374 arg3 = static_cast< int >(val3);
17375 {
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = (byte)(arg1)->GetBlue(arg2,arg3);
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj = 0;
17390 wxImage *arg1 = (wxImage *) 0 ;
17391 int arg2 ;
17392 int arg3 ;
17393 byte arg4 ;
17394 void *argp1 = 0 ;
17395 int res1 = 0 ;
17396 int val2 ;
17397 int ecode2 = 0 ;
17398 int val3 ;
17399 int ecode3 = 0 ;
17400 unsigned char val4 ;
17401 int ecode4 = 0 ;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 PyObject * obj2 = 0 ;
17405 PyObject * obj3 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17412 if (!SWIG_IsOK(res1)) {
17413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17414 }
17415 arg1 = reinterpret_cast< wxImage * >(argp1);
17416 ecode2 = SWIG_AsVal_int(obj1, &val2);
17417 if (!SWIG_IsOK(ecode2)) {
17418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
17419 }
17420 arg2 = static_cast< int >(val2);
17421 ecode3 = SWIG_AsVal_int(obj2, &val3);
17422 if (!SWIG_IsOK(ecode3)) {
17423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
17424 }
17425 arg3 = static_cast< int >(val3);
17426 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17427 if (!SWIG_IsOK(ecode4)) {
17428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
17429 }
17430 arg4 = static_cast< byte >(val4);
17431 {
17432 PyThreadState* __tstate = wxPyBeginAllowThreads();
17433 (arg1)->SetAlpha(arg2,arg3,arg4);
17434 wxPyEndAllowThreads(__tstate);
17435 if (PyErr_Occurred()) SWIG_fail;
17436 }
17437 resultobj = SWIG_Py_Void();
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj = 0;
17446 wxImage *arg1 = (wxImage *) 0 ;
17447 int arg2 ;
17448 int arg3 ;
17449 byte result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 int val2 ;
17453 int ecode2 = 0 ;
17454 int val3 ;
17455 int ecode3 = 0 ;
17456 PyObject * obj0 = 0 ;
17457 PyObject * obj1 = 0 ;
17458 PyObject * obj2 = 0 ;
17459 char * kwnames[] = {
17460 (char *) "self",(char *) "x",(char *) "y", NULL
17461 };
17462
17463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17465 if (!SWIG_IsOK(res1)) {
17466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17467 }
17468 arg1 = reinterpret_cast< wxImage * >(argp1);
17469 ecode2 = SWIG_AsVal_int(obj1, &val2);
17470 if (!SWIG_IsOK(ecode2)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
17472 }
17473 arg2 = static_cast< int >(val2);
17474 ecode3 = SWIG_AsVal_int(obj2, &val3);
17475 if (!SWIG_IsOK(ecode3)) {
17476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
17477 }
17478 arg3 = static_cast< int >(val3);
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (byte)(arg1)->GetAlpha(arg2,arg3);
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 PyObject *resultobj = 0;
17494 wxImage *arg1 = (wxImage *) 0 ;
17495 bool result;
17496 void *argp1 = 0 ;
17497 int res1 = 0 ;
17498 PyObject *swig_obj[1] ;
17499
17500 if (!args) SWIG_fail;
17501 swig_obj[0] = args;
17502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17503 if (!SWIG_IsOK(res1)) {
17504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17505 }
17506 arg1 = reinterpret_cast< wxImage * >(argp1);
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (bool)(arg1)->HasAlpha();
17510 wxPyEndAllowThreads(__tstate);
17511 if (PyErr_Occurred()) SWIG_fail;
17512 }
17513 {
17514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17515 }
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17523 PyObject *resultobj = 0;
17524 wxImage *arg1 = (wxImage *) 0 ;
17525 void *argp1 = 0 ;
17526 int res1 = 0 ;
17527 PyObject *swig_obj[1] ;
17528
17529 if (!args) SWIG_fail;
17530 swig_obj[0] = args;
17531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17532 if (!SWIG_IsOK(res1)) {
17533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17534 }
17535 arg1 = reinterpret_cast< wxImage * >(argp1);
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 (arg1)->InitAlpha();
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 resultobj = SWIG_Py_Void();
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj = 0;
17551 wxImage *arg1 = (wxImage *) 0 ;
17552 int arg2 ;
17553 int arg3 ;
17554 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17555 bool result;
17556 void *argp1 = 0 ;
17557 int res1 = 0 ;
17558 int val2 ;
17559 int ecode2 = 0 ;
17560 int val3 ;
17561 int ecode3 = 0 ;
17562 unsigned char val4 ;
17563 int ecode4 = 0 ;
17564 PyObject * obj0 = 0 ;
17565 PyObject * obj1 = 0 ;
17566 PyObject * obj2 = 0 ;
17567 PyObject * obj3 = 0 ;
17568 char * kwnames[] = {
17569 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17570 };
17571
17572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17576 }
17577 arg1 = reinterpret_cast< wxImage * >(argp1);
17578 ecode2 = SWIG_AsVal_int(obj1, &val2);
17579 if (!SWIG_IsOK(ecode2)) {
17580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17581 }
17582 arg2 = static_cast< int >(val2);
17583 ecode3 = SWIG_AsVal_int(obj2, &val3);
17584 if (!SWIG_IsOK(ecode3)) {
17585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17586 }
17587 arg3 = static_cast< int >(val3);
17588 if (obj3) {
17589 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17590 if (!SWIG_IsOK(ecode4)) {
17591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17592 }
17593 arg4 = static_cast< byte >(val4);
17594 }
17595 {
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj = 0;
17612 wxImage *arg1 = (wxImage *) 0 ;
17613 byte *arg2 = (byte *) 0 ;
17614 byte *arg3 = (byte *) 0 ;
17615 byte *arg4 = (byte *) 0 ;
17616 byte arg5 = (byte) 0 ;
17617 byte arg6 = (byte) 0 ;
17618 byte arg7 = (byte) 0 ;
17619 bool result;
17620 void *argp1 = 0 ;
17621 int res1 = 0 ;
17622 byte temp2 ;
17623 int res2 = SWIG_TMPOBJ ;
17624 byte temp3 ;
17625 int res3 = SWIG_TMPOBJ ;
17626 byte temp4 ;
17627 int res4 = SWIG_TMPOBJ ;
17628 unsigned char val5 ;
17629 int ecode5 = 0 ;
17630 unsigned char val6 ;
17631 int ecode6 = 0 ;
17632 unsigned char val7 ;
17633 int ecode7 = 0 ;
17634 PyObject * obj0 = 0 ;
17635 PyObject * obj1 = 0 ;
17636 PyObject * obj2 = 0 ;
17637 PyObject * obj3 = 0 ;
17638 char * kwnames[] = {
17639 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17640 };
17641
17642 arg2 = &temp2;
17643 arg3 = &temp3;
17644 arg4 = &temp4;
17645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17647 if (!SWIG_IsOK(res1)) {
17648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17649 }
17650 arg1 = reinterpret_cast< wxImage * >(argp1);
17651 if (obj1) {
17652 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17653 if (!SWIG_IsOK(ecode5)) {
17654 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17655 }
17656 arg5 = static_cast< byte >(val5);
17657 }
17658 if (obj2) {
17659 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17660 if (!SWIG_IsOK(ecode6)) {
17661 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17662 }
17663 arg6 = static_cast< byte >(val6);
17664 }
17665 if (obj3) {
17666 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17667 if (!SWIG_IsOK(ecode7)) {
17668 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17669 }
17670 arg7 = static_cast< byte >(val7);
17671 }
17672 {
17673 PyThreadState* __tstate = wxPyBeginAllowThreads();
17674 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17675 wxPyEndAllowThreads(__tstate);
17676 if (PyErr_Occurred()) SWIG_fail;
17677 }
17678 {
17679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17680 }
17681 if (SWIG_IsTmpObj(res2)) {
17682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17683 } else {
17684 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17686 }
17687 if (SWIG_IsTmpObj(res3)) {
17688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17689 } else {
17690 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17692 }
17693 if (SWIG_IsTmpObj(res4)) {
17694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17695 } else {
17696 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = 0;
17707 wxImage *arg1 = (wxImage *) 0 ;
17708 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17709 bool result;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 unsigned char val2 ;
17713 int ecode2 = 0 ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "self",(char *) "threshold", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17722 if (!SWIG_IsOK(res1)) {
17723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17724 }
17725 arg1 = reinterpret_cast< wxImage * >(argp1);
17726 if (obj1) {
17727 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17728 if (!SWIG_IsOK(ecode2)) {
17729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17730 }
17731 arg2 = static_cast< byte >(val2);
17732 }
17733 {
17734 PyThreadState* __tstate = wxPyBeginAllowThreads();
17735 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 {
17740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17741 }
17742 return resultobj;
17743 fail:
17744 return NULL;
17745 }
17746
17747
17748 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = 0;
17750 wxImage *arg1 = (wxImage *) 0 ;
17751 byte arg2 ;
17752 byte arg3 ;
17753 byte arg4 ;
17754 bool result;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 unsigned char val2 ;
17758 int ecode2 = 0 ;
17759 unsigned char val3 ;
17760 int ecode3 = 0 ;
17761 unsigned char val4 ;
17762 int ecode4 = 0 ;
17763 PyObject * obj0 = 0 ;
17764 PyObject * obj1 = 0 ;
17765 PyObject * obj2 = 0 ;
17766 PyObject * obj3 = 0 ;
17767 char * kwnames[] = {
17768 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17769 };
17770
17771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17773 if (!SWIG_IsOK(res1)) {
17774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17775 }
17776 arg1 = reinterpret_cast< wxImage * >(argp1);
17777 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17778 if (!SWIG_IsOK(ecode2)) {
17779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17780 }
17781 arg2 = static_cast< byte >(val2);
17782 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17783 if (!SWIG_IsOK(ecode3)) {
17784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17785 }
17786 arg3 = static_cast< byte >(val3);
17787 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17788 if (!SWIG_IsOK(ecode4)) {
17789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17790 }
17791 arg4 = static_cast< byte >(val4);
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17795 wxPyEndAllowThreads(__tstate);
17796 if (PyErr_Occurred()) SWIG_fail;
17797 }
17798 {
17799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17800 }
17801 return resultobj;
17802 fail:
17803 return NULL;
17804 }
17805
17806
17807 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17808 PyObject *resultobj = 0;
17809 wxImage *arg1 = (wxImage *) 0 ;
17810 wxImage *arg2 = 0 ;
17811 byte arg3 ;
17812 byte arg4 ;
17813 byte arg5 ;
17814 bool result;
17815 void *argp1 = 0 ;
17816 int res1 = 0 ;
17817 void *argp2 = 0 ;
17818 int res2 = 0 ;
17819 unsigned char val3 ;
17820 int ecode3 = 0 ;
17821 unsigned char val4 ;
17822 int ecode4 = 0 ;
17823 unsigned char val5 ;
17824 int ecode5 = 0 ;
17825 PyObject * obj0 = 0 ;
17826 PyObject * obj1 = 0 ;
17827 PyObject * obj2 = 0 ;
17828 PyObject * obj3 = 0 ;
17829 PyObject * obj4 = 0 ;
17830 char * kwnames[] = {
17831 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17832 };
17833
17834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17836 if (!SWIG_IsOK(res1)) {
17837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17838 }
17839 arg1 = reinterpret_cast< wxImage * >(argp1);
17840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17841 if (!SWIG_IsOK(res2)) {
17842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17843 }
17844 if (!argp2) {
17845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17846 }
17847 arg2 = reinterpret_cast< wxImage * >(argp2);
17848 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17849 if (!SWIG_IsOK(ecode3)) {
17850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17851 }
17852 arg3 = static_cast< byte >(val3);
17853 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17854 if (!SWIG_IsOK(ecode4)) {
17855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17856 }
17857 arg4 = static_cast< byte >(val4);
17858 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17859 if (!SWIG_IsOK(ecode5)) {
17860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17861 }
17862 arg5 = static_cast< byte >(val5);
17863 {
17864 PyThreadState* __tstate = wxPyBeginAllowThreads();
17865 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17866 wxPyEndAllowThreads(__tstate);
17867 if (PyErr_Occurred()) SWIG_fail;
17868 }
17869 {
17870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17871 }
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17879 PyObject *resultobj = 0;
17880 wxString *arg1 = 0 ;
17881 bool result;
17882 bool temp1 = false ;
17883 PyObject * obj0 = 0 ;
17884 char * kwnames[] = {
17885 (char *) "filename", NULL
17886 };
17887
17888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17889 {
17890 arg1 = wxString_in_helper(obj0);
17891 if (arg1 == NULL) SWIG_fail;
17892 temp1 = true;
17893 }
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17902 }
17903 {
17904 if (temp1)
17905 delete arg1;
17906 }
17907 return resultobj;
17908 fail:
17909 {
17910 if (temp1)
17911 delete arg1;
17912 }
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17918 PyObject *resultobj = 0;
17919 wxString *arg1 = 0 ;
17920 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17921 int result;
17922 bool temp1 = false ;
17923 long val2 ;
17924 int ecode2 = 0 ;
17925 PyObject * obj0 = 0 ;
17926 PyObject * obj1 = 0 ;
17927 char * kwnames[] = {
17928 (char *) "filename",(char *) "type", NULL
17929 };
17930
17931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17932 {
17933 arg1 = wxString_in_helper(obj0);
17934 if (arg1 == NULL) SWIG_fail;
17935 temp1 = true;
17936 }
17937 if (obj1) {
17938 ecode2 = SWIG_AsVal_long(obj1, &val2);
17939 if (!SWIG_IsOK(ecode2)) {
17940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17941 }
17942 arg2 = static_cast< long >(val2);
17943 }
17944 {
17945 PyThreadState* __tstate = wxPyBeginAllowThreads();
17946 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17947 wxPyEndAllowThreads(__tstate);
17948 if (PyErr_Occurred()) SWIG_fail;
17949 }
17950 resultobj = SWIG_From_int(static_cast< int >(result));
17951 {
17952 if (temp1)
17953 delete arg1;
17954 }
17955 return resultobj;
17956 fail:
17957 {
17958 if (temp1)
17959 delete arg1;
17960 }
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj = 0;
17967 wxImage *arg1 = (wxImage *) 0 ;
17968 wxString *arg2 = 0 ;
17969 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17970 int arg4 = (int) -1 ;
17971 bool result;
17972 void *argp1 = 0 ;
17973 int res1 = 0 ;
17974 bool temp2 = false ;
17975 long val3 ;
17976 int ecode3 = 0 ;
17977 int val4 ;
17978 int ecode4 = 0 ;
17979 PyObject * obj0 = 0 ;
17980 PyObject * obj1 = 0 ;
17981 PyObject * obj2 = 0 ;
17982 PyObject * obj3 = 0 ;
17983 char * kwnames[] = {
17984 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17985 };
17986
17987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17989 if (!SWIG_IsOK(res1)) {
17990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17991 }
17992 arg1 = reinterpret_cast< wxImage * >(argp1);
17993 {
17994 arg2 = wxString_in_helper(obj1);
17995 if (arg2 == NULL) SWIG_fail;
17996 temp2 = true;
17997 }
17998 if (obj2) {
17999 ecode3 = SWIG_AsVal_long(obj2, &val3);
18000 if (!SWIG_IsOK(ecode3)) {
18001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
18002 }
18003 arg3 = static_cast< long >(val3);
18004 }
18005 if (obj3) {
18006 ecode4 = SWIG_AsVal_int(obj3, &val4);
18007 if (!SWIG_IsOK(ecode4)) {
18008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
18009 }
18010 arg4 = static_cast< int >(val4);
18011 }
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
18015 wxPyEndAllowThreads(__tstate);
18016 if (PyErr_Occurred()) SWIG_fail;
18017 }
18018 {
18019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18020 }
18021 {
18022 if (temp2)
18023 delete arg2;
18024 }
18025 return resultobj;
18026 fail:
18027 {
18028 if (temp2)
18029 delete arg2;
18030 }
18031 return NULL;
18032 }
18033
18034
18035 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18036 PyObject *resultobj = 0;
18037 wxImage *arg1 = (wxImage *) 0 ;
18038 wxString *arg2 = 0 ;
18039 wxString *arg3 = 0 ;
18040 int arg4 = (int) -1 ;
18041 bool result;
18042 void *argp1 = 0 ;
18043 int res1 = 0 ;
18044 bool temp2 = false ;
18045 bool temp3 = false ;
18046 int val4 ;
18047 int ecode4 = 0 ;
18048 PyObject * obj0 = 0 ;
18049 PyObject * obj1 = 0 ;
18050 PyObject * obj2 = 0 ;
18051 PyObject * obj3 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18060 }
18061 arg1 = reinterpret_cast< wxImage * >(argp1);
18062 {
18063 arg2 = wxString_in_helper(obj1);
18064 if (arg2 == NULL) SWIG_fail;
18065 temp2 = true;
18066 }
18067 {
18068 arg3 = wxString_in_helper(obj2);
18069 if (arg3 == NULL) SWIG_fail;
18070 temp3 = true;
18071 }
18072 if (obj3) {
18073 ecode4 = SWIG_AsVal_int(obj3, &val4);
18074 if (!SWIG_IsOK(ecode4)) {
18075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
18076 }
18077 arg4 = static_cast< int >(val4);
18078 }
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18082 wxPyEndAllowThreads(__tstate);
18083 if (PyErr_Occurred()) SWIG_fail;
18084 }
18085 {
18086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18087 }
18088 {
18089 if (temp2)
18090 delete arg2;
18091 }
18092 {
18093 if (temp3)
18094 delete arg3;
18095 }
18096 return resultobj;
18097 fail:
18098 {
18099 if (temp2)
18100 delete arg2;
18101 }
18102 {
18103 if (temp3)
18104 delete arg3;
18105 }
18106 return NULL;
18107 }
18108
18109
18110 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18111 PyObject *resultobj = 0;
18112 wxImage *arg1 = (wxImage *) 0 ;
18113 wxString *arg2 = 0 ;
18114 int arg3 ;
18115 bool result;
18116 void *argp1 = 0 ;
18117 int res1 = 0 ;
18118 bool temp2 = false ;
18119 int val3 ;
18120 int ecode3 = 0 ;
18121 PyObject * obj0 = 0 ;
18122 PyObject * obj1 = 0 ;
18123 PyObject * obj2 = 0 ;
18124 char * kwnames[] = {
18125 (char *) "self",(char *) "name",(char *) "type", NULL
18126 };
18127
18128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18130 if (!SWIG_IsOK(res1)) {
18131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
18132 }
18133 arg1 = reinterpret_cast< wxImage * >(argp1);
18134 {
18135 arg2 = wxString_in_helper(obj1);
18136 if (arg2 == NULL) SWIG_fail;
18137 temp2 = true;
18138 }
18139 ecode3 = SWIG_AsVal_int(obj2, &val3);
18140 if (!SWIG_IsOK(ecode3)) {
18141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
18142 }
18143 arg3 = static_cast< int >(val3);
18144 {
18145 PyThreadState* __tstate = wxPyBeginAllowThreads();
18146 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18152 }
18153 {
18154 if (temp2)
18155 delete arg2;
18156 }
18157 return resultobj;
18158 fail:
18159 {
18160 if (temp2)
18161 delete arg2;
18162 }
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj = 0;
18169 wxImage *arg1 = (wxImage *) 0 ;
18170 wxString *arg2 = 0 ;
18171 wxString *arg3 = 0 ;
18172 bool result;
18173 void *argp1 = 0 ;
18174 int res1 = 0 ;
18175 bool temp2 = false ;
18176 bool temp3 = false ;
18177 PyObject * obj0 = 0 ;
18178 PyObject * obj1 = 0 ;
18179 PyObject * obj2 = 0 ;
18180 char * kwnames[] = {
18181 (char *) "self",(char *) "name",(char *) "mimetype", NULL
18182 };
18183
18184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) 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_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18188 }
18189 arg1 = reinterpret_cast< wxImage * >(argp1);
18190 {
18191 arg2 = wxString_in_helper(obj1);
18192 if (arg2 == NULL) SWIG_fail;
18193 temp2 = true;
18194 }
18195 {
18196 arg3 = wxString_in_helper(obj2);
18197 if (arg3 == NULL) SWIG_fail;
18198 temp3 = true;
18199 }
18200 {
18201 PyThreadState* __tstate = wxPyBeginAllowThreads();
18202 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
18203 wxPyEndAllowThreads(__tstate);
18204 if (PyErr_Occurred()) SWIG_fail;
18205 }
18206 {
18207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18208 }
18209 {
18210 if (temp2)
18211 delete arg2;
18212 }
18213 {
18214 if (temp3)
18215 delete arg3;
18216 }
18217 return resultobj;
18218 fail:
18219 {
18220 if (temp2)
18221 delete arg2;
18222 }
18223 {
18224 if (temp3)
18225 delete arg3;
18226 }
18227 return NULL;
18228 }
18229
18230
18231 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj = 0;
18233 wxInputStream *arg1 = 0 ;
18234 bool result;
18235 wxPyInputStream *temp1 ;
18236 bool created1 ;
18237 PyObject * obj0 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "stream", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
18243 {
18244 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
18245 arg1 = temp1->m_wxis;
18246 created1 = false;
18247 } else {
18248 PyErr_Clear(); // clear the failure of the wxPyConvert above
18249 arg1 = wxPyCBInputStream_create(obj0, false);
18250 if (arg1 == NULL) {
18251 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18252 SWIG_fail;
18253 }
18254 created1 = true;
18255 }
18256 }
18257 {
18258 PyThreadState* __tstate = wxPyBeginAllowThreads();
18259 result = (bool)wxImage::CanRead(*arg1);
18260 wxPyEndAllowThreads(__tstate);
18261 if (PyErr_Occurred()) SWIG_fail;
18262 }
18263 {
18264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18265 }
18266 {
18267 if (created1) delete arg1;
18268 }
18269 return resultobj;
18270 fail:
18271 {
18272 if (created1) delete arg1;
18273 }
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxImage *arg1 = (wxImage *) 0 ;
18281 wxInputStream *arg2 = 0 ;
18282 long arg3 = (long) wxBITMAP_TYPE_ANY ;
18283 int arg4 = (int) -1 ;
18284 bool result;
18285 void *argp1 = 0 ;
18286 int res1 = 0 ;
18287 wxPyInputStream *temp2 ;
18288 bool created2 ;
18289 long val3 ;
18290 int ecode3 = 0 ;
18291 int val4 ;
18292 int ecode4 = 0 ;
18293 PyObject * obj0 = 0 ;
18294 PyObject * obj1 = 0 ;
18295 PyObject * obj2 = 0 ;
18296 PyObject * obj3 = 0 ;
18297 char * kwnames[] = {
18298 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
18299 };
18300
18301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18303 if (!SWIG_IsOK(res1)) {
18304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
18305 }
18306 arg1 = reinterpret_cast< wxImage * >(argp1);
18307 {
18308 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18309 arg2 = temp2->m_wxis;
18310 created2 = false;
18311 } else {
18312 PyErr_Clear(); // clear the failure of the wxPyConvert above
18313 arg2 = wxPyCBInputStream_create(obj1, false);
18314 if (arg2 == NULL) {
18315 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18316 SWIG_fail;
18317 }
18318 created2 = true;
18319 }
18320 }
18321 if (obj2) {
18322 ecode3 = SWIG_AsVal_long(obj2, &val3);
18323 if (!SWIG_IsOK(ecode3)) {
18324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
18325 }
18326 arg3 = static_cast< long >(val3);
18327 }
18328 if (obj3) {
18329 ecode4 = SWIG_AsVal_int(obj3, &val4);
18330 if (!SWIG_IsOK(ecode4)) {
18331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
18332 }
18333 arg4 = static_cast< int >(val4);
18334 }
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
18338 wxPyEndAllowThreads(__tstate);
18339 if (PyErr_Occurred()) SWIG_fail;
18340 }
18341 {
18342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18343 }
18344 {
18345 if (created2) delete arg2;
18346 }
18347 return resultobj;
18348 fail:
18349 {
18350 if (created2) delete arg2;
18351 }
18352 return NULL;
18353 }
18354
18355
18356 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18357 PyObject *resultobj = 0;
18358 wxImage *arg1 = (wxImage *) 0 ;
18359 wxInputStream *arg2 = 0 ;
18360 wxString *arg3 = 0 ;
18361 int arg4 = (int) -1 ;
18362 bool result;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 wxPyInputStream *temp2 ;
18366 bool created2 ;
18367 bool temp3 = false ;
18368 int val4 ;
18369 int ecode4 = 0 ;
18370 PyObject * obj0 = 0 ;
18371 PyObject * obj1 = 0 ;
18372 PyObject * obj2 = 0 ;
18373 PyObject * obj3 = 0 ;
18374 char * kwnames[] = {
18375 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
18376 };
18377
18378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18380 if (!SWIG_IsOK(res1)) {
18381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
18382 }
18383 arg1 = reinterpret_cast< wxImage * >(argp1);
18384 {
18385 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18386 arg2 = temp2->m_wxis;
18387 created2 = false;
18388 } else {
18389 PyErr_Clear(); // clear the failure of the wxPyConvert above
18390 arg2 = wxPyCBInputStream_create(obj1, false);
18391 if (arg2 == NULL) {
18392 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18393 SWIG_fail;
18394 }
18395 created2 = true;
18396 }
18397 }
18398 {
18399 arg3 = wxString_in_helper(obj2);
18400 if (arg3 == NULL) SWIG_fail;
18401 temp3 = true;
18402 }
18403 if (obj3) {
18404 ecode4 = SWIG_AsVal_int(obj3, &val4);
18405 if (!SWIG_IsOK(ecode4)) {
18406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
18407 }
18408 arg4 = static_cast< int >(val4);
18409 }
18410 {
18411 PyThreadState* __tstate = wxPyBeginAllowThreads();
18412 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
18413 wxPyEndAllowThreads(__tstate);
18414 if (PyErr_Occurred()) SWIG_fail;
18415 }
18416 {
18417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18418 }
18419 {
18420 if (created2) delete arg2;
18421 }
18422 {
18423 if (temp3)
18424 delete arg3;
18425 }
18426 return resultobj;
18427 fail:
18428 {
18429 if (created2) delete arg2;
18430 }
18431 {
18432 if (temp3)
18433 delete arg3;
18434 }
18435 return NULL;
18436 }
18437
18438
18439 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18440 PyObject *resultobj = 0;
18441 wxImage *arg1 = (wxImage *) 0 ;
18442 bool result;
18443 void *argp1 = 0 ;
18444 int res1 = 0 ;
18445 PyObject *swig_obj[1] ;
18446
18447 if (!args) SWIG_fail;
18448 swig_obj[0] = args;
18449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
18452 }
18453 arg1 = reinterpret_cast< wxImage * >(argp1);
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 result = (bool)(arg1)->IsOk();
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 {
18461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18462 }
18463 return resultobj;
18464 fail:
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18470 PyObject *resultobj = 0;
18471 wxImage *arg1 = (wxImage *) 0 ;
18472 int result;
18473 void *argp1 = 0 ;
18474 int res1 = 0 ;
18475 PyObject *swig_obj[1] ;
18476
18477 if (!args) SWIG_fail;
18478 swig_obj[0] = args;
18479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
18482 }
18483 arg1 = reinterpret_cast< wxImage * >(argp1);
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 result = (int)(arg1)->GetWidth();
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = SWIG_From_int(static_cast< int >(result));
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498 PyObject *resultobj = 0;
18499 wxImage *arg1 = (wxImage *) 0 ;
18500 int result;
18501 void *argp1 = 0 ;
18502 int res1 = 0 ;
18503 PyObject *swig_obj[1] ;
18504
18505 if (!args) SWIG_fail;
18506 swig_obj[0] = args;
18507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18508 if (!SWIG_IsOK(res1)) {
18509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
18510 }
18511 arg1 = reinterpret_cast< wxImage * >(argp1);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (int)(arg1)->GetHeight();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 resultobj = SWIG_From_int(static_cast< int >(result));
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18526 PyObject *resultobj = 0;
18527 wxImage *arg1 = (wxImage *) 0 ;
18528 wxSize result;
18529 void *argp1 = 0 ;
18530 int res1 = 0 ;
18531 PyObject *swig_obj[1] ;
18532
18533 if (!args) SWIG_fail;
18534 swig_obj[0] = args;
18535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18536 if (!SWIG_IsOK(res1)) {
18537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18538 }
18539 arg1 = reinterpret_cast< wxImage * >(argp1);
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 result = wxImage_GetSize(arg1);
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18554 PyObject *resultobj = 0;
18555 wxImage *arg1 = (wxImage *) 0 ;
18556 wxRect *arg2 = 0 ;
18557 SwigValueWrapper<wxImage > result;
18558 void *argp1 = 0 ;
18559 int res1 = 0 ;
18560 wxRect temp2 ;
18561 PyObject * obj0 = 0 ;
18562 PyObject * obj1 = 0 ;
18563 char * kwnames[] = {
18564 (char *) "self",(char *) "rect", NULL
18565 };
18566
18567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18569 if (!SWIG_IsOK(res1)) {
18570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18571 }
18572 arg1 = reinterpret_cast< wxImage * >(argp1);
18573 {
18574 arg2 = &temp2;
18575 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18576 }
18577 {
18578 PyThreadState* __tstate = wxPyBeginAllowThreads();
18579 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18580 wxPyEndAllowThreads(__tstate);
18581 if (PyErr_Occurred()) SWIG_fail;
18582 }
18583 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18584 return resultobj;
18585 fail:
18586 return NULL;
18587 }
18588
18589
18590 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18591 PyObject *resultobj = 0;
18592 wxImage *arg1 = (wxImage *) 0 ;
18593 wxSize *arg2 = 0 ;
18594 wxPoint *arg3 = 0 ;
18595 int arg4 = (int) -1 ;
18596 int arg5 = (int) -1 ;
18597 int arg6 = (int) -1 ;
18598 SwigValueWrapper<wxImage > result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 wxSize temp2 ;
18602 wxPoint temp3 ;
18603 int val4 ;
18604 int ecode4 = 0 ;
18605 int val5 ;
18606 int ecode5 = 0 ;
18607 int val6 ;
18608 int ecode6 = 0 ;
18609 PyObject * obj0 = 0 ;
18610 PyObject * obj1 = 0 ;
18611 PyObject * obj2 = 0 ;
18612 PyObject * obj3 = 0 ;
18613 PyObject * obj4 = 0 ;
18614 PyObject * obj5 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18623 }
18624 arg1 = reinterpret_cast< wxImage * >(argp1);
18625 {
18626 arg2 = &temp2;
18627 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18628 }
18629 {
18630 arg3 = &temp3;
18631 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18632 }
18633 if (obj3) {
18634 ecode4 = SWIG_AsVal_int(obj3, &val4);
18635 if (!SWIG_IsOK(ecode4)) {
18636 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18637 }
18638 arg4 = static_cast< int >(val4);
18639 }
18640 if (obj4) {
18641 ecode5 = SWIG_AsVal_int(obj4, &val5);
18642 if (!SWIG_IsOK(ecode5)) {
18643 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18644 }
18645 arg5 = static_cast< int >(val5);
18646 }
18647 if (obj5) {
18648 ecode6 = SWIG_AsVal_int(obj5, &val6);
18649 if (!SWIG_IsOK(ecode6)) {
18650 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18651 }
18652 arg6 = static_cast< int >(val6);
18653 }
18654 {
18655 PyThreadState* __tstate = wxPyBeginAllowThreads();
18656 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18657 wxPyEndAllowThreads(__tstate);
18658 if (PyErr_Occurred()) SWIG_fail;
18659 }
18660 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18661 return resultobj;
18662 fail:
18663 return NULL;
18664 }
18665
18666
18667 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18668 PyObject *resultobj = 0;
18669 wxImage *arg1 = (wxImage *) 0 ;
18670 SwigValueWrapper<wxImage > result;
18671 void *argp1 = 0 ;
18672 int res1 = 0 ;
18673 PyObject *swig_obj[1] ;
18674
18675 if (!args) SWIG_fail;
18676 swig_obj[0] = args;
18677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18678 if (!SWIG_IsOK(res1)) {
18679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18680 }
18681 arg1 = reinterpret_cast< wxImage * >(argp1);
18682 {
18683 PyThreadState* __tstate = wxPyBeginAllowThreads();
18684 result = (arg1)->Copy();
18685 wxPyEndAllowThreads(__tstate);
18686 if (PyErr_Occurred()) SWIG_fail;
18687 }
18688 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj = 0;
18697 wxImage *arg1 = (wxImage *) 0 ;
18698 wxImage *arg2 = 0 ;
18699 int arg3 ;
18700 int arg4 ;
18701 void *argp1 = 0 ;
18702 int res1 = 0 ;
18703 void *argp2 = 0 ;
18704 int res2 = 0 ;
18705 int val3 ;
18706 int ecode3 = 0 ;
18707 int val4 ;
18708 int ecode4 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 PyObject * obj1 = 0 ;
18711 PyObject * obj2 = 0 ;
18712 PyObject * obj3 = 0 ;
18713 char * kwnames[] = {
18714 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18715 };
18716
18717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18721 }
18722 arg1 = reinterpret_cast< wxImage * >(argp1);
18723 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18724 if (!SWIG_IsOK(res2)) {
18725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18726 }
18727 if (!argp2) {
18728 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18729 }
18730 arg2 = reinterpret_cast< wxImage * >(argp2);
18731 ecode3 = SWIG_AsVal_int(obj2, &val3);
18732 if (!SWIG_IsOK(ecode3)) {
18733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18734 }
18735 arg3 = static_cast< int >(val3);
18736 ecode4 = SWIG_AsVal_int(obj3, &val4);
18737 if (!SWIG_IsOK(ecode4)) {
18738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18739 }
18740 arg4 = static_cast< int >(val4);
18741 {
18742 PyThreadState* __tstate = wxPyBeginAllowThreads();
18743 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18744 wxPyEndAllowThreads(__tstate);
18745 if (PyErr_Occurred()) SWIG_fail;
18746 }
18747 resultobj = SWIG_Py_Void();
18748 return resultobj;
18749 fail:
18750 return NULL;
18751 }
18752
18753
18754 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18755 PyObject *resultobj = 0;
18756 wxImage *arg1 = (wxImage *) 0 ;
18757 PyObject *result = 0 ;
18758 void *argp1 = 0 ;
18759 int res1 = 0 ;
18760 PyObject *swig_obj[1] ;
18761
18762 if (!args) SWIG_fail;
18763 swig_obj[0] = args;
18764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18765 if (!SWIG_IsOK(res1)) {
18766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18767 }
18768 arg1 = reinterpret_cast< wxImage * >(argp1);
18769 {
18770 PyThreadState* __tstate = wxPyBeginAllowThreads();
18771 result = (PyObject *)wxImage_GetData(arg1);
18772 wxPyEndAllowThreads(__tstate);
18773 if (PyErr_Occurred()) SWIG_fail;
18774 }
18775 resultobj = result;
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18783 PyObject *resultobj = 0;
18784 wxImage *arg1 = (wxImage *) 0 ;
18785 buffer arg2 ;
18786 int arg3 ;
18787 void *argp1 = 0 ;
18788 int res1 = 0 ;
18789 Py_ssize_t temp2 ;
18790 PyObject * obj0 = 0 ;
18791 PyObject * obj1 = 0 ;
18792 char * kwnames[] = {
18793 (char *) "self",(char *) "data", NULL
18794 };
18795
18796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18798 if (!SWIG_IsOK(res1)) {
18799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18800 }
18801 arg1 = reinterpret_cast< wxImage * >(argp1);
18802 {
18803 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18804 arg3 = (int)temp2;
18805 }
18806 {
18807 PyThreadState* __tstate = wxPyBeginAllowThreads();
18808 wxImage_SetData(arg1,arg2,arg3);
18809 wxPyEndAllowThreads(__tstate);
18810 if (PyErr_Occurred()) SWIG_fail;
18811 }
18812 resultobj = SWIG_Py_Void();
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18820 PyObject *resultobj = 0;
18821 wxImage *arg1 = (wxImage *) 0 ;
18822 PyObject *result = 0 ;
18823 void *argp1 = 0 ;
18824 int res1 = 0 ;
18825 PyObject *swig_obj[1] ;
18826
18827 if (!args) SWIG_fail;
18828 swig_obj[0] = args;
18829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18830 if (!SWIG_IsOK(res1)) {
18831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18832 }
18833 arg1 = reinterpret_cast< wxImage * >(argp1);
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18837 wxPyEndAllowThreads(__tstate);
18838 if (PyErr_Occurred()) SWIG_fail;
18839 }
18840 resultobj = result;
18841 return resultobj;
18842 fail:
18843 return NULL;
18844 }
18845
18846
18847 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj = 0;
18849 wxImage *arg1 = (wxImage *) 0 ;
18850 buffer arg2 ;
18851 int arg3 ;
18852 void *argp1 = 0 ;
18853 int res1 = 0 ;
18854 Py_ssize_t temp2 ;
18855 PyObject * obj0 = 0 ;
18856 PyObject * obj1 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "data", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18863 if (!SWIG_IsOK(res1)) {
18864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18865 }
18866 arg1 = reinterpret_cast< wxImage * >(argp1);
18867 {
18868 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18869 arg3 = (int)temp2;
18870 }
18871 {
18872 PyThreadState* __tstate = wxPyBeginAllowThreads();
18873 wxImage_SetDataBuffer(arg1,arg2,arg3);
18874 wxPyEndAllowThreads(__tstate);
18875 if (PyErr_Occurred()) SWIG_fail;
18876 }
18877 resultobj = SWIG_Py_Void();
18878 return resultobj;
18879 fail:
18880 return NULL;
18881 }
18882
18883
18884 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18885 PyObject *resultobj = 0;
18886 wxImage *arg1 = (wxImage *) 0 ;
18887 PyObject *result = 0 ;
18888 void *argp1 = 0 ;
18889 int res1 = 0 ;
18890 PyObject *swig_obj[1] ;
18891
18892 if (!args) SWIG_fail;
18893 swig_obj[0] = args;
18894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18895 if (!SWIG_IsOK(res1)) {
18896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18897 }
18898 arg1 = reinterpret_cast< wxImage * >(argp1);
18899 {
18900 PyThreadState* __tstate = wxPyBeginAllowThreads();
18901 result = (PyObject *)wxImage_GetAlphaData(arg1);
18902 wxPyEndAllowThreads(__tstate);
18903 if (PyErr_Occurred()) SWIG_fail;
18904 }
18905 resultobj = result;
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj = 0;
18914 wxImage *arg1 = (wxImage *) 0 ;
18915 buffer arg2 ;
18916 int arg3 ;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 Py_ssize_t temp2 ;
18920 PyObject * obj0 = 0 ;
18921 PyObject * obj1 = 0 ;
18922 char * kwnames[] = {
18923 (char *) "self",(char *) "alpha", NULL
18924 };
18925
18926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18928 if (!SWIG_IsOK(res1)) {
18929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18930 }
18931 arg1 = reinterpret_cast< wxImage * >(argp1);
18932 {
18933 if (obj1 != Py_None) {
18934 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18935 arg3 = (int)temp2;
18936 }
18937 }
18938 {
18939 PyThreadState* __tstate = wxPyBeginAllowThreads();
18940 wxImage_SetAlphaData(arg1,arg2,arg3);
18941 wxPyEndAllowThreads(__tstate);
18942 if (PyErr_Occurred()) SWIG_fail;
18943 }
18944 resultobj = SWIG_Py_Void();
18945 return resultobj;
18946 fail:
18947 return NULL;
18948 }
18949
18950
18951 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18952 PyObject *resultobj = 0;
18953 wxImage *arg1 = (wxImage *) 0 ;
18954 PyObject *result = 0 ;
18955 void *argp1 = 0 ;
18956 int res1 = 0 ;
18957 PyObject *swig_obj[1] ;
18958
18959 if (!args) SWIG_fail;
18960 swig_obj[0] = args;
18961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18962 if (!SWIG_IsOK(res1)) {
18963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18964 }
18965 arg1 = reinterpret_cast< wxImage * >(argp1);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = result;
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18980 PyObject *resultobj = 0;
18981 wxImage *arg1 = (wxImage *) 0 ;
18982 buffer arg2 ;
18983 int arg3 ;
18984 void *argp1 = 0 ;
18985 int res1 = 0 ;
18986 Py_ssize_t temp2 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char * kwnames[] = {
18990 (char *) "self",(char *) "alpha", NULL
18991 };
18992
18993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18995 if (!SWIG_IsOK(res1)) {
18996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18997 }
18998 arg1 = reinterpret_cast< wxImage * >(argp1);
18999 {
19000 if (obj1 != Py_None) {
19001 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
19002 arg3 = (int)temp2;
19003 }
19004 }
19005 {
19006 PyThreadState* __tstate = wxPyBeginAllowThreads();
19007 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 resultobj = SWIG_Py_Void();
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj = 0;
19020 wxImage *arg1 = (wxImage *) 0 ;
19021 byte arg2 ;
19022 byte arg3 ;
19023 byte arg4 ;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 unsigned char val2 ;
19027 int ecode2 = 0 ;
19028 unsigned char val3 ;
19029 int ecode3 = 0 ;
19030 unsigned char val4 ;
19031 int ecode4 = 0 ;
19032 PyObject * obj0 = 0 ;
19033 PyObject * obj1 = 0 ;
19034 PyObject * obj2 = 0 ;
19035 PyObject * obj3 = 0 ;
19036 char * kwnames[] = {
19037 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19038 };
19039
19040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19042 if (!SWIG_IsOK(res1)) {
19043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
19044 }
19045 arg1 = reinterpret_cast< wxImage * >(argp1);
19046 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19047 if (!SWIG_IsOK(ecode2)) {
19048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
19049 }
19050 arg2 = static_cast< byte >(val2);
19051 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19052 if (!SWIG_IsOK(ecode3)) {
19053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
19054 }
19055 arg3 = static_cast< byte >(val3);
19056 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19057 if (!SWIG_IsOK(ecode4)) {
19058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
19059 }
19060 arg4 = static_cast< byte >(val4);
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 (arg1)->SetMaskColour(arg2,arg3,arg4);
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = SWIG_Py_Void();
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19075 PyObject *resultobj = 0;
19076 wxImage *arg1 = (wxImage *) 0 ;
19077 byte *arg2 = (byte *) 0 ;
19078 byte *arg3 = (byte *) 0 ;
19079 byte *arg4 = (byte *) 0 ;
19080 void *argp1 = 0 ;
19081 int res1 = 0 ;
19082 byte temp2 ;
19083 int res2 = SWIG_TMPOBJ ;
19084 byte temp3 ;
19085 int res3 = SWIG_TMPOBJ ;
19086 byte temp4 ;
19087 int res4 = SWIG_TMPOBJ ;
19088 PyObject *swig_obj[1] ;
19089
19090 arg2 = &temp2;
19091 arg3 = &temp3;
19092 arg4 = &temp4;
19093 if (!args) SWIG_fail;
19094 swig_obj[0] = args;
19095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19096 if (!SWIG_IsOK(res1)) {
19097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
19098 }
19099 arg1 = reinterpret_cast< wxImage * >(argp1);
19100 {
19101 PyThreadState* __tstate = wxPyBeginAllowThreads();
19102 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 resultobj = SWIG_Py_Void();
19107 if (SWIG_IsTmpObj(res2)) {
19108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
19109 } else {
19110 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
19112 }
19113 if (SWIG_IsTmpObj(res3)) {
19114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
19115 } else {
19116 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
19118 }
19119 if (SWIG_IsTmpObj(res4)) {
19120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
19121 } else {
19122 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
19124 }
19125 return resultobj;
19126 fail:
19127 return NULL;
19128 }
19129
19130
19131 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19132 PyObject *resultobj = 0;
19133 wxImage *arg1 = (wxImage *) 0 ;
19134 byte result;
19135 void *argp1 = 0 ;
19136 int res1 = 0 ;
19137 PyObject *swig_obj[1] ;
19138
19139 if (!args) SWIG_fail;
19140 swig_obj[0] = args;
19141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19142 if (!SWIG_IsOK(res1)) {
19143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
19144 }
19145 arg1 = reinterpret_cast< wxImage * >(argp1);
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 result = (byte)(arg1)->GetMaskRed();
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxImage *arg1 = (wxImage *) 0 ;
19162 byte result;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
19172 }
19173 arg1 = reinterpret_cast< wxImage * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (byte)(arg1)->GetMaskGreen();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19188 PyObject *resultobj = 0;
19189 wxImage *arg1 = (wxImage *) 0 ;
19190 byte result;
19191 void *argp1 = 0 ;
19192 int res1 = 0 ;
19193 PyObject *swig_obj[1] ;
19194
19195 if (!args) SWIG_fail;
19196 swig_obj[0] = args;
19197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19198 if (!SWIG_IsOK(res1)) {
19199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
19200 }
19201 arg1 = reinterpret_cast< wxImage * >(argp1);
19202 {
19203 PyThreadState* __tstate = wxPyBeginAllowThreads();
19204 result = (byte)(arg1)->GetMaskBlue();
19205 wxPyEndAllowThreads(__tstate);
19206 if (PyErr_Occurred()) SWIG_fail;
19207 }
19208 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19209 return resultobj;
19210 fail:
19211 return NULL;
19212 }
19213
19214
19215 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19216 PyObject *resultobj = 0;
19217 wxImage *arg1 = (wxImage *) 0 ;
19218 bool arg2 = (bool) true ;
19219 void *argp1 = 0 ;
19220 int res1 = 0 ;
19221 bool val2 ;
19222 int ecode2 = 0 ;
19223 PyObject * obj0 = 0 ;
19224 PyObject * obj1 = 0 ;
19225 char * kwnames[] = {
19226 (char *) "self",(char *) "mask", NULL
19227 };
19228
19229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
19230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19231 if (!SWIG_IsOK(res1)) {
19232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
19233 }
19234 arg1 = reinterpret_cast< wxImage * >(argp1);
19235 if (obj1) {
19236 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19237 if (!SWIG_IsOK(ecode2)) {
19238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
19239 }
19240 arg2 = static_cast< bool >(val2);
19241 }
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 (arg1)->SetMask(arg2);
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 resultobj = SWIG_Py_Void();
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19256 PyObject *resultobj = 0;
19257 wxImage *arg1 = (wxImage *) 0 ;
19258 bool result;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 PyObject *swig_obj[1] ;
19262
19263 if (!args) SWIG_fail;
19264 swig_obj[0] = args;
19265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
19268 }
19269 arg1 = reinterpret_cast< wxImage * >(argp1);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (bool)(arg1)->HasMask();
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 {
19277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19278 }
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj = 0;
19287 wxImage *arg1 = (wxImage *) 0 ;
19288 double arg2 ;
19289 wxPoint *arg3 = 0 ;
19290 bool arg4 = (bool) true ;
19291 wxPoint *arg5 = (wxPoint *) NULL ;
19292 SwigValueWrapper<wxImage > result;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 double val2 ;
19296 int ecode2 = 0 ;
19297 wxPoint temp3 ;
19298 bool val4 ;
19299 int ecode4 = 0 ;
19300 void *argp5 = 0 ;
19301 int res5 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 PyObject * obj2 = 0 ;
19305 PyObject * obj3 = 0 ;
19306 PyObject * obj4 = 0 ;
19307 char * kwnames[] = {
19308 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
19309 };
19310
19311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19313 if (!SWIG_IsOK(res1)) {
19314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
19315 }
19316 arg1 = reinterpret_cast< wxImage * >(argp1);
19317 ecode2 = SWIG_AsVal_double(obj1, &val2);
19318 if (!SWIG_IsOK(ecode2)) {
19319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
19320 }
19321 arg2 = static_cast< double >(val2);
19322 {
19323 arg3 = &temp3;
19324 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19325 }
19326 if (obj3) {
19327 ecode4 = SWIG_AsVal_bool(obj3, &val4);
19328 if (!SWIG_IsOK(ecode4)) {
19329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
19330 }
19331 arg4 = static_cast< bool >(val4);
19332 }
19333 if (obj4) {
19334 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
19335 if (!SWIG_IsOK(res5)) {
19336 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
19337 }
19338 arg5 = reinterpret_cast< wxPoint * >(argp5);
19339 }
19340 {
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19347 return resultobj;
19348 fail:
19349 return NULL;
19350 }
19351
19352
19353 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj = 0;
19355 wxImage *arg1 = (wxImage *) 0 ;
19356 bool arg2 = (bool) true ;
19357 SwigValueWrapper<wxImage > result;
19358 void *argp1 = 0 ;
19359 int res1 = 0 ;
19360 bool val2 ;
19361 int ecode2 = 0 ;
19362 PyObject * obj0 = 0 ;
19363 PyObject * obj1 = 0 ;
19364 char * kwnames[] = {
19365 (char *) "self",(char *) "clockwise", NULL
19366 };
19367
19368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
19369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19370 if (!SWIG_IsOK(res1)) {
19371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
19372 }
19373 arg1 = reinterpret_cast< wxImage * >(argp1);
19374 if (obj1) {
19375 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19376 if (!SWIG_IsOK(ecode2)) {
19377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
19378 }
19379 arg2 = static_cast< bool >(val2);
19380 }
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 result = (arg1)->Rotate90(arg2);
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj = 0;
19396 wxImage *arg1 = (wxImage *) 0 ;
19397 bool arg2 = (bool) true ;
19398 SwigValueWrapper<wxImage > result;
19399 void *argp1 = 0 ;
19400 int res1 = 0 ;
19401 bool val2 ;
19402 int ecode2 = 0 ;
19403 PyObject * obj0 = 0 ;
19404 PyObject * obj1 = 0 ;
19405 char * kwnames[] = {
19406 (char *) "self",(char *) "horizontally", NULL
19407 };
19408
19409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
19410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19411 if (!SWIG_IsOK(res1)) {
19412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
19413 }
19414 arg1 = reinterpret_cast< wxImage * >(argp1);
19415 if (obj1) {
19416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19417 if (!SWIG_IsOK(ecode2)) {
19418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
19419 }
19420 arg2 = static_cast< bool >(val2);
19421 }
19422 {
19423 PyThreadState* __tstate = wxPyBeginAllowThreads();
19424 result = (arg1)->Mirror(arg2);
19425 wxPyEndAllowThreads(__tstate);
19426 if (PyErr_Occurred()) SWIG_fail;
19427 }
19428 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19429 return resultobj;
19430 fail:
19431 return NULL;
19432 }
19433
19434
19435 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19436 PyObject *resultobj = 0;
19437 wxImage *arg1 = (wxImage *) 0 ;
19438 byte arg2 ;
19439 byte arg3 ;
19440 byte arg4 ;
19441 byte arg5 ;
19442 byte arg6 ;
19443 byte arg7 ;
19444 void *argp1 = 0 ;
19445 int res1 = 0 ;
19446 unsigned char val2 ;
19447 int ecode2 = 0 ;
19448 unsigned char val3 ;
19449 int ecode3 = 0 ;
19450 unsigned char val4 ;
19451 int ecode4 = 0 ;
19452 unsigned char val5 ;
19453 int ecode5 = 0 ;
19454 unsigned char val6 ;
19455 int ecode6 = 0 ;
19456 unsigned char val7 ;
19457 int ecode7 = 0 ;
19458 PyObject * obj0 = 0 ;
19459 PyObject * obj1 = 0 ;
19460 PyObject * obj2 = 0 ;
19461 PyObject * obj3 = 0 ;
19462 PyObject * obj4 = 0 ;
19463 PyObject * obj5 = 0 ;
19464 PyObject * obj6 = 0 ;
19465 char * kwnames[] = {
19466 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
19467 };
19468
19469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
19470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19471 if (!SWIG_IsOK(res1)) {
19472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
19473 }
19474 arg1 = reinterpret_cast< wxImage * >(argp1);
19475 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19476 if (!SWIG_IsOK(ecode2)) {
19477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
19478 }
19479 arg2 = static_cast< byte >(val2);
19480 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19481 if (!SWIG_IsOK(ecode3)) {
19482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
19483 }
19484 arg3 = static_cast< byte >(val3);
19485 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19486 if (!SWIG_IsOK(ecode4)) {
19487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
19488 }
19489 arg4 = static_cast< byte >(val4);
19490 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
19491 if (!SWIG_IsOK(ecode5)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
19493 }
19494 arg5 = static_cast< byte >(val5);
19495 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
19496 if (!SWIG_IsOK(ecode6)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
19498 }
19499 arg6 = static_cast< byte >(val6);
19500 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
19501 if (!SWIG_IsOK(ecode7)) {
19502 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
19503 }
19504 arg7 = static_cast< byte >(val7);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_Py_Void();
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = 0;
19520 wxImage *arg1 = (wxImage *) 0 ;
19521 double arg2 = (double) 0.299 ;
19522 double arg3 = (double) 0.587 ;
19523 double arg4 = (double) 0.114 ;
19524 SwigValueWrapper<wxImage > result;
19525 void *argp1 = 0 ;
19526 int res1 = 0 ;
19527 double val2 ;
19528 int ecode2 = 0 ;
19529 double val3 ;
19530 int ecode3 = 0 ;
19531 double val4 ;
19532 int ecode4 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 PyObject * obj2 = 0 ;
19536 PyObject * obj3 = 0 ;
19537 char * kwnames[] = {
19538 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19539 };
19540
19541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19545 }
19546 arg1 = reinterpret_cast< wxImage * >(argp1);
19547 if (obj1) {
19548 ecode2 = SWIG_AsVal_double(obj1, &val2);
19549 if (!SWIG_IsOK(ecode2)) {
19550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19551 }
19552 arg2 = static_cast< double >(val2);
19553 }
19554 if (obj2) {
19555 ecode3 = SWIG_AsVal_double(obj2, &val3);
19556 if (!SWIG_IsOK(ecode3)) {
19557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19558 }
19559 arg3 = static_cast< double >(val3);
19560 }
19561 if (obj3) {
19562 ecode4 = SWIG_AsVal_double(obj3, &val4);
19563 if (!SWIG_IsOK(ecode4)) {
19564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19565 }
19566 arg4 = static_cast< double >(val4);
19567 }
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj = 0;
19583 wxImage *arg1 = (wxImage *) 0 ;
19584 byte arg2 ;
19585 byte arg3 ;
19586 byte arg4 ;
19587 SwigValueWrapper<wxImage > result;
19588 void *argp1 = 0 ;
19589 int res1 = 0 ;
19590 unsigned char val2 ;
19591 int ecode2 = 0 ;
19592 unsigned char val3 ;
19593 int ecode3 = 0 ;
19594 unsigned char val4 ;
19595 int ecode4 = 0 ;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 PyObject * obj2 = 0 ;
19599 PyObject * obj3 = 0 ;
19600 char * kwnames[] = {
19601 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19602 };
19603
19604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19606 if (!SWIG_IsOK(res1)) {
19607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19608 }
19609 arg1 = reinterpret_cast< wxImage * >(argp1);
19610 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19611 if (!SWIG_IsOK(ecode2)) {
19612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19613 }
19614 arg2 = static_cast< byte >(val2);
19615 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19616 if (!SWIG_IsOK(ecode3)) {
19617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19618 }
19619 arg3 = static_cast< byte >(val3);
19620 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19621 if (!SWIG_IsOK(ecode4)) {
19622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19623 }
19624 arg4 = static_cast< byte >(val4);
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19632 return resultobj;
19633 fail:
19634 return NULL;
19635 }
19636
19637
19638 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19639 PyObject *resultobj = 0;
19640 wxImage *arg1 = (wxImage *) 0 ;
19641 wxString *arg2 = 0 ;
19642 wxString *arg3 = 0 ;
19643 void *argp1 = 0 ;
19644 int res1 = 0 ;
19645 bool temp2 = false ;
19646 bool temp3 = false ;
19647 PyObject * obj0 = 0 ;
19648 PyObject * obj1 = 0 ;
19649 PyObject * obj2 = 0 ;
19650 char * kwnames[] = {
19651 (char *) "self",(char *) "name",(char *) "value", NULL
19652 };
19653
19654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19658 }
19659 arg1 = reinterpret_cast< wxImage * >(argp1);
19660 {
19661 arg2 = wxString_in_helper(obj1);
19662 if (arg2 == NULL) SWIG_fail;
19663 temp2 = true;
19664 }
19665 {
19666 arg3 = wxString_in_helper(obj2);
19667 if (arg3 == NULL) SWIG_fail;
19668 temp3 = true;
19669 }
19670 {
19671 PyThreadState* __tstate = wxPyBeginAllowThreads();
19672 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19673 wxPyEndAllowThreads(__tstate);
19674 if (PyErr_Occurred()) SWIG_fail;
19675 }
19676 resultobj = SWIG_Py_Void();
19677 {
19678 if (temp2)
19679 delete arg2;
19680 }
19681 {
19682 if (temp3)
19683 delete arg3;
19684 }
19685 return resultobj;
19686 fail:
19687 {
19688 if (temp2)
19689 delete arg2;
19690 }
19691 {
19692 if (temp3)
19693 delete arg3;
19694 }
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19700 PyObject *resultobj = 0;
19701 wxImage *arg1 = (wxImage *) 0 ;
19702 wxString *arg2 = 0 ;
19703 int arg3 ;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 bool temp2 = false ;
19707 int val3 ;
19708 int ecode3 = 0 ;
19709 PyObject * obj0 = 0 ;
19710 PyObject * obj1 = 0 ;
19711 PyObject * obj2 = 0 ;
19712 char * kwnames[] = {
19713 (char *) "self",(char *) "name",(char *) "value", NULL
19714 };
19715
19716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19718 if (!SWIG_IsOK(res1)) {
19719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19720 }
19721 arg1 = reinterpret_cast< wxImage * >(argp1);
19722 {
19723 arg2 = wxString_in_helper(obj1);
19724 if (arg2 == NULL) SWIG_fail;
19725 temp2 = true;
19726 }
19727 ecode3 = SWIG_AsVal_int(obj2, &val3);
19728 if (!SWIG_IsOK(ecode3)) {
19729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19730 }
19731 arg3 = static_cast< int >(val3);
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 (arg1)->SetOption((wxString const &)*arg2,arg3);
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_Py_Void();
19739 {
19740 if (temp2)
19741 delete arg2;
19742 }
19743 return resultobj;
19744 fail:
19745 {
19746 if (temp2)
19747 delete arg2;
19748 }
19749 return NULL;
19750 }
19751
19752
19753 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19754 PyObject *resultobj = 0;
19755 wxImage *arg1 = (wxImage *) 0 ;
19756 wxString *arg2 = 0 ;
19757 wxString result;
19758 void *argp1 = 0 ;
19759 int res1 = 0 ;
19760 bool temp2 = false ;
19761 PyObject * obj0 = 0 ;
19762 PyObject * obj1 = 0 ;
19763 char * kwnames[] = {
19764 (char *) "self",(char *) "name", NULL
19765 };
19766
19767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19769 if (!SWIG_IsOK(res1)) {
19770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19771 }
19772 arg1 = reinterpret_cast< wxImage * >(argp1);
19773 {
19774 arg2 = wxString_in_helper(obj1);
19775 if (arg2 == NULL) SWIG_fail;
19776 temp2 = true;
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 #if wxUSE_UNICODE
19786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19787 #else
19788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19789 #endif
19790 }
19791 {
19792 if (temp2)
19793 delete arg2;
19794 }
19795 return resultobj;
19796 fail:
19797 {
19798 if (temp2)
19799 delete arg2;
19800 }
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = 0;
19807 wxImage *arg1 = (wxImage *) 0 ;
19808 wxString *arg2 = 0 ;
19809 int result;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 bool temp2 = false ;
19813 PyObject * obj0 = 0 ;
19814 PyObject * obj1 = 0 ;
19815 char * kwnames[] = {
19816 (char *) "self",(char *) "name", NULL
19817 };
19818
19819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19821 if (!SWIG_IsOK(res1)) {
19822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19823 }
19824 arg1 = reinterpret_cast< wxImage * >(argp1);
19825 {
19826 arg2 = wxString_in_helper(obj1);
19827 if (arg2 == NULL) SWIG_fail;
19828 temp2 = true;
19829 }
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19833 wxPyEndAllowThreads(__tstate);
19834 if (PyErr_Occurred()) SWIG_fail;
19835 }
19836 resultobj = SWIG_From_int(static_cast< int >(result));
19837 {
19838 if (temp2)
19839 delete arg2;
19840 }
19841 return resultobj;
19842 fail:
19843 {
19844 if (temp2)
19845 delete arg2;
19846 }
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj = 0;
19853 wxImage *arg1 = (wxImage *) 0 ;
19854 wxString *arg2 = 0 ;
19855 bool result;
19856 void *argp1 = 0 ;
19857 int res1 = 0 ;
19858 bool temp2 = false ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char * kwnames[] = {
19862 (char *) "self",(char *) "name", NULL
19863 };
19864
19865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19867 if (!SWIG_IsOK(res1)) {
19868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19869 }
19870 arg1 = reinterpret_cast< wxImage * >(argp1);
19871 {
19872 arg2 = wxString_in_helper(obj1);
19873 if (arg2 == NULL) SWIG_fail;
19874 temp2 = true;
19875 }
19876 {
19877 PyThreadState* __tstate = wxPyBeginAllowThreads();
19878 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19879 wxPyEndAllowThreads(__tstate);
19880 if (PyErr_Occurred()) SWIG_fail;
19881 }
19882 {
19883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19884 }
19885 {
19886 if (temp2)
19887 delete arg2;
19888 }
19889 return resultobj;
19890 fail:
19891 {
19892 if (temp2)
19893 delete arg2;
19894 }
19895 return NULL;
19896 }
19897
19898
19899 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19900 PyObject *resultobj = 0;
19901 wxImage *arg1 = (wxImage *) 0 ;
19902 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19903 unsigned long result;
19904 void *argp1 = 0 ;
19905 int res1 = 0 ;
19906 unsigned long val2 ;
19907 int ecode2 = 0 ;
19908 PyObject * obj0 = 0 ;
19909 PyObject * obj1 = 0 ;
19910 char * kwnames[] = {
19911 (char *) "self",(char *) "stopafter", NULL
19912 };
19913
19914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19918 }
19919 arg1 = reinterpret_cast< wxImage * >(argp1);
19920 if (obj1) {
19921 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19922 if (!SWIG_IsOK(ecode2)) {
19923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19924 }
19925 arg2 = static_cast< unsigned long >(val2);
19926 }
19927 {
19928 PyThreadState* __tstate = wxPyBeginAllowThreads();
19929 result = (unsigned long)(arg1)->CountColours(arg2);
19930 wxPyEndAllowThreads(__tstate);
19931 if (PyErr_Occurred()) SWIG_fail;
19932 }
19933 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19934 return resultobj;
19935 fail:
19936 return NULL;
19937 }
19938
19939
19940 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19941 PyObject *resultobj = 0;
19942 wxImage *arg1 = (wxImage *) 0 ;
19943 wxImageHistogram *arg2 = 0 ;
19944 unsigned long result;
19945 void *argp1 = 0 ;
19946 int res1 = 0 ;
19947 void *argp2 = 0 ;
19948 int res2 = 0 ;
19949 PyObject * obj0 = 0 ;
19950 PyObject * obj1 = 0 ;
19951 char * kwnames[] = {
19952 (char *) "self",(char *) "h", NULL
19953 };
19954
19955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19957 if (!SWIG_IsOK(res1)) {
19958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19959 }
19960 arg1 = reinterpret_cast< wxImage * >(argp1);
19961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19962 if (!SWIG_IsOK(res2)) {
19963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19964 }
19965 if (!argp2) {
19966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19967 }
19968 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19972 wxPyEndAllowThreads(__tstate);
19973 if (PyErr_Occurred()) SWIG_fail;
19974 }
19975 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj = 0;
19984 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 char * kwnames[] = {
19989 (char *) "handler", NULL
19990 };
19991
19992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19994 if (!SWIG_IsOK(res1)) {
19995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19996 }
19997 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19998 {
19999 PyThreadState* __tstate = wxPyBeginAllowThreads();
20000 wxImage::AddHandler(arg1);
20001 wxPyEndAllowThreads(__tstate);
20002 if (PyErr_Occurred()) SWIG_fail;
20003 }
20004 resultobj = SWIG_Py_Void();
20005 return resultobj;
20006 fail:
20007 return NULL;
20008 }
20009
20010
20011 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20012 PyObject *resultobj = 0;
20013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20014 void *argp1 = 0 ;
20015 int res1 = 0 ;
20016 PyObject * obj0 = 0 ;
20017 char * kwnames[] = {
20018 (char *) "handler", NULL
20019 };
20020
20021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
20022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20025 }
20026 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 wxImage::InsertHandler(arg1);
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 resultobj = SWIG_Py_Void();
20034 return resultobj;
20035 fail:
20036 return NULL;
20037 }
20038
20039
20040 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20041 PyObject *resultobj = 0;
20042 wxString *arg1 = 0 ;
20043 bool result;
20044 bool temp1 = false ;
20045 PyObject * obj0 = 0 ;
20046 char * kwnames[] = {
20047 (char *) "name", NULL
20048 };
20049
20050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
20051 {
20052 arg1 = wxString_in_helper(obj0);
20053 if (arg1 == NULL) SWIG_fail;
20054 temp1 = true;
20055 }
20056 {
20057 PyThreadState* __tstate = wxPyBeginAllowThreads();
20058 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
20059 wxPyEndAllowThreads(__tstate);
20060 if (PyErr_Occurred()) SWIG_fail;
20061 }
20062 {
20063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20064 }
20065 {
20066 if (temp1)
20067 delete arg1;
20068 }
20069 return resultobj;
20070 fail:
20071 {
20072 if (temp1)
20073 delete arg1;
20074 }
20075 return NULL;
20076 }
20077
20078
20079 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20080 PyObject *resultobj = 0;
20081 PyObject *result = 0 ;
20082
20083 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = (PyObject *)wxImage_GetHandlers();
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 resultobj = result;
20091 return resultobj;
20092 fail:
20093 return NULL;
20094 }
20095
20096
20097 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20098 PyObject *resultobj = 0;
20099 wxString result;
20100
20101 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
20102 {
20103 PyThreadState* __tstate = wxPyBeginAllowThreads();
20104 result = wxImage::GetImageExtWildcard();
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 {
20109 #if wxUSE_UNICODE
20110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20111 #else
20112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20113 #endif
20114 }
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj = 0;
20123 wxImage *arg1 = (wxImage *) 0 ;
20124 int arg2 = (int) -1 ;
20125 wxBitmap result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 int val2 ;
20129 int ecode2 = 0 ;
20130 PyObject * obj0 = 0 ;
20131 PyObject * obj1 = 0 ;
20132 char * kwnames[] = {
20133 (char *) "self",(char *) "depth", NULL
20134 };
20135
20136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
20137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20138 if (!SWIG_IsOK(res1)) {
20139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20140 }
20141 arg1 = reinterpret_cast< wxImage * >(argp1);
20142 if (obj1) {
20143 ecode2 = SWIG_AsVal_int(obj1, &val2);
20144 if (!SWIG_IsOK(ecode2)) {
20145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
20146 }
20147 arg2 = static_cast< int >(val2);
20148 }
20149 {
20150 if (!wxPyCheckForApp()) SWIG_fail;
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 result = wxImage_ConvertToBitmap(arg1,arg2);
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj = 0;
20165 wxImage *arg1 = (wxImage *) 0 ;
20166 byte arg2 ;
20167 byte arg3 ;
20168 byte arg4 ;
20169 wxBitmap result;
20170 void *argp1 = 0 ;
20171 int res1 = 0 ;
20172 unsigned char val2 ;
20173 int ecode2 = 0 ;
20174 unsigned char val3 ;
20175 int ecode3 = 0 ;
20176 unsigned char val4 ;
20177 int ecode4 = 0 ;
20178 PyObject * obj0 = 0 ;
20179 PyObject * obj1 = 0 ;
20180 PyObject * obj2 = 0 ;
20181 PyObject * obj3 = 0 ;
20182 char * kwnames[] = {
20183 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
20184 };
20185
20186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20188 if (!SWIG_IsOK(res1)) {
20189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20190 }
20191 arg1 = reinterpret_cast< wxImage * >(argp1);
20192 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
20193 if (!SWIG_IsOK(ecode2)) {
20194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
20195 }
20196 arg2 = static_cast< byte >(val2);
20197 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
20198 if (!SWIG_IsOK(ecode3)) {
20199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
20200 }
20201 arg3 = static_cast< byte >(val3);
20202 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
20203 if (!SWIG_IsOK(ecode4)) {
20204 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
20205 }
20206 arg4 = static_cast< byte >(val4);
20207 {
20208 if (!wxPyCheckForApp()) SWIG_fail;
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj = 0;
20223 wxImage *arg1 = (wxImage *) 0 ;
20224 double arg2 ;
20225 void *argp1 = 0 ;
20226 int res1 = 0 ;
20227 double val2 ;
20228 int ecode2 = 0 ;
20229 PyObject * obj0 = 0 ;
20230 PyObject * obj1 = 0 ;
20231 char * kwnames[] = {
20232 (char *) "self",(char *) "angle", NULL
20233 };
20234
20235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
20236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20237 if (!SWIG_IsOK(res1)) {
20238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
20239 }
20240 arg1 = reinterpret_cast< wxImage * >(argp1);
20241 ecode2 = SWIG_AsVal_double(obj1, &val2);
20242 if (!SWIG_IsOK(ecode2)) {
20243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
20244 }
20245 arg2 = static_cast< double >(val2);
20246 {
20247 PyThreadState* __tstate = wxPyBeginAllowThreads();
20248 (arg1)->RotateHue(arg2);
20249 wxPyEndAllowThreads(__tstate);
20250 if (PyErr_Occurred()) SWIG_fail;
20251 }
20252 resultobj = SWIG_Py_Void();
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj = 0;
20261 wxImage_RGBValue arg1 ;
20262 wxImage_HSVValue result;
20263 void *argp1 ;
20264 int res1 = 0 ;
20265 PyObject * obj0 = 0 ;
20266 char * kwnames[] = {
20267 (char *) "rgb", NULL
20268 };
20269
20270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
20271 {
20272 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
20273 if (!SWIG_IsOK(res1)) {
20274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20275 }
20276 if (!argp1) {
20277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20278 } else {
20279 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
20280 arg1 = *temp;
20281 if (SWIG_IsNewObj(res1)) delete temp;
20282 }
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = wxImage::RGBtoHSV(arg1);
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
20291 return resultobj;
20292 fail:
20293 return NULL;
20294 }
20295
20296
20297 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj = 0;
20299 wxImage_HSVValue arg1 ;
20300 wxImage_RGBValue result;
20301 void *argp1 ;
20302 int res1 = 0 ;
20303 PyObject * obj0 = 0 ;
20304 char * kwnames[] = {
20305 (char *) "hsv", NULL
20306 };
20307
20308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
20309 {
20310 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
20311 if (!SWIG_IsOK(res1)) {
20312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20313 }
20314 if (!argp1) {
20315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20316 } else {
20317 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
20318 arg1 = *temp;
20319 if (SWIG_IsNewObj(res1)) delete temp;
20320 }
20321 }
20322 {
20323 PyThreadState* __tstate = wxPyBeginAllowThreads();
20324 result = wxImage::HSVtoRGB(arg1);
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20336 PyObject *obj;
20337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20338 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
20339 return SWIG_Py_Void();
20340 }
20341
20342 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 return SWIG_Python_InitShadowInstance(args);
20344 }
20345
20346 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20347 PyObject *resultobj = 0;
20348 int arg1 ;
20349 int arg2 ;
20350 buffer arg3 ;
20351 int arg4 ;
20352 buffer arg5 = (buffer) NULL ;
20353 int arg6 = (int) 0 ;
20354 wxImage *result = 0 ;
20355 int val1 ;
20356 int ecode1 = 0 ;
20357 int val2 ;
20358 int ecode2 = 0 ;
20359 Py_ssize_t temp3 ;
20360 Py_ssize_t temp5 ;
20361 PyObject * obj0 = 0 ;
20362 PyObject * obj1 = 0 ;
20363 PyObject * obj2 = 0 ;
20364 PyObject * obj3 = 0 ;
20365 char * kwnames[] = {
20366 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
20367 };
20368
20369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20370 ecode1 = SWIG_AsVal_int(obj0, &val1);
20371 if (!SWIG_IsOK(ecode1)) {
20372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
20373 }
20374 arg1 = static_cast< int >(val1);
20375 ecode2 = SWIG_AsVal_int(obj1, &val2);
20376 if (!SWIG_IsOK(ecode2)) {
20377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
20378 }
20379 arg2 = static_cast< int >(val2);
20380 {
20381 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
20382 arg4 = (int)temp3;
20383 }
20384 if (obj3) {
20385 {
20386 if (obj3 != Py_None) {
20387 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
20388 arg6 = (int)temp5;
20389 }
20390 }
20391 }
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 {
20399 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
20400 }
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN int NullImage_set(PyObject *) {
20408 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
20409 return 1;
20410 }
20411
20412
20413 SWIGINTERN PyObject *NullImage_get(void) {
20414 PyObject *pyobj = 0;
20415
20416 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
20417 return pyobj;
20418 }
20419
20420
20421 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
20422 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
20423 return 1;
20424 }
20425
20426
20427 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
20428 PyObject *pyobj = 0;
20429
20430 {
20431 #if wxUSE_UNICODE
20432 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20433 #else
20434 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20435 #endif
20436 }
20437 return pyobj;
20438 }
20439
20440
20441 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
20442 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
20443 return 1;
20444 }
20445
20446
20447 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
20448 PyObject *pyobj = 0;
20449
20450 {
20451 #if wxUSE_UNICODE
20452 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20453 #else
20454 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20455 #endif
20456 }
20457 return pyobj;
20458 }
20459
20460
20461 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
20462 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
20463 return 1;
20464 }
20465
20466
20467 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
20468 PyObject *pyobj = 0;
20469
20470 {
20471 #if wxUSE_UNICODE
20472 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20473 #else
20474 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20475 #endif
20476 }
20477 return pyobj;
20478 }
20479
20480
20481 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
20482 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
20483 return 1;
20484 }
20485
20486
20487 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
20488 PyObject *pyobj = 0;
20489
20490 {
20491 #if wxUSE_UNICODE
20492 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20493 #else
20494 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20495 #endif
20496 }
20497 return pyobj;
20498 }
20499
20500
20501 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
20502 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
20503 return 1;
20504 }
20505
20506
20507 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
20508 PyObject *pyobj = 0;
20509
20510 {
20511 #if wxUSE_UNICODE
20512 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20513 #else
20514 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20515 #endif
20516 }
20517 return pyobj;
20518 }
20519
20520
20521 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20522 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20523 return 1;
20524 }
20525
20526
20527 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20528 PyObject *pyobj = 0;
20529
20530 {
20531 #if wxUSE_UNICODE
20532 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20533 #else
20534 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20535 #endif
20536 }
20537 return pyobj;
20538 }
20539
20540
20541 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20542 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20543 return 1;
20544 }
20545
20546
20547 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20548 PyObject *pyobj = 0;
20549
20550 {
20551 #if wxUSE_UNICODE
20552 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20553 #else
20554 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20555 #endif
20556 }
20557 return pyobj;
20558 }
20559
20560
20561 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20562 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20563 return 1;
20564 }
20565
20566
20567 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20568 PyObject *pyobj = 0;
20569
20570 {
20571 #if wxUSE_UNICODE
20572 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20573 #else
20574 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20575 #endif
20576 }
20577 return pyobj;
20578 }
20579
20580
20581 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20582 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20583 return 1;
20584 }
20585
20586
20587 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20588 PyObject *pyobj = 0;
20589
20590 {
20591 #if wxUSE_UNICODE
20592 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20593 #else
20594 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20595 #endif
20596 }
20597 return pyobj;
20598 }
20599
20600
20601 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20602 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20603 return 1;
20604 }
20605
20606
20607 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20608 PyObject *pyobj = 0;
20609
20610 {
20611 #if wxUSE_UNICODE
20612 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20613 #else
20614 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20615 #endif
20616 }
20617 return pyobj;
20618 }
20619
20620
20621 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20622 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20623 return 1;
20624 }
20625
20626
20627 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20628 PyObject *pyobj = 0;
20629
20630 {
20631 #if wxUSE_UNICODE
20632 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20633 #else
20634 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20635 #endif
20636 }
20637 return pyobj;
20638 }
20639
20640
20641 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20642 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20643 return 1;
20644 }
20645
20646
20647 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20648 PyObject *pyobj = 0;
20649
20650 {
20651 #if wxUSE_UNICODE
20652 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20653 #else
20654 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20655 #endif
20656 }
20657 return pyobj;
20658 }
20659
20660
20661 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20662 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20663 return 1;
20664 }
20665
20666
20667 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20668 PyObject *pyobj = 0;
20669
20670 {
20671 #if wxUSE_UNICODE
20672 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20673 #else
20674 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20675 #endif
20676 }
20677 return pyobj;
20678 }
20679
20680
20681 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20682 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20683 return 1;
20684 }
20685
20686
20687 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20688 PyObject *pyobj = 0;
20689
20690 {
20691 #if wxUSE_UNICODE
20692 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20693 #else
20694 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20695 #endif
20696 }
20697 return pyobj;
20698 }
20699
20700
20701 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20702 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20703 return 1;
20704 }
20705
20706
20707 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20708 PyObject *pyobj = 0;
20709
20710 {
20711 #if wxUSE_UNICODE
20712 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20713 #else
20714 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20715 #endif
20716 }
20717 return pyobj;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20722 PyObject *resultobj = 0;
20723 wxBMPHandler *result = 0 ;
20724
20725 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 result = (wxBMPHandler *)new wxBMPHandler();
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20740 PyObject *obj;
20741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20742 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20743 return SWIG_Py_Void();
20744 }
20745
20746 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20747 return SWIG_Python_InitShadowInstance(args);
20748 }
20749
20750 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20751 PyObject *resultobj = 0;
20752 wxICOHandler *result = 0 ;
20753
20754 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (wxICOHandler *)new wxICOHandler();
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20769 PyObject *obj;
20770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20771 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20772 return SWIG_Py_Void();
20773 }
20774
20775 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20776 return SWIG_Python_InitShadowInstance(args);
20777 }
20778
20779 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20780 PyObject *resultobj = 0;
20781 wxCURHandler *result = 0 ;
20782
20783 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 result = (wxCURHandler *)new wxCURHandler();
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20791 return resultobj;
20792 fail:
20793 return NULL;
20794 }
20795
20796
20797 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20798 PyObject *obj;
20799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20800 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20801 return SWIG_Py_Void();
20802 }
20803
20804 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20805 return SWIG_Python_InitShadowInstance(args);
20806 }
20807
20808 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20809 PyObject *resultobj = 0;
20810 wxANIHandler *result = 0 ;
20811
20812 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (wxANIHandler *)new wxANIHandler();
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 PyObject *obj;
20828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20829 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20830 return SWIG_Py_Void();
20831 }
20832
20833 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20834 return SWIG_Python_InitShadowInstance(args);
20835 }
20836
20837 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20838 PyObject *resultobj = 0;
20839 wxPNGHandler *result = 0 ;
20840
20841 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20842 {
20843 PyThreadState* __tstate = wxPyBeginAllowThreads();
20844 result = (wxPNGHandler *)new wxPNGHandler();
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20849 return resultobj;
20850 fail:
20851 return NULL;
20852 }
20853
20854
20855 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20856 PyObject *obj;
20857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20859 return SWIG_Py_Void();
20860 }
20861
20862 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 return SWIG_Python_InitShadowInstance(args);
20864 }
20865
20866 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20867 PyObject *resultobj = 0;
20868 wxGIFHandler *result = 0 ;
20869
20870 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 result = (wxGIFHandler *)new wxGIFHandler();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20885 PyObject *obj;
20886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20887 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20888 return SWIG_Py_Void();
20889 }
20890
20891 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20892 return SWIG_Python_InitShadowInstance(args);
20893 }
20894
20895 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20896 PyObject *resultobj = 0;
20897 wxPCXHandler *result = 0 ;
20898
20899 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20900 {
20901 PyThreadState* __tstate = wxPyBeginAllowThreads();
20902 result = (wxPCXHandler *)new wxPCXHandler();
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20914 PyObject *obj;
20915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20916 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20917 return SWIG_Py_Void();
20918 }
20919
20920 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20921 return SWIG_Python_InitShadowInstance(args);
20922 }
20923
20924 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20925 PyObject *resultobj = 0;
20926 wxJPEGHandler *result = 0 ;
20927
20928 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (wxJPEGHandler *)new wxJPEGHandler();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *obj;
20944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20945 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20946 return SWIG_Py_Void();
20947 }
20948
20949 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 return SWIG_Python_InitShadowInstance(args);
20951 }
20952
20953 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxPNMHandler *result = 0 ;
20956
20957 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (wxPNMHandler *)new wxPNMHandler();
20961 wxPyEndAllowThreads(__tstate);
20962 if (PyErr_Occurred()) SWIG_fail;
20963 }
20964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20972 PyObject *obj;
20973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20974 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20975 return SWIG_Py_Void();
20976 }
20977
20978 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 return SWIG_Python_InitShadowInstance(args);
20980 }
20981
20982 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20983 PyObject *resultobj = 0;
20984 wxXPMHandler *result = 0 ;
20985
20986 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (wxXPMHandler *)new wxXPMHandler();
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21001 PyObject *obj;
21002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21003 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
21004 return SWIG_Py_Void();
21005 }
21006
21007 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21008 return SWIG_Python_InitShadowInstance(args);
21009 }
21010
21011 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21012 PyObject *resultobj = 0;
21013 wxTIFFHandler *result = 0 ;
21014
21015 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
21016 {
21017 PyThreadState* __tstate = wxPyBeginAllowThreads();
21018 result = (wxTIFFHandler *)new wxTIFFHandler();
21019 wxPyEndAllowThreads(__tstate);
21020 if (PyErr_Occurred()) SWIG_fail;
21021 }
21022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *obj;
21031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21032 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
21033 return SWIG_Py_Void();
21034 }
21035
21036 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21037 return SWIG_Python_InitShadowInstance(args);
21038 }
21039
21040 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21041 PyObject *resultobj = 0;
21042 wxTGAHandler *result = 0 ;
21043
21044 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 result = (wxTGAHandler *)new wxTGAHandler();
21048 wxPyEndAllowThreads(__tstate);
21049 if (PyErr_Occurred()) SWIG_fail;
21050 }
21051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21059 PyObject *obj;
21060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21061 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
21062 return SWIG_Py_Void();
21063 }
21064
21065 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21066 return SWIG_Python_InitShadowInstance(args);
21067 }
21068
21069 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21070 PyObject *resultobj = 0;
21071 wxImage *arg1 = 0 ;
21072 wxImage *arg2 = 0 ;
21073 int arg3 = (int) 236 ;
21074 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
21075 bool result;
21076 void *argp1 = 0 ;
21077 int res1 = 0 ;
21078 void *argp2 = 0 ;
21079 int res2 = 0 ;
21080 int val3 ;
21081 int ecode3 = 0 ;
21082 int val4 ;
21083 int ecode4 = 0 ;
21084 PyObject * obj0 = 0 ;
21085 PyObject * obj1 = 0 ;
21086 PyObject * obj2 = 0 ;
21087 PyObject * obj3 = 0 ;
21088 char * kwnames[] = {
21089 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
21090 };
21091
21092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21096 }
21097 if (!argp1) {
21098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21099 }
21100 arg1 = reinterpret_cast< wxImage * >(argp1);
21101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
21102 if (!SWIG_IsOK(res2)) {
21103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21104 }
21105 if (!argp2) {
21106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21107 }
21108 arg2 = reinterpret_cast< wxImage * >(argp2);
21109 if (obj2) {
21110 ecode3 = SWIG_AsVal_int(obj2, &val3);
21111 if (!SWIG_IsOK(ecode3)) {
21112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
21113 }
21114 arg3 = static_cast< int >(val3);
21115 }
21116 if (obj3) {
21117 ecode4 = SWIG_AsVal_int(obj3, &val4);
21118 if (!SWIG_IsOK(ecode4)) {
21119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
21120 }
21121 arg4 = static_cast< int >(val4);
21122 }
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 {
21130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21131 }
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21139 PyObject *obj;
21140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21141 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
21142 return SWIG_Py_Void();
21143 }
21144
21145 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21146 PyObject *resultobj = 0;
21147 wxEvtHandler *result = 0 ;
21148
21149 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 result = (wxEvtHandler *)new wxEvtHandler();
21153 wxPyEndAllowThreads(__tstate);
21154 if (PyErr_Occurred()) SWIG_fail;
21155 }
21156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21164 PyObject *resultobj = 0;
21165 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21166 wxEvtHandler *result = 0 ;
21167 void *argp1 = 0 ;
21168 int res1 = 0 ;
21169 PyObject *swig_obj[1] ;
21170
21171 if (!args) SWIG_fail;
21172 swig_obj[0] = args;
21173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21174 if (!SWIG_IsOK(res1)) {
21175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21176 }
21177 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 result = (wxEvtHandler *)(arg1)->GetNextHandler();
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 {
21185 resultobj = wxPyMake_wxObject(result, 0);
21186 }
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21194 PyObject *resultobj = 0;
21195 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21196 wxEvtHandler *result = 0 ;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 PyObject *swig_obj[1] ;
21200
21201 if (!args) SWIG_fail;
21202 swig_obj[0] = args;
21203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21204 if (!SWIG_IsOK(res1)) {
21205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21206 }
21207 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 {
21215 resultobj = wxPyMake_wxObject(result, 0);
21216 }
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21224 PyObject *resultobj = 0;
21225 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21226 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21227 void *argp1 = 0 ;
21228 int res1 = 0 ;
21229 void *argp2 = 0 ;
21230 int res2 = 0 ;
21231 PyObject * obj0 = 0 ;
21232 PyObject * obj1 = 0 ;
21233 char * kwnames[] = {
21234 (char *) "self",(char *) "handler", NULL
21235 };
21236
21237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21239 if (!SWIG_IsOK(res1)) {
21240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21241 }
21242 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21244 if (!SWIG_IsOK(res2)) {
21245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21246 }
21247 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 (arg1)->SetNextHandler(arg2);
21251 wxPyEndAllowThreads(__tstate);
21252 if (PyErr_Occurred()) SWIG_fail;
21253 }
21254 resultobj = SWIG_Py_Void();
21255 return resultobj;
21256 fail:
21257 return NULL;
21258 }
21259
21260
21261 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21262 PyObject *resultobj = 0;
21263 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21264 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21265 void *argp1 = 0 ;
21266 int res1 = 0 ;
21267 void *argp2 = 0 ;
21268 int res2 = 0 ;
21269 PyObject * obj0 = 0 ;
21270 PyObject * obj1 = 0 ;
21271 char * kwnames[] = {
21272 (char *) "self",(char *) "handler", NULL
21273 };
21274
21275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21279 }
21280 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21282 if (!SWIG_IsOK(res2)) {
21283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21284 }
21285 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21286 {
21287 PyThreadState* __tstate = wxPyBeginAllowThreads();
21288 (arg1)->SetPreviousHandler(arg2);
21289 wxPyEndAllowThreads(__tstate);
21290 if (PyErr_Occurred()) SWIG_fail;
21291 }
21292 resultobj = SWIG_Py_Void();
21293 return resultobj;
21294 fail:
21295 return NULL;
21296 }
21297
21298
21299 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21300 PyObject *resultobj = 0;
21301 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21302 bool result;
21303 void *argp1 = 0 ;
21304 int res1 = 0 ;
21305 PyObject *swig_obj[1] ;
21306
21307 if (!args) SWIG_fail;
21308 swig_obj[0] = args;
21309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21310 if (!SWIG_IsOK(res1)) {
21311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21312 }
21313 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21314 {
21315 PyThreadState* __tstate = wxPyBeginAllowThreads();
21316 result = (bool)(arg1)->GetEvtHandlerEnabled();
21317 wxPyEndAllowThreads(__tstate);
21318 if (PyErr_Occurred()) SWIG_fail;
21319 }
21320 {
21321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21322 }
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21330 PyObject *resultobj = 0;
21331 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21332 bool arg2 ;
21333 void *argp1 = 0 ;
21334 int res1 = 0 ;
21335 bool val2 ;
21336 int ecode2 = 0 ;
21337 PyObject * obj0 = 0 ;
21338 PyObject * obj1 = 0 ;
21339 char * kwnames[] = {
21340 (char *) "self",(char *) "enabled", NULL
21341 };
21342
21343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
21344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21345 if (!SWIG_IsOK(res1)) {
21346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21347 }
21348 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21349 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21350 if (!SWIG_IsOK(ecode2)) {
21351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
21352 }
21353 arg2 = static_cast< bool >(val2);
21354 {
21355 PyThreadState* __tstate = wxPyBeginAllowThreads();
21356 (arg1)->SetEvtHandlerEnabled(arg2);
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 resultobj = SWIG_Py_Void();
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj = 0;
21369 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21370 wxEvent *arg2 = 0 ;
21371 bool result;
21372 void *argp1 = 0 ;
21373 int res1 = 0 ;
21374 void *argp2 = 0 ;
21375 int res2 = 0 ;
21376 PyObject * obj0 = 0 ;
21377 PyObject * obj1 = 0 ;
21378 char * kwnames[] = {
21379 (char *) "self",(char *) "event", NULL
21380 };
21381
21382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21384 if (!SWIG_IsOK(res1)) {
21385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21386 }
21387 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21388 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21389 if (!SWIG_IsOK(res2)) {
21390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21391 }
21392 if (!argp2) {
21393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21394 }
21395 arg2 = reinterpret_cast< wxEvent * >(argp2);
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (bool)(arg1)->ProcessEvent(*arg2);
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 {
21403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21404 }
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj = 0;
21413 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21414 wxEvent *arg2 = 0 ;
21415 void *argp1 = 0 ;
21416 int res1 = 0 ;
21417 void *argp2 = 0 ;
21418 int res2 = 0 ;
21419 PyObject * obj0 = 0 ;
21420 PyObject * obj1 = 0 ;
21421 char * kwnames[] = {
21422 (char *) "self",(char *) "event", NULL
21423 };
21424
21425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21429 }
21430 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21431 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21432 if (!SWIG_IsOK(res2)) {
21433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21434 }
21435 if (!argp2) {
21436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21437 }
21438 arg2 = reinterpret_cast< wxEvent * >(argp2);
21439 {
21440 PyThreadState* __tstate = wxPyBeginAllowThreads();
21441 (arg1)->AddPendingEvent(*arg2);
21442 wxPyEndAllowThreads(__tstate);
21443 if (PyErr_Occurred()) SWIG_fail;
21444 }
21445 resultobj = SWIG_Py_Void();
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21453 PyObject *resultobj = 0;
21454 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21455 void *argp1 = 0 ;
21456 int res1 = 0 ;
21457 PyObject *swig_obj[1] ;
21458
21459 if (!args) SWIG_fail;
21460 swig_obj[0] = args;
21461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21462 if (!SWIG_IsOK(res1)) {
21463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21464 }
21465 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21466 {
21467 PyThreadState* __tstate = wxPyBeginAllowThreads();
21468 (arg1)->ProcessPendingEvents();
21469 wxPyEndAllowThreads(__tstate);
21470 if (PyErr_Occurred()) SWIG_fail;
21471 }
21472 resultobj = SWIG_Py_Void();
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21480 PyObject *resultobj = 0;
21481 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21482 int arg2 ;
21483 int arg3 ;
21484 int arg4 ;
21485 PyObject *arg5 = (PyObject *) 0 ;
21486 void *argp1 = 0 ;
21487 int res1 = 0 ;
21488 int val2 ;
21489 int ecode2 = 0 ;
21490 int val3 ;
21491 int ecode3 = 0 ;
21492 int val4 ;
21493 int ecode4 = 0 ;
21494 PyObject * obj0 = 0 ;
21495 PyObject * obj1 = 0 ;
21496 PyObject * obj2 = 0 ;
21497 PyObject * obj3 = 0 ;
21498 PyObject * obj4 = 0 ;
21499 char * kwnames[] = {
21500 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21501 };
21502
21503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21507 }
21508 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21509 ecode2 = SWIG_AsVal_int(obj1, &val2);
21510 if (!SWIG_IsOK(ecode2)) {
21511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21512 }
21513 arg2 = static_cast< int >(val2);
21514 ecode3 = SWIG_AsVal_int(obj2, &val3);
21515 if (!SWIG_IsOK(ecode3)) {
21516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21517 }
21518 arg3 = static_cast< int >(val3);
21519 ecode4 = SWIG_AsVal_int(obj3, &val4);
21520 if (!SWIG_IsOK(ecode4)) {
21521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21522 }
21523 arg4 = static_cast< int >(val4);
21524 arg5 = obj4;
21525 {
21526 PyThreadState* __tstate = wxPyBeginAllowThreads();
21527 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21528 wxPyEndAllowThreads(__tstate);
21529 if (PyErr_Occurred()) SWIG_fail;
21530 }
21531 resultobj = SWIG_Py_Void();
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21539 PyObject *resultobj = 0;
21540 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21541 int arg2 ;
21542 int arg3 = (int) -1 ;
21543 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21544 bool result;
21545 void *argp1 = 0 ;
21546 int res1 = 0 ;
21547 int val2 ;
21548 int ecode2 = 0 ;
21549 int val3 ;
21550 int ecode3 = 0 ;
21551 int val4 ;
21552 int ecode4 = 0 ;
21553 PyObject * obj0 = 0 ;
21554 PyObject * obj1 = 0 ;
21555 PyObject * obj2 = 0 ;
21556 PyObject * obj3 = 0 ;
21557 char * kwnames[] = {
21558 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21559 };
21560
21561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21563 if (!SWIG_IsOK(res1)) {
21564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21565 }
21566 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21567 ecode2 = SWIG_AsVal_int(obj1, &val2);
21568 if (!SWIG_IsOK(ecode2)) {
21569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21570 }
21571 arg2 = static_cast< int >(val2);
21572 if (obj2) {
21573 ecode3 = SWIG_AsVal_int(obj2, &val3);
21574 if (!SWIG_IsOK(ecode3)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21576 }
21577 arg3 = static_cast< int >(val3);
21578 }
21579 if (obj3) {
21580 ecode4 = SWIG_AsVal_int(obj3, &val4);
21581 if (!SWIG_IsOK(ecode4)) {
21582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21583 }
21584 arg4 = static_cast< wxEventType >(val4);
21585 }
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21589 wxPyEndAllowThreads(__tstate);
21590 if (PyErr_Occurred()) SWIG_fail;
21591 }
21592 {
21593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21594 }
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21602 PyObject *resultobj = 0;
21603 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21604 PyObject *arg2 = (PyObject *) 0 ;
21605 bool arg3 = (bool) true ;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 bool val3 ;
21609 int ecode3 = 0 ;
21610 PyObject * obj0 = 0 ;
21611 PyObject * obj1 = 0 ;
21612 PyObject * obj2 = 0 ;
21613 char * kwnames[] = {
21614 (char *) "self",(char *) "_self",(char *) "incref", NULL
21615 };
21616
21617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21619 if (!SWIG_IsOK(res1)) {
21620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21621 }
21622 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21623 arg2 = obj1;
21624 if (obj2) {
21625 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21626 if (!SWIG_IsOK(ecode3)) {
21627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21628 }
21629 arg3 = static_cast< bool >(val3);
21630 }
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *obj;
21646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21647 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21648 return SWIG_Py_Void();
21649 }
21650
21651 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21652 return SWIG_Python_InitShadowInstance(args);
21653 }
21654
21655 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21656 PyObject *resultobj = 0;
21657 wxEventType result;
21658
21659 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 result = (wxEventType)wxNewEventType();
21663 wxPyEndAllowThreads(__tstate);
21664 if (PyErr_Occurred()) SWIG_fail;
21665 }
21666 resultobj = SWIG_From_int(static_cast< int >(result));
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 PyObject *resultobj = 0;
21675 wxEvent *arg1 = (wxEvent *) 0 ;
21676 void *argp1 = 0 ;
21677 int res1 = 0 ;
21678 PyObject *swig_obj[1] ;
21679
21680 if (!args) SWIG_fail;
21681 swig_obj[0] = args;
21682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21683 if (!SWIG_IsOK(res1)) {
21684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21685 }
21686 arg1 = reinterpret_cast< wxEvent * >(argp1);
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 delete arg1;
21690
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 resultobj = SWIG_Py_Void();
21695 return resultobj;
21696 fail:
21697 return NULL;
21698 }
21699
21700
21701 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21702 PyObject *resultobj = 0;
21703 wxEvent *arg1 = (wxEvent *) 0 ;
21704 wxEventType arg2 ;
21705 void *argp1 = 0 ;
21706 int res1 = 0 ;
21707 int val2 ;
21708 int ecode2 = 0 ;
21709 PyObject * obj0 = 0 ;
21710 PyObject * obj1 = 0 ;
21711 char * kwnames[] = {
21712 (char *) "self",(char *) "typ", NULL
21713 };
21714
21715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21717 if (!SWIG_IsOK(res1)) {
21718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21719 }
21720 arg1 = reinterpret_cast< wxEvent * >(argp1);
21721 ecode2 = SWIG_AsVal_int(obj1, &val2);
21722 if (!SWIG_IsOK(ecode2)) {
21723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21724 }
21725 arg2 = static_cast< wxEventType >(val2);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 (arg1)->SetEventType(arg2);
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *resultobj = 0;
21741 wxEvent *arg1 = (wxEvent *) 0 ;
21742 wxEventType result;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 PyObject *swig_obj[1] ;
21746
21747 if (!args) SWIG_fail;
21748 swig_obj[0] = args;
21749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21750 if (!SWIG_IsOK(res1)) {
21751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21752 }
21753 arg1 = reinterpret_cast< wxEvent * >(argp1);
21754 {
21755 PyThreadState* __tstate = wxPyBeginAllowThreads();
21756 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21757 wxPyEndAllowThreads(__tstate);
21758 if (PyErr_Occurred()) SWIG_fail;
21759 }
21760 resultobj = SWIG_From_int(static_cast< int >(result));
21761 return resultobj;
21762 fail:
21763 return NULL;
21764 }
21765
21766
21767 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21768 PyObject *resultobj = 0;
21769 wxEvent *arg1 = (wxEvent *) 0 ;
21770 wxObject *result = 0 ;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 PyObject *swig_obj[1] ;
21774
21775 if (!args) SWIG_fail;
21776 swig_obj[0] = args;
21777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21778 if (!SWIG_IsOK(res1)) {
21779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21780 }
21781 arg1 = reinterpret_cast< wxEvent * >(argp1);
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 {
21789 resultobj = wxPyMake_wxObject(result, (bool)0);
21790 }
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21798 PyObject *resultobj = 0;
21799 wxEvent *arg1 = (wxEvent *) 0 ;
21800 wxObject *arg2 = (wxObject *) 0 ;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 void *argp2 = 0 ;
21804 int res2 = 0 ;
21805 PyObject * obj0 = 0 ;
21806 PyObject * obj1 = 0 ;
21807 char * kwnames[] = {
21808 (char *) "self",(char *) "obj", NULL
21809 };
21810
21811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21813 if (!SWIG_IsOK(res1)) {
21814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21815 }
21816 arg1 = reinterpret_cast< wxEvent * >(argp1);
21817 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21818 if (!SWIG_IsOK(res2)) {
21819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21820 }
21821 arg2 = reinterpret_cast< wxObject * >(argp2);
21822 {
21823 PyThreadState* __tstate = wxPyBeginAllowThreads();
21824 (arg1)->SetEventObject(arg2);
21825 wxPyEndAllowThreads(__tstate);
21826 if (PyErr_Occurred()) SWIG_fail;
21827 }
21828 resultobj = SWIG_Py_Void();
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 PyObject *resultobj = 0;
21837 wxEvent *arg1 = (wxEvent *) 0 ;
21838 long result;
21839 void *argp1 = 0 ;
21840 int res1 = 0 ;
21841 PyObject *swig_obj[1] ;
21842
21843 if (!args) SWIG_fail;
21844 swig_obj[0] = args;
21845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21846 if (!SWIG_IsOK(res1)) {
21847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21848 }
21849 arg1 = reinterpret_cast< wxEvent * >(argp1);
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 resultobj = SWIG_From_long(static_cast< long >(result));
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj = 0;
21865 wxEvent *arg1 = (wxEvent *) 0 ;
21866 long arg2 = (long) 0 ;
21867 void *argp1 = 0 ;
21868 int res1 = 0 ;
21869 long val2 ;
21870 int ecode2 = 0 ;
21871 PyObject * obj0 = 0 ;
21872 PyObject * obj1 = 0 ;
21873 char * kwnames[] = {
21874 (char *) "self",(char *) "ts", NULL
21875 };
21876
21877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21879 if (!SWIG_IsOK(res1)) {
21880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21881 }
21882 arg1 = reinterpret_cast< wxEvent * >(argp1);
21883 if (obj1) {
21884 ecode2 = SWIG_AsVal_long(obj1, &val2);
21885 if (!SWIG_IsOK(ecode2)) {
21886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21887 }
21888 arg2 = static_cast< long >(val2);
21889 }
21890 {
21891 PyThreadState* __tstate = wxPyBeginAllowThreads();
21892 (arg1)->SetTimestamp(arg2);
21893 wxPyEndAllowThreads(__tstate);
21894 if (PyErr_Occurred()) SWIG_fail;
21895 }
21896 resultobj = SWIG_Py_Void();
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21904 PyObject *resultobj = 0;
21905 wxEvent *arg1 = (wxEvent *) 0 ;
21906 int result;
21907 void *argp1 = 0 ;
21908 int res1 = 0 ;
21909 PyObject *swig_obj[1] ;
21910
21911 if (!args) SWIG_fail;
21912 swig_obj[0] = args;
21913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21914 if (!SWIG_IsOK(res1)) {
21915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21916 }
21917 arg1 = reinterpret_cast< wxEvent * >(argp1);
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 result = (int)((wxEvent const *)arg1)->GetId();
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 resultobj = SWIG_From_int(static_cast< int >(result));
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21932 PyObject *resultobj = 0;
21933 wxEvent *arg1 = (wxEvent *) 0 ;
21934 int arg2 ;
21935 void *argp1 = 0 ;
21936 int res1 = 0 ;
21937 int val2 ;
21938 int ecode2 = 0 ;
21939 PyObject * obj0 = 0 ;
21940 PyObject * obj1 = 0 ;
21941 char * kwnames[] = {
21942 (char *) "self",(char *) "Id", NULL
21943 };
21944
21945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21949 }
21950 arg1 = reinterpret_cast< wxEvent * >(argp1);
21951 ecode2 = SWIG_AsVal_int(obj1, &val2);
21952 if (!SWIG_IsOK(ecode2)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21954 }
21955 arg2 = static_cast< int >(val2);
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 (arg1)->SetId(arg2);
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 resultobj = SWIG_Py_Void();
21963 return resultobj;
21964 fail:
21965 return NULL;
21966 }
21967
21968
21969 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21970 PyObject *resultobj = 0;
21971 wxEvent *arg1 = (wxEvent *) 0 ;
21972 bool result;
21973 void *argp1 = 0 ;
21974 int res1 = 0 ;
21975 PyObject *swig_obj[1] ;
21976
21977 if (!args) SWIG_fail;
21978 swig_obj[0] = args;
21979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21980 if (!SWIG_IsOK(res1)) {
21981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21982 }
21983 arg1 = reinterpret_cast< wxEvent * >(argp1);
21984 {
21985 PyThreadState* __tstate = wxPyBeginAllowThreads();
21986 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 {
21991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21992 }
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22000 PyObject *resultobj = 0;
22001 wxEvent *arg1 = (wxEvent *) 0 ;
22002 bool arg2 = (bool) true ;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 bool val2 ;
22006 int ecode2 = 0 ;
22007 PyObject * obj0 = 0 ;
22008 PyObject * obj1 = 0 ;
22009 char * kwnames[] = {
22010 (char *) "self",(char *) "skip", NULL
22011 };
22012
22013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
22014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
22017 }
22018 arg1 = reinterpret_cast< wxEvent * >(argp1);
22019 if (obj1) {
22020 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22021 if (!SWIG_IsOK(ecode2)) {
22022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
22023 }
22024 arg2 = static_cast< bool >(val2);
22025 }
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 (arg1)->Skip(arg2);
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 resultobj = SWIG_Py_Void();
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxEvent *arg1 = (wxEvent *) 0 ;
22042 bool result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
22052 }
22053 arg1 = reinterpret_cast< wxEvent * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)((wxEvent const *)arg1)->GetSkipped();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxEvent *arg1 = (wxEvent *) 0 ;
22072 bool result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22100 PyObject *resultobj = 0;
22101 wxEvent *arg1 = (wxEvent *) 0 ;
22102 int result;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 PyObject *swig_obj[1] ;
22106
22107 if (!args) SWIG_fail;
22108 swig_obj[0] = args;
22109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22112 }
22113 arg1 = reinterpret_cast< wxEvent * >(argp1);
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (int)(arg1)->StopPropagation();
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 resultobj = SWIG_From_int(static_cast< int >(result));
22121 return resultobj;
22122 fail:
22123 return NULL;
22124 }
22125
22126
22127 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22128 PyObject *resultobj = 0;
22129 wxEvent *arg1 = (wxEvent *) 0 ;
22130 int arg2 ;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 int val2 ;
22134 int ecode2 = 0 ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 char * kwnames[] = {
22138 (char *) "self",(char *) "propagationLevel", NULL
22139 };
22140
22141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
22142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22145 }
22146 arg1 = reinterpret_cast< wxEvent * >(argp1);
22147 ecode2 = SWIG_AsVal_int(obj1, &val2);
22148 if (!SWIG_IsOK(ecode2)) {
22149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
22150 }
22151 arg2 = static_cast< int >(val2);
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 (arg1)->ResumePropagation(arg2);
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = SWIG_Py_Void();
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxEvent *arg1 = (wxEvent *) 0 ;
22168 wxEvent *result = 0 ;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 PyObject *swig_obj[1] ;
22172
22173 if (!args) SWIG_fail;
22174 swig_obj[0] = args;
22175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
22178 }
22179 arg1 = reinterpret_cast< wxEvent * >(argp1);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (wxEvent *)(arg1)->Clone();
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22194 PyObject *obj;
22195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22196 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
22197 return SWIG_Py_Void();
22198 }
22199
22200 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22201 PyObject *resultobj = 0;
22202 wxEvent *arg1 = 0 ;
22203 wxPropagationDisabler *result = 0 ;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 PyObject * obj0 = 0 ;
22207 char * kwnames[] = {
22208 (char *) "event", NULL
22209 };
22210
22211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
22212 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22213 if (!SWIG_IsOK(res1)) {
22214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22215 }
22216 if (!argp1) {
22217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22218 }
22219 arg1 = reinterpret_cast< wxEvent * >(argp1);
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22234 PyObject *resultobj = 0;
22235 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
22236 void *argp1 = 0 ;
22237 int res1 = 0 ;
22238 PyObject *swig_obj[1] ;
22239
22240 if (!args) SWIG_fail;
22241 swig_obj[0] = args;
22242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
22243 if (!SWIG_IsOK(res1)) {
22244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
22245 }
22246 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 delete arg1;
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 resultobj = SWIG_Py_Void();
22255 return resultobj;
22256 fail:
22257 return NULL;
22258 }
22259
22260
22261 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22262 PyObject *obj;
22263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22264 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
22265 return SWIG_Py_Void();
22266 }
22267
22268 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22269 return SWIG_Python_InitShadowInstance(args);
22270 }
22271
22272 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22273 PyObject *resultobj = 0;
22274 wxEvent *arg1 = 0 ;
22275 wxPropagateOnce *result = 0 ;
22276 void *argp1 = 0 ;
22277 int res1 = 0 ;
22278 PyObject * obj0 = 0 ;
22279 char * kwnames[] = {
22280 (char *) "event", NULL
22281 };
22282
22283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
22284 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22285 if (!SWIG_IsOK(res1)) {
22286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22287 }
22288 if (!argp1) {
22289 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22290 }
22291 arg1 = reinterpret_cast< wxEvent * >(argp1);
22292 {
22293 PyThreadState* __tstate = wxPyBeginAllowThreads();
22294 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22306 PyObject *resultobj = 0;
22307 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
22308 void *argp1 = 0 ;
22309 int res1 = 0 ;
22310 PyObject *swig_obj[1] ;
22311
22312 if (!args) SWIG_fail;
22313 swig_obj[0] = args;
22314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
22315 if (!SWIG_IsOK(res1)) {
22316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
22317 }
22318 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
22319 {
22320 PyThreadState* __tstate = wxPyBeginAllowThreads();
22321 delete arg1;
22322
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_Py_Void();
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22334 PyObject *obj;
22335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22336 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
22337 return SWIG_Py_Void();
22338 }
22339
22340 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22341 return SWIG_Python_InitShadowInstance(args);
22342 }
22343
22344 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22345 PyObject *resultobj = 0;
22346 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22347 int arg2 = (int) 0 ;
22348 wxCommandEvent *result = 0 ;
22349 int val1 ;
22350 int ecode1 = 0 ;
22351 int val2 ;
22352 int ecode2 = 0 ;
22353 PyObject * obj0 = 0 ;
22354 PyObject * obj1 = 0 ;
22355 char * kwnames[] = {
22356 (char *) "commandType",(char *) "winid", NULL
22357 };
22358
22359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22360 if (obj0) {
22361 ecode1 = SWIG_AsVal_int(obj0, &val1);
22362 if (!SWIG_IsOK(ecode1)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22364 }
22365 arg1 = static_cast< wxEventType >(val1);
22366 }
22367 if (obj1) {
22368 ecode2 = SWIG_AsVal_int(obj1, &val2);
22369 if (!SWIG_IsOK(ecode2)) {
22370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
22371 }
22372 arg2 = static_cast< int >(val2);
22373 }
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
22377 wxPyEndAllowThreads(__tstate);
22378 if (PyErr_Occurred()) SWIG_fail;
22379 }
22380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22388 PyObject *resultobj = 0;
22389 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22390 int result;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 PyObject *swig_obj[1] ;
22394
22395 if (!args) SWIG_fail;
22396 swig_obj[0] = args;
22397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22398 if (!SWIG_IsOK(res1)) {
22399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22400 }
22401 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 resultobj = SWIG_From_int(static_cast< int >(result));
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22416 PyObject *resultobj = 0;
22417 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22418 wxString *arg2 = 0 ;
22419 void *argp1 = 0 ;
22420 int res1 = 0 ;
22421 bool temp2 = false ;
22422 PyObject * obj0 = 0 ;
22423 PyObject * obj1 = 0 ;
22424 char * kwnames[] = {
22425 (char *) "self",(char *) "s", NULL
22426 };
22427
22428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
22429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22430 if (!SWIG_IsOK(res1)) {
22431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22432 }
22433 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22434 {
22435 arg2 = wxString_in_helper(obj1);
22436 if (arg2 == NULL) SWIG_fail;
22437 temp2 = true;
22438 }
22439 {
22440 PyThreadState* __tstate = wxPyBeginAllowThreads();
22441 (arg1)->SetString((wxString const &)*arg2);
22442 wxPyEndAllowThreads(__tstate);
22443 if (PyErr_Occurred()) SWIG_fail;
22444 }
22445 resultobj = SWIG_Py_Void();
22446 {
22447 if (temp2)
22448 delete arg2;
22449 }
22450 return resultobj;
22451 fail:
22452 {
22453 if (temp2)
22454 delete arg2;
22455 }
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22463 wxString result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22473 }
22474 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = ((wxCommandEvent const *)arg1)->GetString();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 {
22482 #if wxUSE_UNICODE
22483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22484 #else
22485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22486 #endif
22487 }
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22497 bool result;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 PyObject *swig_obj[1] ;
22501
22502 if (!args) SWIG_fail;
22503 swig_obj[0] = args;
22504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22507 }
22508 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22509 {
22510 PyThreadState* __tstate = wxPyBeginAllowThreads();
22511 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 {
22516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22517 }
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22527 bool result;
22528 void *argp1 = 0 ;
22529 int res1 = 0 ;
22530 PyObject *swig_obj[1] ;
22531
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22537 }
22538 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 {
22546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22547 }
22548 return resultobj;
22549 fail:
22550 return NULL;
22551 }
22552
22553
22554 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22555 PyObject *resultobj = 0;
22556 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22557 long arg2 ;
22558 void *argp1 = 0 ;
22559 int res1 = 0 ;
22560 long val2 ;
22561 int ecode2 = 0 ;
22562 PyObject * obj0 = 0 ;
22563 PyObject * obj1 = 0 ;
22564 char * kwnames[] = {
22565 (char *) "self",(char *) "extraLong", NULL
22566 };
22567
22568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22570 if (!SWIG_IsOK(res1)) {
22571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22572 }
22573 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22574 ecode2 = SWIG_AsVal_long(obj1, &val2);
22575 if (!SWIG_IsOK(ecode2)) {
22576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22577 }
22578 arg2 = static_cast< long >(val2);
22579 {
22580 PyThreadState* __tstate = wxPyBeginAllowThreads();
22581 (arg1)->SetExtraLong(arg2);
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 resultobj = SWIG_Py_Void();
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 PyObject *resultobj = 0;
22594 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22595 long result;
22596 void *argp1 = 0 ;
22597 int res1 = 0 ;
22598 PyObject *swig_obj[1] ;
22599
22600 if (!args) SWIG_fail;
22601 swig_obj[0] = args;
22602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22605 }
22606 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22607 {
22608 PyThreadState* __tstate = wxPyBeginAllowThreads();
22609 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22610 wxPyEndAllowThreads(__tstate);
22611 if (PyErr_Occurred()) SWIG_fail;
22612 }
22613 resultobj = SWIG_From_long(static_cast< long >(result));
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22621 PyObject *resultobj = 0;
22622 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22623 int arg2 ;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 int val2 ;
22627 int ecode2 = 0 ;
22628 PyObject * obj0 = 0 ;
22629 PyObject * obj1 = 0 ;
22630 char * kwnames[] = {
22631 (char *) "self",(char *) "i", NULL
22632 };
22633
22634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22638 }
22639 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22640 ecode2 = SWIG_AsVal_int(obj1, &val2);
22641 if (!SWIG_IsOK(ecode2)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22643 }
22644 arg2 = static_cast< int >(val2);
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 (arg1)->SetInt(arg2);
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_Py_Void();
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22659 PyObject *resultobj = 0;
22660 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22661 int result;
22662 void *argp1 = 0 ;
22663 int res1 = 0 ;
22664 PyObject *swig_obj[1] ;
22665
22666 if (!args) SWIG_fail;
22667 swig_obj[0] = args;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22671 }
22672 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_From_int(static_cast< int >(result));
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *resultobj = 0;
22688 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22689 PyObject *result = 0 ;
22690 void *argp1 = 0 ;
22691 int res1 = 0 ;
22692 PyObject *swig_obj[1] ;
22693
22694 if (!args) SWIG_fail;
22695 swig_obj[0] = args;
22696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22697 if (!SWIG_IsOK(res1)) {
22698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22699 }
22700 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = result;
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22715 PyObject *resultobj = 0;
22716 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22717 PyObject *arg2 = (PyObject *) 0 ;
22718 void *argp1 = 0 ;
22719 int res1 = 0 ;
22720 PyObject * obj0 = 0 ;
22721 PyObject * obj1 = 0 ;
22722 char * kwnames[] = {
22723 (char *) "self",(char *) "clientData", NULL
22724 };
22725
22726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22728 if (!SWIG_IsOK(res1)) {
22729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22730 }
22731 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22732 arg2 = obj1;
22733 {
22734 PyThreadState* __tstate = wxPyBeginAllowThreads();
22735 wxCommandEvent_SetClientData(arg1,arg2);
22736 wxPyEndAllowThreads(__tstate);
22737 if (PyErr_Occurred()) SWIG_fail;
22738 }
22739 resultobj = SWIG_Py_Void();
22740 return resultobj;
22741 fail:
22742 return NULL;
22743 }
22744
22745
22746 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747 PyObject *resultobj = 0;
22748 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22749 wxEvent *result = 0 ;
22750 void *argp1 = 0 ;
22751 int res1 = 0 ;
22752 PyObject *swig_obj[1] ;
22753
22754 if (!args) SWIG_fail;
22755 swig_obj[0] = args;
22756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22757 if (!SWIG_IsOK(res1)) {
22758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22759 }
22760 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22761 {
22762 PyThreadState* __tstate = wxPyBeginAllowThreads();
22763 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22764 wxPyEndAllowThreads(__tstate);
22765 if (PyErr_Occurred()) SWIG_fail;
22766 }
22767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22768 return resultobj;
22769 fail:
22770 return NULL;
22771 }
22772
22773
22774 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22775 PyObject *obj;
22776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22777 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22778 return SWIG_Py_Void();
22779 }
22780
22781 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22782 return SWIG_Python_InitShadowInstance(args);
22783 }
22784
22785 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22786 PyObject *resultobj = 0;
22787 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22788 int arg2 = (int) 0 ;
22789 wxNotifyEvent *result = 0 ;
22790 int val1 ;
22791 int ecode1 = 0 ;
22792 int val2 ;
22793 int ecode2 = 0 ;
22794 PyObject * obj0 = 0 ;
22795 PyObject * obj1 = 0 ;
22796 char * kwnames[] = {
22797 (char *) "commandType",(char *) "winid", NULL
22798 };
22799
22800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22801 if (obj0) {
22802 ecode1 = SWIG_AsVal_int(obj0, &val1);
22803 if (!SWIG_IsOK(ecode1)) {
22804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22805 }
22806 arg1 = static_cast< wxEventType >(val1);
22807 }
22808 if (obj1) {
22809 ecode2 = SWIG_AsVal_int(obj1, &val2);
22810 if (!SWIG_IsOK(ecode2)) {
22811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22812 }
22813 arg2 = static_cast< int >(val2);
22814 }
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22829 PyObject *resultobj = 0;
22830 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22831 void *argp1 = 0 ;
22832 int res1 = 0 ;
22833 PyObject *swig_obj[1] ;
22834
22835 if (!args) SWIG_fail;
22836 swig_obj[0] = args;
22837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22838 if (!SWIG_IsOK(res1)) {
22839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22840 }
22841 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22842 {
22843 PyThreadState* __tstate = wxPyBeginAllowThreads();
22844 (arg1)->Veto();
22845 wxPyEndAllowThreads(__tstate);
22846 if (PyErr_Occurred()) SWIG_fail;
22847 }
22848 resultobj = SWIG_Py_Void();
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 PyObject *swig_obj[1] ;
22861
22862 if (!args) SWIG_fail;
22863 swig_obj[0] = args;
22864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22865 if (!SWIG_IsOK(res1)) {
22866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22867 }
22868 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22869 {
22870 PyThreadState* __tstate = wxPyBeginAllowThreads();
22871 (arg1)->Allow();
22872 wxPyEndAllowThreads(__tstate);
22873 if (PyErr_Occurred()) SWIG_fail;
22874 }
22875 resultobj = SWIG_Py_Void();
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22883 PyObject *resultobj = 0;
22884 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22885 bool result;
22886 void *argp1 = 0 ;
22887 int res1 = 0 ;
22888 PyObject *swig_obj[1] ;
22889
22890 if (!args) SWIG_fail;
22891 swig_obj[0] = args;
22892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = (bool)(arg1)->IsAllowed();
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 {
22904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22905 }
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22913 PyObject *obj;
22914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22915 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22916 return SWIG_Py_Void();
22917 }
22918
22919 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22920 return SWIG_Python_InitShadowInstance(args);
22921 }
22922
22923 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22924 PyObject *resultobj = 0;
22925 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22926 int arg2 = (int) 0 ;
22927 int arg3 = (int) 0 ;
22928 int arg4 = (int) 0 ;
22929 wxScrollEvent *result = 0 ;
22930 int val1 ;
22931 int ecode1 = 0 ;
22932 int val2 ;
22933 int ecode2 = 0 ;
22934 int val3 ;
22935 int ecode3 = 0 ;
22936 int val4 ;
22937 int ecode4 = 0 ;
22938 PyObject * obj0 = 0 ;
22939 PyObject * obj1 = 0 ;
22940 PyObject * obj2 = 0 ;
22941 PyObject * obj3 = 0 ;
22942 char * kwnames[] = {
22943 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22944 };
22945
22946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22947 if (obj0) {
22948 ecode1 = SWIG_AsVal_int(obj0, &val1);
22949 if (!SWIG_IsOK(ecode1)) {
22950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22951 }
22952 arg1 = static_cast< wxEventType >(val1);
22953 }
22954 if (obj1) {
22955 ecode2 = SWIG_AsVal_int(obj1, &val2);
22956 if (!SWIG_IsOK(ecode2)) {
22957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22958 }
22959 arg2 = static_cast< int >(val2);
22960 }
22961 if (obj2) {
22962 ecode3 = SWIG_AsVal_int(obj2, &val3);
22963 if (!SWIG_IsOK(ecode3)) {
22964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22965 }
22966 arg3 = static_cast< int >(val3);
22967 }
22968 if (obj3) {
22969 ecode4 = SWIG_AsVal_int(obj3, &val4);
22970 if (!SWIG_IsOK(ecode4)) {
22971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22972 }
22973 arg4 = static_cast< int >(val4);
22974 }
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22978 wxPyEndAllowThreads(__tstate);
22979 if (PyErr_Occurred()) SWIG_fail;
22980 }
22981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22989 PyObject *resultobj = 0;
22990 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22991 int result;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 PyObject *swig_obj[1] ;
22995
22996 if (!args) SWIG_fail;
22997 swig_obj[0] = args;
22998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22999 if (!SWIG_IsOK(res1)) {
23000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23001 }
23002 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
23006 wxPyEndAllowThreads(__tstate);
23007 if (PyErr_Occurred()) SWIG_fail;
23008 }
23009 resultobj = SWIG_From_int(static_cast< int >(result));
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23019 int result;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 PyObject *swig_obj[1] ;
23023
23024 if (!args) SWIG_fail;
23025 swig_obj[0] = args;
23026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23027 if (!SWIG_IsOK(res1)) {
23028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23029 }
23030 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 resultobj = SWIG_From_int(static_cast< int >(result));
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23045 PyObject *resultobj = 0;
23046 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23047 int arg2 ;
23048 void *argp1 = 0 ;
23049 int res1 = 0 ;
23050 int val2 ;
23051 int ecode2 = 0 ;
23052 PyObject * obj0 = 0 ;
23053 PyObject * obj1 = 0 ;
23054 char * kwnames[] = {
23055 (char *) "self",(char *) "orient", NULL
23056 };
23057
23058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23060 if (!SWIG_IsOK(res1)) {
23061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23062 }
23063 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23064 ecode2 = SWIG_AsVal_int(obj1, &val2);
23065 if (!SWIG_IsOK(ecode2)) {
23066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23067 }
23068 arg2 = static_cast< int >(val2);
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 (arg1)->SetOrientation(arg2);
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 resultobj = SWIG_Py_Void();
23076 return resultobj;
23077 fail:
23078 return NULL;
23079 }
23080
23081
23082 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj = 0;
23084 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23085 int arg2 ;
23086 void *argp1 = 0 ;
23087 int res1 = 0 ;
23088 int val2 ;
23089 int ecode2 = 0 ;
23090 PyObject * obj0 = 0 ;
23091 PyObject * obj1 = 0 ;
23092 char * kwnames[] = {
23093 (char *) "self",(char *) "pos", NULL
23094 };
23095
23096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23098 if (!SWIG_IsOK(res1)) {
23099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23100 }
23101 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23102 ecode2 = SWIG_AsVal_int(obj1, &val2);
23103 if (!SWIG_IsOK(ecode2)) {
23104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23105 }
23106 arg2 = static_cast< int >(val2);
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 (arg1)->SetPosition(arg2);
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 resultobj = SWIG_Py_Void();
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23121 PyObject *obj;
23122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23123 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
23124 return SWIG_Py_Void();
23125 }
23126
23127 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23128 return SWIG_Python_InitShadowInstance(args);
23129 }
23130
23131 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23132 PyObject *resultobj = 0;
23133 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23134 int arg2 = (int) 0 ;
23135 int arg3 = (int) 0 ;
23136 wxScrollWinEvent *result = 0 ;
23137 int val1 ;
23138 int ecode1 = 0 ;
23139 int val2 ;
23140 int ecode2 = 0 ;
23141 int val3 ;
23142 int ecode3 = 0 ;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 PyObject * obj2 = 0 ;
23146 char * kwnames[] = {
23147 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
23148 };
23149
23150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23151 if (obj0) {
23152 ecode1 = SWIG_AsVal_int(obj0, &val1);
23153 if (!SWIG_IsOK(ecode1)) {
23154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23155 }
23156 arg1 = static_cast< wxEventType >(val1);
23157 }
23158 if (obj1) {
23159 ecode2 = SWIG_AsVal_int(obj1, &val2);
23160 if (!SWIG_IsOK(ecode2)) {
23161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
23162 }
23163 arg2 = static_cast< int >(val2);
23164 }
23165 if (obj2) {
23166 ecode3 = SWIG_AsVal_int(obj2, &val3);
23167 if (!SWIG_IsOK(ecode3)) {
23168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
23169 }
23170 arg3 = static_cast< int >(val3);
23171 }
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
23179 return resultobj;
23180 fail:
23181 return NULL;
23182 }
23183
23184
23185 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23186 PyObject *resultobj = 0;
23187 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23188 int result;
23189 void *argp1 = 0 ;
23190 int res1 = 0 ;
23191 PyObject *swig_obj[1] ;
23192
23193 if (!args) SWIG_fail;
23194 swig_obj[0] = args;
23195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23196 if (!SWIG_IsOK(res1)) {
23197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23198 }
23199 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 resultobj = SWIG_From_int(static_cast< int >(result));
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23214 PyObject *resultobj = 0;
23215 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23216 int result;
23217 void *argp1 = 0 ;
23218 int res1 = 0 ;
23219 PyObject *swig_obj[1] ;
23220
23221 if (!args) SWIG_fail;
23222 swig_obj[0] = args;
23223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23224 if (!SWIG_IsOK(res1)) {
23225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23226 }
23227 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23228 {
23229 PyThreadState* __tstate = wxPyBeginAllowThreads();
23230 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 resultobj = SWIG_From_int(static_cast< int >(result));
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23244 int arg2 ;
23245 void *argp1 = 0 ;
23246 int res1 = 0 ;
23247 int val2 ;
23248 int ecode2 = 0 ;
23249 PyObject * obj0 = 0 ;
23250 PyObject * obj1 = 0 ;
23251 char * kwnames[] = {
23252 (char *) "self",(char *) "orient", NULL
23253 };
23254
23255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23257 if (!SWIG_IsOK(res1)) {
23258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23259 }
23260 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23261 ecode2 = SWIG_AsVal_int(obj1, &val2);
23262 if (!SWIG_IsOK(ecode2)) {
23263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23264 }
23265 arg2 = static_cast< int >(val2);
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 (arg1)->SetOrientation(arg2);
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 resultobj = SWIG_Py_Void();
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj = 0;
23281 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23282 int arg2 ;
23283 void *argp1 = 0 ;
23284 int res1 = 0 ;
23285 int val2 ;
23286 int ecode2 = 0 ;
23287 PyObject * obj0 = 0 ;
23288 PyObject * obj1 = 0 ;
23289 char * kwnames[] = {
23290 (char *) "self",(char *) "pos", NULL
23291 };
23292
23293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23295 if (!SWIG_IsOK(res1)) {
23296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23297 }
23298 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23299 ecode2 = SWIG_AsVal_int(obj1, &val2);
23300 if (!SWIG_IsOK(ecode2)) {
23301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23302 }
23303 arg2 = static_cast< int >(val2);
23304 {
23305 PyThreadState* __tstate = wxPyBeginAllowThreads();
23306 (arg1)->SetPosition(arg2);
23307 wxPyEndAllowThreads(__tstate);
23308 if (PyErr_Occurred()) SWIG_fail;
23309 }
23310 resultobj = SWIG_Py_Void();
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23318 PyObject *obj;
23319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23320 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
23321 return SWIG_Py_Void();
23322 }
23323
23324 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23325 return SWIG_Python_InitShadowInstance(args);
23326 }
23327
23328 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj = 0;
23330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23331 wxMouseEvent *result = 0 ;
23332 int val1 ;
23333 int ecode1 = 0 ;
23334 PyObject * obj0 = 0 ;
23335 char * kwnames[] = {
23336 (char *) "mouseType", NULL
23337 };
23338
23339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
23340 if (obj0) {
23341 ecode1 = SWIG_AsVal_int(obj0, &val1);
23342 if (!SWIG_IsOK(ecode1)) {
23343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23344 }
23345 arg1 = static_cast< wxEventType >(val1);
23346 }
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = (wxMouseEvent *)new wxMouseEvent(arg1);
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 PyObject *resultobj = 0;
23362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23363 bool result;
23364 void *argp1 = 0 ;
23365 int res1 = 0 ;
23366 PyObject *swig_obj[1] ;
23367
23368 if (!args) SWIG_fail;
23369 swig_obj[0] = args;
23370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23371 if (!SWIG_IsOK(res1)) {
23372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23373 }
23374 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 {
23382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23383 }
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj = 0;
23392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23393 int arg2 = (int) wxMOUSE_BTN_ANY ;
23394 bool result;
23395 void *argp1 = 0 ;
23396 int res1 = 0 ;
23397 int val2 ;
23398 int ecode2 = 0 ;
23399 PyObject * obj0 = 0 ;
23400 PyObject * obj1 = 0 ;
23401 char * kwnames[] = {
23402 (char *) "self",(char *) "but", NULL
23403 };
23404
23405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
23406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23409 }
23410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23411 if (obj1) {
23412 ecode2 = SWIG_AsVal_int(obj1, &val2);
23413 if (!SWIG_IsOK(ecode2)) {
23414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
23415 }
23416 arg2 = static_cast< int >(val2);
23417 }
23418 {
23419 PyThreadState* __tstate = wxPyBeginAllowThreads();
23420 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
23421 wxPyEndAllowThreads(__tstate);
23422 if (PyErr_Occurred()) SWIG_fail;
23423 }
23424 {
23425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23426 }
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23434 PyObject *resultobj = 0;
23435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23436 int arg2 = (int) wxMOUSE_BTN_ANY ;
23437 bool result;
23438 void *argp1 = 0 ;
23439 int res1 = 0 ;
23440 int val2 ;
23441 int ecode2 = 0 ;
23442 PyObject * obj0 = 0 ;
23443 PyObject * obj1 = 0 ;
23444 char * kwnames[] = {
23445 (char *) "self",(char *) "but", NULL
23446 };
23447
23448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
23449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23450 if (!SWIG_IsOK(res1)) {
23451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23452 }
23453 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23454 if (obj1) {
23455 ecode2 = SWIG_AsVal_int(obj1, &val2);
23456 if (!SWIG_IsOK(ecode2)) {
23457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
23458 }
23459 arg2 = static_cast< int >(val2);
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
23464 wxPyEndAllowThreads(__tstate);
23465 if (PyErr_Occurred()) SWIG_fail;
23466 }
23467 {
23468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23469 }
23470 return resultobj;
23471 fail:
23472 return NULL;
23473 }
23474
23475
23476 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23477 PyObject *resultobj = 0;
23478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23479 int arg2 = (int) wxMOUSE_BTN_ANY ;
23480 bool result;
23481 void *argp1 = 0 ;
23482 int res1 = 0 ;
23483 int val2 ;
23484 int ecode2 = 0 ;
23485 PyObject * obj0 = 0 ;
23486 PyObject * obj1 = 0 ;
23487 char * kwnames[] = {
23488 (char *) "self",(char *) "but", NULL
23489 };
23490
23491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
23492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23493 if (!SWIG_IsOK(res1)) {
23494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23495 }
23496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23497 if (obj1) {
23498 ecode2 = SWIG_AsVal_int(obj1, &val2);
23499 if (!SWIG_IsOK(ecode2)) {
23500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23501 }
23502 arg2 = static_cast< int >(val2);
23503 }
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 {
23511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23512 }
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23520 PyObject *resultobj = 0;
23521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23522 int arg2 ;
23523 bool result;
23524 void *argp1 = 0 ;
23525 int res1 = 0 ;
23526 int val2 ;
23527 int ecode2 = 0 ;
23528 PyObject * obj0 = 0 ;
23529 PyObject * obj1 = 0 ;
23530 char * kwnames[] = {
23531 (char *) "self",(char *) "button", NULL
23532 };
23533
23534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23536 if (!SWIG_IsOK(res1)) {
23537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23538 }
23539 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23540 ecode2 = SWIG_AsVal_int(obj1, &val2);
23541 if (!SWIG_IsOK(ecode2)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23543 }
23544 arg2 = static_cast< int >(val2);
23545 {
23546 PyThreadState* __tstate = wxPyBeginAllowThreads();
23547 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23548 wxPyEndAllowThreads(__tstate);
23549 if (PyErr_Occurred()) SWIG_fail;
23550 }
23551 {
23552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23553 }
23554 return resultobj;
23555 fail:
23556 return NULL;
23557 }
23558
23559
23560 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23561 PyObject *resultobj = 0;
23562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23563 int arg2 ;
23564 bool result;
23565 void *argp1 = 0 ;
23566 int res1 = 0 ;
23567 int val2 ;
23568 int ecode2 = 0 ;
23569 PyObject * obj0 = 0 ;
23570 PyObject * obj1 = 0 ;
23571 char * kwnames[] = {
23572 (char *) "self",(char *) "but", NULL
23573 };
23574
23575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23577 if (!SWIG_IsOK(res1)) {
23578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23579 }
23580 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23581 ecode2 = SWIG_AsVal_int(obj1, &val2);
23582 if (!SWIG_IsOK(ecode2)) {
23583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23584 }
23585 arg2 = static_cast< int >(val2);
23586 {
23587 PyThreadState* __tstate = wxPyBeginAllowThreads();
23588 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23589 wxPyEndAllowThreads(__tstate);
23590 if (PyErr_Occurred()) SWIG_fail;
23591 }
23592 {
23593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23594 }
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23602 PyObject *resultobj = 0;
23603 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23604 int result;
23605 void *argp1 = 0 ;
23606 int res1 = 0 ;
23607 PyObject *swig_obj[1] ;
23608
23609 if (!args) SWIG_fail;
23610 swig_obj[0] = args;
23611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23612 if (!SWIG_IsOK(res1)) {
23613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23614 }
23615 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 resultobj = SWIG_From_int(static_cast< int >(result));
23623 return resultobj;
23624 fail:
23625 return NULL;
23626 }
23627
23628
23629 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23630 PyObject *resultobj = 0;
23631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23632 bool result;
23633 void *argp1 = 0 ;
23634 int res1 = 0 ;
23635 PyObject *swig_obj[1] ;
23636
23637 if (!args) SWIG_fail;
23638 swig_obj[0] = args;
23639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23640 if (!SWIG_IsOK(res1)) {
23641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23642 }
23643 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23647 wxPyEndAllowThreads(__tstate);
23648 if (PyErr_Occurred()) SWIG_fail;
23649 }
23650 {
23651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23652 }
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23660 PyObject *resultobj = 0;
23661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23662 bool result;
23663 void *argp1 = 0 ;
23664 int res1 = 0 ;
23665 PyObject *swig_obj[1] ;
23666
23667 if (!args) SWIG_fail;
23668 swig_obj[0] = args;
23669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23670 if (!SWIG_IsOK(res1)) {
23671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23672 }
23673 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23674 {
23675 PyThreadState* __tstate = wxPyBeginAllowThreads();
23676 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23677 wxPyEndAllowThreads(__tstate);
23678 if (PyErr_Occurred()) SWIG_fail;
23679 }
23680 {
23681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23682 }
23683 return resultobj;
23684 fail:
23685 return NULL;
23686 }
23687
23688
23689 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23690 PyObject *resultobj = 0;
23691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23692 bool result;
23693 void *argp1 = 0 ;
23694 int res1 = 0 ;
23695 PyObject *swig_obj[1] ;
23696
23697 if (!args) SWIG_fail;
23698 swig_obj[0] = args;
23699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23700 if (!SWIG_IsOK(res1)) {
23701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23702 }
23703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23704 {
23705 PyThreadState* __tstate = wxPyBeginAllowThreads();
23706 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23707 wxPyEndAllowThreads(__tstate);
23708 if (PyErr_Occurred()) SWIG_fail;
23709 }
23710 {
23711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23712 }
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23720 PyObject *resultobj = 0;
23721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23722 bool result;
23723 void *argp1 = 0 ;
23724 int res1 = 0 ;
23725 PyObject *swig_obj[1] ;
23726
23727 if (!args) SWIG_fail;
23728 swig_obj[0] = args;
23729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23730 if (!SWIG_IsOK(res1)) {
23731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23732 }
23733 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23737 wxPyEndAllowThreads(__tstate);
23738 if (PyErr_Occurred()) SWIG_fail;
23739 }
23740 {
23741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23742 }
23743 return resultobj;
23744 fail:
23745 return NULL;
23746 }
23747
23748
23749 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23750 PyObject *resultobj = 0;
23751 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23752 bool result;
23753 void *argp1 = 0 ;
23754 int res1 = 0 ;
23755 PyObject *swig_obj[1] ;
23756
23757 if (!args) SWIG_fail;
23758 swig_obj[0] = args;
23759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23760 if (!SWIG_IsOK(res1)) {
23761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23762 }
23763 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23767 wxPyEndAllowThreads(__tstate);
23768 if (PyErr_Occurred()) SWIG_fail;
23769 }
23770 {
23771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23772 }
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23780 PyObject *resultobj = 0;
23781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23782 bool result;
23783 void *argp1 = 0 ;
23784 int res1 = 0 ;
23785 PyObject *swig_obj[1] ;
23786
23787 if (!args) SWIG_fail;
23788 swig_obj[0] = args;
23789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23790 if (!SWIG_IsOK(res1)) {
23791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23792 }
23793 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *resultobj = 0;
23811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23812 bool result;
23813 void *argp1 = 0 ;
23814 int res1 = 0 ;
23815 PyObject *swig_obj[1] ;
23816
23817 if (!args) SWIG_fail;
23818 swig_obj[0] = args;
23819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23820 if (!SWIG_IsOK(res1)) {
23821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23822 }
23823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 {
23831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23832 }
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23842 bool result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 {
23861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23862 }
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *resultobj = 0;
23871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23872 bool result;
23873 void *argp1 = 0 ;
23874 int res1 = 0 ;
23875 PyObject *swig_obj[1] ;
23876
23877 if (!args) SWIG_fail;
23878 swig_obj[0] = args;
23879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23880 if (!SWIG_IsOK(res1)) {
23881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23882 }
23883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23884 {
23885 PyThreadState* __tstate = wxPyBeginAllowThreads();
23886 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 {
23891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23892 }
23893 return resultobj;
23894 fail:
23895 return NULL;
23896 }
23897
23898
23899 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23900 PyObject *resultobj = 0;
23901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23902 bool result;
23903 void *argp1 = 0 ;
23904 int res1 = 0 ;
23905 PyObject *swig_obj[1] ;
23906
23907 if (!args) SWIG_fail;
23908 swig_obj[0] = args;
23909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23910 if (!SWIG_IsOK(res1)) {
23911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23912 }
23913 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23914 {
23915 PyThreadState* __tstate = wxPyBeginAllowThreads();
23916 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23930 PyObject *resultobj = 0;
23931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23932 bool result;
23933 void *argp1 = 0 ;
23934 int res1 = 0 ;
23935 PyObject *swig_obj[1] ;
23936
23937 if (!args) SWIG_fail;
23938 swig_obj[0] = args;
23939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23940 if (!SWIG_IsOK(res1)) {
23941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23942 }
23943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23944 {
23945 PyThreadState* __tstate = wxPyBeginAllowThreads();
23946 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23947 wxPyEndAllowThreads(__tstate);
23948 if (PyErr_Occurred()) SWIG_fail;
23949 }
23950 {
23951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23952 }
23953 return resultobj;
23954 fail:
23955 return NULL;
23956 }
23957
23958
23959 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23960 PyObject *resultobj = 0;
23961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23962 bool result;
23963 void *argp1 = 0 ;
23964 int res1 = 0 ;
23965 PyObject *swig_obj[1] ;
23966
23967 if (!args) SWIG_fail;
23968 swig_obj[0] = args;
23969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23970 if (!SWIG_IsOK(res1)) {
23971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23972 }
23973 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 {
23981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23982 }
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *resultobj = 0;
23991 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23992 bool result;
23993 void *argp1 = 0 ;
23994 int res1 = 0 ;
23995 PyObject *swig_obj[1] ;
23996
23997 if (!args) SWIG_fail;
23998 swig_obj[0] = args;
23999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24000 if (!SWIG_IsOK(res1)) {
24001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24002 }
24003 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 {
24011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24012 }
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *resultobj = 0;
24021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24022 bool result;
24023 void *argp1 = 0 ;
24024 int res1 = 0 ;
24025 PyObject *swig_obj[1] ;
24026
24027 if (!args) SWIG_fail;
24028 swig_obj[0] = args;
24029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24030 if (!SWIG_IsOK(res1)) {
24031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24032 }
24033 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
24037 wxPyEndAllowThreads(__tstate);
24038 if (PyErr_Occurred()) SWIG_fail;
24039 }
24040 {
24041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24042 }
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24052 bool result;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 PyObject *swig_obj[1] ;
24056
24057 if (!args) SWIG_fail;
24058 swig_obj[0] = args;
24059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24062 }
24063 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (bool)(arg1)->LeftIsDown();
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24072 }
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24080 PyObject *resultobj = 0;
24081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24082 bool result;
24083 void *argp1 = 0 ;
24084 int res1 = 0 ;
24085 PyObject *swig_obj[1] ;
24086
24087 if (!args) SWIG_fail;
24088 swig_obj[0] = args;
24089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24090 if (!SWIG_IsOK(res1)) {
24091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24092 }
24093 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = (bool)(arg1)->MiddleIsDown();
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 {
24101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24102 }
24103 return resultobj;
24104 fail:
24105 return NULL;
24106 }
24107
24108
24109 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24110 PyObject *resultobj = 0;
24111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24112 bool result;
24113 void *argp1 = 0 ;
24114 int res1 = 0 ;
24115 PyObject *swig_obj[1] ;
24116
24117 if (!args) SWIG_fail;
24118 swig_obj[0] = args;
24119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24120 if (!SWIG_IsOK(res1)) {
24121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24122 }
24123 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 result = (bool)(arg1)->RightIsDown();
24127 wxPyEndAllowThreads(__tstate);
24128 if (PyErr_Occurred()) SWIG_fail;
24129 }
24130 {
24131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24132 }
24133 return resultobj;
24134 fail:
24135 return NULL;
24136 }
24137
24138
24139 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24140 PyObject *resultobj = 0;
24141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24142 bool result;
24143 void *argp1 = 0 ;
24144 int res1 = 0 ;
24145 PyObject *swig_obj[1] ;
24146
24147 if (!args) SWIG_fail;
24148 swig_obj[0] = args;
24149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24150 if (!SWIG_IsOK(res1)) {
24151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24152 }
24153 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 {
24161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24162 }
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24170 PyObject *resultobj = 0;
24171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24172 bool result;
24173 void *argp1 = 0 ;
24174 int res1 = 0 ;
24175 PyObject *swig_obj[1] ;
24176
24177 if (!args) SWIG_fail;
24178 swig_obj[0] = args;
24179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24180 if (!SWIG_IsOK(res1)) {
24181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24182 }
24183 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 result = (bool)((wxMouseEvent const *)arg1)->Moving();
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 {
24191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24192 }
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24200 PyObject *resultobj = 0;
24201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24202 bool result;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 PyObject *swig_obj[1] ;
24206
24207 if (!args) SWIG_fail;
24208 swig_obj[0] = args;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 result = (bool)((wxMouseEvent const *)arg1)->Entering();
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 {
24221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24222 }
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24230 PyObject *resultobj = 0;
24231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24232 bool result;
24233 void *argp1 = 0 ;
24234 int res1 = 0 ;
24235 PyObject *swig_obj[1] ;
24236
24237 if (!args) SWIG_fail;
24238 swig_obj[0] = args;
24239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24240 if (!SWIG_IsOK(res1)) {
24241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24242 }
24243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24244 {
24245 PyThreadState* __tstate = wxPyBeginAllowThreads();
24246 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 {
24251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24252 }
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24260 PyObject *resultobj = 0;
24261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24262 wxPoint result;
24263 void *argp1 = 0 ;
24264 int res1 = 0 ;
24265 PyObject *swig_obj[1] ;
24266
24267 if (!args) SWIG_fail;
24268 swig_obj[0] = args;
24269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24270 if (!SWIG_IsOK(res1)) {
24271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24272 }
24273 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24274 {
24275 PyThreadState* __tstate = wxPyBeginAllowThreads();
24276 result = (arg1)->GetPosition();
24277 wxPyEndAllowThreads(__tstate);
24278 if (PyErr_Occurred()) SWIG_fail;
24279 }
24280 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24281 return resultobj;
24282 fail:
24283 return NULL;
24284 }
24285
24286
24287 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24288 PyObject *resultobj = 0;
24289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24290 long *arg2 = (long *) 0 ;
24291 long *arg3 = (long *) 0 ;
24292 void *argp1 = 0 ;
24293 int res1 = 0 ;
24294 long temp2 ;
24295 int res2 = SWIG_TMPOBJ ;
24296 long temp3 ;
24297 int res3 = SWIG_TMPOBJ ;
24298 PyObject *swig_obj[1] ;
24299
24300 arg2 = &temp2;
24301 arg3 = &temp3;
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24309 {
24310 PyThreadState* __tstate = wxPyBeginAllowThreads();
24311 (arg1)->GetPosition(arg2,arg3);
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_Py_Void();
24316 if (SWIG_IsTmpObj(res2)) {
24317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
24318 } else {
24319 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
24321 }
24322 if (SWIG_IsTmpObj(res3)) {
24323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
24324 } else {
24325 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
24327 }
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24335 PyObject *resultobj = 0;
24336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24337 wxDC *arg2 = 0 ;
24338 wxPoint result;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 void *argp2 = 0 ;
24342 int res2 = 0 ;
24343 PyObject * obj0 = 0 ;
24344 PyObject * obj1 = 0 ;
24345 char * kwnames[] = {
24346 (char *) "self",(char *) "dc", NULL
24347 };
24348
24349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24351 if (!SWIG_IsOK(res1)) {
24352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24353 }
24354 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
24356 if (!SWIG_IsOK(res2)) {
24357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24358 }
24359 if (!argp2) {
24360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24361 }
24362 arg2 = reinterpret_cast< wxDC * >(argp2);
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24370 return resultobj;
24371 fail:
24372 return NULL;
24373 }
24374
24375
24376 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24377 PyObject *resultobj = 0;
24378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24379 int result;
24380 void *argp1 = 0 ;
24381 int res1 = 0 ;
24382 PyObject *swig_obj[1] ;
24383
24384 if (!args) SWIG_fail;
24385 swig_obj[0] = args;
24386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24387 if (!SWIG_IsOK(res1)) {
24388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24389 }
24390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24391 {
24392 PyThreadState* __tstate = wxPyBeginAllowThreads();
24393 result = (int)((wxMouseEvent const *)arg1)->GetX();
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 resultobj = SWIG_From_int(static_cast< int >(result));
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24407 int result;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 PyObject *swig_obj[1] ;
24411
24412 if (!args) SWIG_fail;
24413 swig_obj[0] = args;
24414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24415 if (!SWIG_IsOK(res1)) {
24416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24417 }
24418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24419 {
24420 PyThreadState* __tstate = wxPyBeginAllowThreads();
24421 result = (int)((wxMouseEvent const *)arg1)->GetY();
24422 wxPyEndAllowThreads(__tstate);
24423 if (PyErr_Occurred()) SWIG_fail;
24424 }
24425 resultobj = SWIG_From_int(static_cast< int >(result));
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *resultobj = 0;
24434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24435 int result;
24436 void *argp1 = 0 ;
24437 int res1 = 0 ;
24438 PyObject *swig_obj[1] ;
24439
24440 if (!args) SWIG_fail;
24441 swig_obj[0] = args;
24442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24443 if (!SWIG_IsOK(res1)) {
24444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24445 }
24446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 resultobj = SWIG_From_int(static_cast< int >(result));
24454 return resultobj;
24455 fail:
24456 return NULL;
24457 }
24458
24459
24460 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24461 PyObject *resultobj = 0;
24462 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24463 int result;
24464 void *argp1 = 0 ;
24465 int res1 = 0 ;
24466 PyObject *swig_obj[1] ;
24467
24468 if (!args) SWIG_fail;
24469 swig_obj[0] = args;
24470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24473 }
24474 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 resultobj = SWIG_From_int(static_cast< int >(result));
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *resultobj = 0;
24490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24491 int result;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 PyObject *swig_obj[1] ;
24495
24496 if (!args) SWIG_fail;
24497 swig_obj[0] = args;
24498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24499 if (!SWIG_IsOK(res1)) {
24500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24501 }
24502 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = SWIG_From_int(static_cast< int >(result));
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *resultobj = 0;
24518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24519 int result;
24520 void *argp1 = 0 ;
24521 int res1 = 0 ;
24522 PyObject *swig_obj[1] ;
24523
24524 if (!args) SWIG_fail;
24525 swig_obj[0] = args;
24526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24527 if (!SWIG_IsOK(res1)) {
24528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24529 }
24530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24531 {
24532 PyThreadState* __tstate = wxPyBeginAllowThreads();
24533 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 resultobj = SWIG_From_int(static_cast< int >(result));
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545 PyObject *resultobj = 0;
24546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24547 bool result;
24548 void *argp1 = 0 ;
24549 int res1 = 0 ;
24550 PyObject *swig_obj[1] ;
24551
24552 if (!args) SWIG_fail;
24553 swig_obj[0] = args;
24554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24555 if (!SWIG_IsOK(res1)) {
24556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24557 }
24558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24559 {
24560 PyThreadState* __tstate = wxPyBeginAllowThreads();
24561 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 {
24566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24567 }
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *resultobj = 0;
24576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24577 int arg2 ;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 int val2 ;
24581 int ecode2 = 0 ;
24582 PyObject *swig_obj[2] ;
24583
24584 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24588 }
24589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24590 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24591 if (!SWIG_IsOK(ecode2)) {
24592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24593 }
24594 arg2 = static_cast< int >(val2);
24595 if (arg1) (arg1)->m_x = arg2;
24596
24597 resultobj = SWIG_Py_Void();
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24605 PyObject *resultobj = 0;
24606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24607 int result;
24608 void *argp1 = 0 ;
24609 int res1 = 0 ;
24610 PyObject *swig_obj[1] ;
24611
24612 if (!args) SWIG_fail;
24613 swig_obj[0] = args;
24614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24615 if (!SWIG_IsOK(res1)) {
24616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24617 }
24618 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24619 result = (int) ((arg1)->m_x);
24620 resultobj = SWIG_From_int(static_cast< int >(result));
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *resultobj = 0;
24629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24630 int arg2 ;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 int val2 ;
24634 int ecode2 = 0 ;
24635 PyObject *swig_obj[2] ;
24636
24637 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24639 if (!SWIG_IsOK(res1)) {
24640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24641 }
24642 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24644 if (!SWIG_IsOK(ecode2)) {
24645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24646 }
24647 arg2 = static_cast< int >(val2);
24648 if (arg1) (arg1)->m_y = arg2;
24649
24650 resultobj = SWIG_Py_Void();
24651 return resultobj;
24652 fail:
24653 return NULL;
24654 }
24655
24656
24657 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24658 PyObject *resultobj = 0;
24659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24660 int result;
24661 void *argp1 = 0 ;
24662 int res1 = 0 ;
24663 PyObject *swig_obj[1] ;
24664
24665 if (!args) SWIG_fail;
24666 swig_obj[0] = args;
24667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24668 if (!SWIG_IsOK(res1)) {
24669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24670 }
24671 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24672 result = (int) ((arg1)->m_y);
24673 resultobj = SWIG_From_int(static_cast< int >(result));
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *resultobj = 0;
24682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24683 bool arg2 ;
24684 void *argp1 = 0 ;
24685 int res1 = 0 ;
24686 bool val2 ;
24687 int ecode2 = 0 ;
24688 PyObject *swig_obj[2] ;
24689
24690 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24692 if (!SWIG_IsOK(res1)) {
24693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24694 }
24695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24696 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24697 if (!SWIG_IsOK(ecode2)) {
24698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24699 }
24700 arg2 = static_cast< bool >(val2);
24701 if (arg1) (arg1)->m_leftDown = arg2;
24702
24703 resultobj = SWIG_Py_Void();
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 PyObject *resultobj = 0;
24712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24713 bool result;
24714 void *argp1 = 0 ;
24715 int res1 = 0 ;
24716 PyObject *swig_obj[1] ;
24717
24718 if (!args) SWIG_fail;
24719 swig_obj[0] = args;
24720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24721 if (!SWIG_IsOK(res1)) {
24722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24723 }
24724 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24725 result = (bool) ((arg1)->m_leftDown);
24726 {
24727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24728 }
24729 return resultobj;
24730 fail:
24731 return NULL;
24732 }
24733
24734
24735 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24736 PyObject *resultobj = 0;
24737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24738 bool arg2 ;
24739 void *argp1 = 0 ;
24740 int res1 = 0 ;
24741 bool val2 ;
24742 int ecode2 = 0 ;
24743 PyObject *swig_obj[2] ;
24744
24745 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24747 if (!SWIG_IsOK(res1)) {
24748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24749 }
24750 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24751 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24752 if (!SWIG_IsOK(ecode2)) {
24753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24754 }
24755 arg2 = static_cast< bool >(val2);
24756 if (arg1) (arg1)->m_middleDown = arg2;
24757
24758 resultobj = SWIG_Py_Void();
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24766 PyObject *resultobj = 0;
24767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24768 bool result;
24769 void *argp1 = 0 ;
24770 int res1 = 0 ;
24771 PyObject *swig_obj[1] ;
24772
24773 if (!args) SWIG_fail;
24774 swig_obj[0] = args;
24775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24778 }
24779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24780 result = (bool) ((arg1)->m_middleDown);
24781 {
24782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24783 }
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24791 PyObject *resultobj = 0;
24792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24793 bool arg2 ;
24794 void *argp1 = 0 ;
24795 int res1 = 0 ;
24796 bool val2 ;
24797 int ecode2 = 0 ;
24798 PyObject *swig_obj[2] ;
24799
24800 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24802 if (!SWIG_IsOK(res1)) {
24803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24804 }
24805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24806 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24807 if (!SWIG_IsOK(ecode2)) {
24808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24809 }
24810 arg2 = static_cast< bool >(val2);
24811 if (arg1) (arg1)->m_rightDown = arg2;
24812
24813 resultobj = SWIG_Py_Void();
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24821 PyObject *resultobj = 0;
24822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24823 bool result;
24824 void *argp1 = 0 ;
24825 int res1 = 0 ;
24826 PyObject *swig_obj[1] ;
24827
24828 if (!args) SWIG_fail;
24829 swig_obj[0] = args;
24830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24831 if (!SWIG_IsOK(res1)) {
24832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24833 }
24834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24835 result = (bool) ((arg1)->m_rightDown);
24836 {
24837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *resultobj = 0;
24847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24848 bool arg2 ;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 bool val2 ;
24852 int ecode2 = 0 ;
24853 PyObject *swig_obj[2] ;
24854
24855 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24859 }
24860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24861 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24862 if (!SWIG_IsOK(ecode2)) {
24863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24864 }
24865 arg2 = static_cast< bool >(val2);
24866 if (arg1) (arg1)->m_controlDown = arg2;
24867
24868 resultobj = SWIG_Py_Void();
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24876 PyObject *resultobj = 0;
24877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24878 bool result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 PyObject *swig_obj[1] ;
24882
24883 if (!args) SWIG_fail;
24884 swig_obj[0] = args;
24885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24886 if (!SWIG_IsOK(res1)) {
24887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24888 }
24889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24890 result = (bool) ((arg1)->m_controlDown);
24891 {
24892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24893 }
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24901 PyObject *resultobj = 0;
24902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24903 bool arg2 ;
24904 void *argp1 = 0 ;
24905 int res1 = 0 ;
24906 bool val2 ;
24907 int ecode2 = 0 ;
24908 PyObject *swig_obj[2] ;
24909
24910 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24912 if (!SWIG_IsOK(res1)) {
24913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24914 }
24915 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24916 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24917 if (!SWIG_IsOK(ecode2)) {
24918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24919 }
24920 arg2 = static_cast< bool >(val2);
24921 if (arg1) (arg1)->m_shiftDown = arg2;
24922
24923 resultobj = SWIG_Py_Void();
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24931 PyObject *resultobj = 0;
24932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24933 bool result;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 PyObject *swig_obj[1] ;
24937
24938 if (!args) SWIG_fail;
24939 swig_obj[0] = args;
24940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24941 if (!SWIG_IsOK(res1)) {
24942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24943 }
24944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24945 result = (bool) ((arg1)->m_shiftDown);
24946 {
24947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24948 }
24949 return resultobj;
24950 fail:
24951 return NULL;
24952 }
24953
24954
24955 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24956 PyObject *resultobj = 0;
24957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24958 bool arg2 ;
24959 void *argp1 = 0 ;
24960 int res1 = 0 ;
24961 bool val2 ;
24962 int ecode2 = 0 ;
24963 PyObject *swig_obj[2] ;
24964
24965 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24967 if (!SWIG_IsOK(res1)) {
24968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24969 }
24970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24971 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24972 if (!SWIG_IsOK(ecode2)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24974 }
24975 arg2 = static_cast< bool >(val2);
24976 if (arg1) (arg1)->m_altDown = arg2;
24977
24978 resultobj = SWIG_Py_Void();
24979 return resultobj;
24980 fail:
24981 return NULL;
24982 }
24983
24984
24985 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24986 PyObject *resultobj = 0;
24987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24988 bool result;
24989 void *argp1 = 0 ;
24990 int res1 = 0 ;
24991 PyObject *swig_obj[1] ;
24992
24993 if (!args) SWIG_fail;
24994 swig_obj[0] = args;
24995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24996 if (!SWIG_IsOK(res1)) {
24997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24998 }
24999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25000 result = (bool) ((arg1)->m_altDown);
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25011 PyObject *resultobj = 0;
25012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25013 bool arg2 ;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 bool val2 ;
25017 int ecode2 = 0 ;
25018 PyObject *swig_obj[2] ;
25019
25020 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25022 if (!SWIG_IsOK(res1)) {
25023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25024 }
25025 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25026 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25027 if (!SWIG_IsOK(ecode2)) {
25028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25029 }
25030 arg2 = static_cast< bool >(val2);
25031 if (arg1) (arg1)->m_metaDown = arg2;
25032
25033 resultobj = SWIG_Py_Void();
25034 return resultobj;
25035 fail:
25036 return NULL;
25037 }
25038
25039
25040 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25041 PyObject *resultobj = 0;
25042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25043 bool result;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 PyObject *swig_obj[1] ;
25047
25048 if (!args) SWIG_fail;
25049 swig_obj[0] = args;
25050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25053 }
25054 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25055 result = (bool) ((arg1)->m_metaDown);
25056 {
25057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25066 PyObject *resultobj = 0;
25067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25068 int arg2 ;
25069 void *argp1 = 0 ;
25070 int res1 = 0 ;
25071 int val2 ;
25072 int ecode2 = 0 ;
25073 PyObject *swig_obj[2] ;
25074
25075 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
25076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25077 if (!SWIG_IsOK(res1)) {
25078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25079 }
25080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25081 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25082 if (!SWIG_IsOK(ecode2)) {
25083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
25084 }
25085 arg2 = static_cast< int >(val2);
25086 if (arg1) (arg1)->m_wheelRotation = arg2;
25087
25088 resultobj = SWIG_Py_Void();
25089 return resultobj;
25090 fail:
25091 return NULL;
25092 }
25093
25094
25095 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25096 PyObject *resultobj = 0;
25097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25098 int result;
25099 void *argp1 = 0 ;
25100 int res1 = 0 ;
25101 PyObject *swig_obj[1] ;
25102
25103 if (!args) SWIG_fail;
25104 swig_obj[0] = args;
25105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25106 if (!SWIG_IsOK(res1)) {
25107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25108 }
25109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25110 result = (int) ((arg1)->m_wheelRotation);
25111 resultobj = SWIG_From_int(static_cast< int >(result));
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25119 PyObject *resultobj = 0;
25120 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25121 int arg2 ;
25122 void *argp1 = 0 ;
25123 int res1 = 0 ;
25124 int val2 ;
25125 int ecode2 = 0 ;
25126 PyObject *swig_obj[2] ;
25127
25128 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
25129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25130 if (!SWIG_IsOK(res1)) {
25131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25132 }
25133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25134 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25135 if (!SWIG_IsOK(ecode2)) {
25136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
25137 }
25138 arg2 = static_cast< int >(val2);
25139 if (arg1) (arg1)->m_wheelDelta = arg2;
25140
25141 resultobj = SWIG_Py_Void();
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25151 int result;
25152 void *argp1 = 0 ;
25153 int res1 = 0 ;
25154 PyObject *swig_obj[1] ;
25155
25156 if (!args) SWIG_fail;
25157 swig_obj[0] = args;
25158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25159 if (!SWIG_IsOK(res1)) {
25160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25161 }
25162 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25163 result = (int) ((arg1)->m_wheelDelta);
25164 resultobj = SWIG_From_int(static_cast< int >(result));
25165 return resultobj;
25166 fail:
25167 return NULL;
25168 }
25169
25170
25171 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25172 PyObject *resultobj = 0;
25173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25174 int arg2 ;
25175 void *argp1 = 0 ;
25176 int res1 = 0 ;
25177 int val2 ;
25178 int ecode2 = 0 ;
25179 PyObject *swig_obj[2] ;
25180
25181 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
25182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25183 if (!SWIG_IsOK(res1)) {
25184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25185 }
25186 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25187 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25188 if (!SWIG_IsOK(ecode2)) {
25189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
25190 }
25191 arg2 = static_cast< int >(val2);
25192 if (arg1) (arg1)->m_linesPerAction = arg2;
25193
25194 resultobj = SWIG_Py_Void();
25195 return resultobj;
25196 fail:
25197 return NULL;
25198 }
25199
25200
25201 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25202 PyObject *resultobj = 0;
25203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25204 int result;
25205 void *argp1 = 0 ;
25206 int res1 = 0 ;
25207 PyObject *swig_obj[1] ;
25208
25209 if (!args) SWIG_fail;
25210 swig_obj[0] = args;
25211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25212 if (!SWIG_IsOK(res1)) {
25213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25214 }
25215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25216 result = (int) ((arg1)->m_linesPerAction);
25217 resultobj = SWIG_From_int(static_cast< int >(result));
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25225 PyObject *obj;
25226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25227 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
25228 return SWIG_Py_Void();
25229 }
25230
25231 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25232 return SWIG_Python_InitShadowInstance(args);
25233 }
25234
25235 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj = 0;
25237 int arg1 = (int) 0 ;
25238 int arg2 = (int) 0 ;
25239 wxSetCursorEvent *result = 0 ;
25240 int val1 ;
25241 int ecode1 = 0 ;
25242 int val2 ;
25243 int ecode2 = 0 ;
25244 PyObject * obj0 = 0 ;
25245 PyObject * obj1 = 0 ;
25246 char * kwnames[] = {
25247 (char *) "x",(char *) "y", NULL
25248 };
25249
25250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25251 if (obj0) {
25252 ecode1 = SWIG_AsVal_int(obj0, &val1);
25253 if (!SWIG_IsOK(ecode1)) {
25254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
25255 }
25256 arg1 = static_cast< int >(val1);
25257 }
25258 if (obj1) {
25259 ecode2 = SWIG_AsVal_int(obj1, &val2);
25260 if (!SWIG_IsOK(ecode2)) {
25261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
25262 }
25263 arg2 = static_cast< int >(val2);
25264 }
25265 {
25266 PyThreadState* __tstate = wxPyBeginAllowThreads();
25267 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25279 PyObject *resultobj = 0;
25280 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25281 int result;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 PyObject *swig_obj[1] ;
25285
25286 if (!args) SWIG_fail;
25287 swig_obj[0] = args;
25288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25291 }
25292 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
25296 wxPyEndAllowThreads(__tstate);
25297 if (PyErr_Occurred()) SWIG_fail;
25298 }
25299 resultobj = SWIG_From_int(static_cast< int >(result));
25300 return resultobj;
25301 fail:
25302 return NULL;
25303 }
25304
25305
25306 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25307 PyObject *resultobj = 0;
25308 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25309 int result;
25310 void *argp1 = 0 ;
25311 int res1 = 0 ;
25312 PyObject *swig_obj[1] ;
25313
25314 if (!args) SWIG_fail;
25315 swig_obj[0] = args;
25316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25317 if (!SWIG_IsOK(res1)) {
25318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25319 }
25320 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_From_int(static_cast< int >(result));
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj = 0;
25336 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25337 wxCursor *arg2 = 0 ;
25338 void *argp1 = 0 ;
25339 int res1 = 0 ;
25340 void *argp2 = 0 ;
25341 int res2 = 0 ;
25342 PyObject * obj0 = 0 ;
25343 PyObject * obj1 = 0 ;
25344 char * kwnames[] = {
25345 (char *) "self",(char *) "cursor", NULL
25346 };
25347
25348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
25349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25350 if (!SWIG_IsOK(res1)) {
25351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
25352 }
25353 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25354 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
25355 if (!SWIG_IsOK(res2)) {
25356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25357 }
25358 if (!argp2) {
25359 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25360 }
25361 arg2 = reinterpret_cast< wxCursor * >(argp2);
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 (arg1)->SetCursor((wxCursor const &)*arg2);
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 resultobj = SWIG_Py_Void();
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25376 PyObject *resultobj = 0;
25377 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25378 wxCursor *result = 0 ;
25379 void *argp1 = 0 ;
25380 int res1 = 0 ;
25381 PyObject *swig_obj[1] ;
25382
25383 if (!args) SWIG_fail;
25384 swig_obj[0] = args;
25385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25386 if (!SWIG_IsOK(res1)) {
25387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25388 }
25389 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 {
25393 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
25394 result = (wxCursor *) &_result_ref;
25395 }
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 {
25400 wxCursor* resultptr = new wxCursor(*result);
25401 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
25402 }
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25410 PyObject *resultobj = 0;
25411 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25412 bool result;
25413 void *argp1 = 0 ;
25414 int res1 = 0 ;
25415 PyObject *swig_obj[1] ;
25416
25417 if (!args) SWIG_fail;
25418 swig_obj[0] = args;
25419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25420 if (!SWIG_IsOK(res1)) {
25421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25422 }
25423 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25424 {
25425 PyThreadState* __tstate = wxPyBeginAllowThreads();
25426 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
25427 wxPyEndAllowThreads(__tstate);
25428 if (PyErr_Occurred()) SWIG_fail;
25429 }
25430 {
25431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25432 }
25433 return resultobj;
25434 fail:
25435 return NULL;
25436 }
25437
25438
25439 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25440 PyObject *obj;
25441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25442 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
25443 return SWIG_Py_Void();
25444 }
25445
25446 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25447 return SWIG_Python_InitShadowInstance(args);
25448 }
25449
25450 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj = 0;
25452 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25453 wxKeyEvent *result = 0 ;
25454 int val1 ;
25455 int ecode1 = 0 ;
25456 PyObject * obj0 = 0 ;
25457 char * kwnames[] = {
25458 (char *) "eventType", NULL
25459 };
25460
25461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
25462 if (obj0) {
25463 ecode1 = SWIG_AsVal_int(obj0, &val1);
25464 if (!SWIG_IsOK(ecode1)) {
25465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25466 }
25467 arg1 = static_cast< wxEventType >(val1);
25468 }
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 result = (wxKeyEvent *)new wxKeyEvent(arg1);
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *resultobj = 0;
25484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25485 int result;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 PyObject *swig_obj[1] ;
25489
25490 if (!args) SWIG_fail;
25491 swig_obj[0] = args;
25492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25493 if (!SWIG_IsOK(res1)) {
25494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25495 }
25496 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25497 {
25498 PyThreadState* __tstate = wxPyBeginAllowThreads();
25499 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
25500 wxPyEndAllowThreads(__tstate);
25501 if (PyErr_Occurred()) SWIG_fail;
25502 }
25503 resultobj = SWIG_From_int(static_cast< int >(result));
25504 return resultobj;
25505 fail:
25506 return NULL;
25507 }
25508
25509
25510 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25511 PyObject *resultobj = 0;
25512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25513 bool result;
25514 void *argp1 = 0 ;
25515 int res1 = 0 ;
25516 PyObject *swig_obj[1] ;
25517
25518 if (!args) SWIG_fail;
25519 swig_obj[0] = args;
25520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25521 if (!SWIG_IsOK(res1)) {
25522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25523 }
25524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25528 wxPyEndAllowThreads(__tstate);
25529 if (PyErr_Occurred()) SWIG_fail;
25530 }
25531 {
25532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25533 }
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 bool result;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 PyObject *swig_obj[1] ;
25547
25548 if (!args) SWIG_fail;
25549 swig_obj[0] = args;
25550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25551 if (!SWIG_IsOK(res1)) {
25552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25553 }
25554 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25555 {
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25558 wxPyEndAllowThreads(__tstate);
25559 if (PyErr_Occurred()) SWIG_fail;
25560 }
25561 {
25562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25563 }
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 PyObject *resultobj = 0;
25572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25573 bool result;
25574 void *argp1 = 0 ;
25575 int res1 = 0 ;
25576 PyObject *swig_obj[1] ;
25577
25578 if (!args) SWIG_fail;
25579 swig_obj[0] = args;
25580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25581 if (!SWIG_IsOK(res1)) {
25582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25583 }
25584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 {
25592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25593 }
25594 return resultobj;
25595 fail:
25596 return NULL;
25597 }
25598
25599
25600 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25601 PyObject *resultobj = 0;
25602 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25603 bool result;
25604 void *argp1 = 0 ;
25605 int res1 = 0 ;
25606 PyObject *swig_obj[1] ;
25607
25608 if (!args) SWIG_fail;
25609 swig_obj[0] = args;
25610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25611 if (!SWIG_IsOK(res1)) {
25612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25613 }
25614 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25615 {
25616 PyThreadState* __tstate = wxPyBeginAllowThreads();
25617 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25618 wxPyEndAllowThreads(__tstate);
25619 if (PyErr_Occurred()) SWIG_fail;
25620 }
25621 {
25622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25623 }
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25631 PyObject *resultobj = 0;
25632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25633 bool result;
25634 void *argp1 = 0 ;
25635 int res1 = 0 ;
25636 PyObject *swig_obj[1] ;
25637
25638 if (!args) SWIG_fail;
25639 swig_obj[0] = args;
25640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25641 if (!SWIG_IsOK(res1)) {
25642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25643 }
25644 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25648 wxPyEndAllowThreads(__tstate);
25649 if (PyErr_Occurred()) SWIG_fail;
25650 }
25651 {
25652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25653 }
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25661 PyObject *resultobj = 0;
25662 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25663 bool result;
25664 void *argp1 = 0 ;
25665 int res1 = 0 ;
25666 PyObject *swig_obj[1] ;
25667
25668 if (!args) SWIG_fail;
25669 swig_obj[0] = args;
25670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25671 if (!SWIG_IsOK(res1)) {
25672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25673 }
25674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25675 {
25676 PyThreadState* __tstate = wxPyBeginAllowThreads();
25677 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25678 wxPyEndAllowThreads(__tstate);
25679 if (PyErr_Occurred()) SWIG_fail;
25680 }
25681 {
25682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25683 }
25684 return resultobj;
25685 fail:
25686 return NULL;
25687 }
25688
25689
25690 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25691 PyObject *resultobj = 0;
25692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25693 int result;
25694 void *argp1 = 0 ;
25695 int res1 = 0 ;
25696 PyObject *swig_obj[1] ;
25697
25698 if (!args) SWIG_fail;
25699 swig_obj[0] = args;
25700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25701 if (!SWIG_IsOK(res1)) {
25702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25703 }
25704 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25705 {
25706 PyThreadState* __tstate = wxPyBeginAllowThreads();
25707 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25708 wxPyEndAllowThreads(__tstate);
25709 if (PyErr_Occurred()) SWIG_fail;
25710 }
25711 resultobj = SWIG_From_int(static_cast< int >(result));
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25719 PyObject *resultobj = 0;
25720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25721 int result;
25722 void *argp1 = 0 ;
25723 int res1 = 0 ;
25724 PyObject *swig_obj[1] ;
25725
25726 if (!args) SWIG_fail;
25727 swig_obj[0] = args;
25728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25731 }
25732 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 resultobj = SWIG_From_int(static_cast< int >(result));
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj = 0;
25748 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25749 int arg2 ;
25750 void *argp1 = 0 ;
25751 int res1 = 0 ;
25752 int val2 ;
25753 int ecode2 = 0 ;
25754 PyObject * obj0 = 0 ;
25755 PyObject * obj1 = 0 ;
25756 char * kwnames[] = {
25757 (char *) "self",(char *) "uniChar", NULL
25758 };
25759
25760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25762 if (!SWIG_IsOK(res1)) {
25763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25764 }
25765 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25766 ecode2 = SWIG_AsVal_int(obj1, &val2);
25767 if (!SWIG_IsOK(ecode2)) {
25768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25769 }
25770 arg2 = static_cast< int >(val2);
25771 {
25772 PyThreadState* __tstate = wxPyBeginAllowThreads();
25773 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25774 wxPyEndAllowThreads(__tstate);
25775 if (PyErr_Occurred()) SWIG_fail;
25776 }
25777 resultobj = SWIG_Py_Void();
25778 return resultobj;
25779 fail:
25780 return NULL;
25781 }
25782
25783
25784 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25785 PyObject *resultobj = 0;
25786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25787 unsigned int result;
25788 void *argp1 = 0 ;
25789 int res1 = 0 ;
25790 PyObject *swig_obj[1] ;
25791
25792 if (!args) SWIG_fail;
25793 swig_obj[0] = args;
25794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25795 if (!SWIG_IsOK(res1)) {
25796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25797 }
25798 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25799 {
25800 PyThreadState* __tstate = wxPyBeginAllowThreads();
25801 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25802 wxPyEndAllowThreads(__tstate);
25803 if (PyErr_Occurred()) SWIG_fail;
25804 }
25805 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25806 return resultobj;
25807 fail:
25808 return NULL;
25809 }
25810
25811
25812 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25813 PyObject *resultobj = 0;
25814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25815 unsigned int result;
25816 void *argp1 = 0 ;
25817 int res1 = 0 ;
25818 PyObject *swig_obj[1] ;
25819
25820 if (!args) SWIG_fail;
25821 swig_obj[0] = args;
25822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25823 if (!SWIG_IsOK(res1)) {
25824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25825 }
25826 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25827 {
25828 PyThreadState* __tstate = wxPyBeginAllowThreads();
25829 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25830 wxPyEndAllowThreads(__tstate);
25831 if (PyErr_Occurred()) SWIG_fail;
25832 }
25833 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25834 return resultobj;
25835 fail:
25836 return NULL;
25837 }
25838
25839
25840 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25841 PyObject *resultobj = 0;
25842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25843 wxPoint result;
25844 void *argp1 = 0 ;
25845 int res1 = 0 ;
25846 PyObject *swig_obj[1] ;
25847
25848 if (!args) SWIG_fail;
25849 swig_obj[0] = args;
25850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25851 if (!SWIG_IsOK(res1)) {
25852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25853 }
25854 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 result = (arg1)->GetPosition();
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 long *arg2 = (long *) 0 ;
25872 long *arg3 = (long *) 0 ;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 long temp2 ;
25876 int res2 = SWIG_TMPOBJ ;
25877 long temp3 ;
25878 int res3 = SWIG_TMPOBJ ;
25879 PyObject *swig_obj[1] ;
25880
25881 arg2 = &temp2;
25882 arg3 = &temp3;
25883 if (!args) SWIG_fail;
25884 swig_obj[0] = args;
25885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25886 if (!SWIG_IsOK(res1)) {
25887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25888 }
25889 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 (arg1)->GetPosition(arg2,arg3);
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 resultobj = SWIG_Py_Void();
25897 if (SWIG_IsTmpObj(res2)) {
25898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25899 } else {
25900 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25902 }
25903 if (SWIG_IsTmpObj(res3)) {
25904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25905 } else {
25906 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25908 }
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25916 PyObject *resultobj = 0;
25917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25918 int result;
25919 void *argp1 = 0 ;
25920 int res1 = 0 ;
25921 PyObject *swig_obj[1] ;
25922
25923 if (!args) SWIG_fail;
25924 swig_obj[0] = args;
25925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25928 }
25929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 result = (int)((wxKeyEvent const *)arg1)->GetX();
25933 wxPyEndAllowThreads(__tstate);
25934 if (PyErr_Occurred()) SWIG_fail;
25935 }
25936 resultobj = SWIG_From_int(static_cast< int >(result));
25937 return resultobj;
25938 fail:
25939 return NULL;
25940 }
25941
25942
25943 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25944 PyObject *resultobj = 0;
25945 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25946 int result;
25947 void *argp1 = 0 ;
25948 int res1 = 0 ;
25949 PyObject *swig_obj[1] ;
25950
25951 if (!args) SWIG_fail;
25952 swig_obj[0] = args;
25953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25954 if (!SWIG_IsOK(res1)) {
25955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25956 }
25957 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25958 {
25959 PyThreadState* __tstate = wxPyBeginAllowThreads();
25960 result = (int)((wxKeyEvent const *)arg1)->GetY();
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_From_int(static_cast< int >(result));
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25972 PyObject *resultobj = 0;
25973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25974 int arg2 ;
25975 void *argp1 = 0 ;
25976 int res1 = 0 ;
25977 int val2 ;
25978 int ecode2 = 0 ;
25979 PyObject *swig_obj[2] ;
25980
25981 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25985 }
25986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25987 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25988 if (!SWIG_IsOK(ecode2)) {
25989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25990 }
25991 arg2 = static_cast< int >(val2);
25992 if (arg1) (arg1)->m_x = arg2;
25993
25994 resultobj = SWIG_Py_Void();
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26002 PyObject *resultobj = 0;
26003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26004 int result;
26005 void *argp1 = 0 ;
26006 int res1 = 0 ;
26007 PyObject *swig_obj[1] ;
26008
26009 if (!args) SWIG_fail;
26010 swig_obj[0] = args;
26011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26012 if (!SWIG_IsOK(res1)) {
26013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26014 }
26015 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26016 result = (int) ((arg1)->m_x);
26017 resultobj = SWIG_From_int(static_cast< int >(result));
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26025 PyObject *resultobj = 0;
26026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26027 int arg2 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 int val2 ;
26031 int ecode2 = 0 ;
26032 PyObject *swig_obj[2] ;
26033
26034 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
26035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26036 if (!SWIG_IsOK(res1)) {
26037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26038 }
26039 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26041 if (!SWIG_IsOK(ecode2)) {
26042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
26043 }
26044 arg2 = static_cast< int >(val2);
26045 if (arg1) (arg1)->m_y = arg2;
26046
26047 resultobj = SWIG_Py_Void();
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26055 PyObject *resultobj = 0;
26056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26057 int result;
26058 void *argp1 = 0 ;
26059 int res1 = 0 ;
26060 PyObject *swig_obj[1] ;
26061
26062 if (!args) SWIG_fail;
26063 swig_obj[0] = args;
26064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26065 if (!SWIG_IsOK(res1)) {
26066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26067 }
26068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26069 result = (int) ((arg1)->m_y);
26070 resultobj = SWIG_From_int(static_cast< int >(result));
26071 return resultobj;
26072 fail:
26073 return NULL;
26074 }
26075
26076
26077 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26078 PyObject *resultobj = 0;
26079 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26080 long arg2 ;
26081 void *argp1 = 0 ;
26082 int res1 = 0 ;
26083 long val2 ;
26084 int ecode2 = 0 ;
26085 PyObject *swig_obj[2] ;
26086
26087 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
26088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26089 if (!SWIG_IsOK(res1)) {
26090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26091 }
26092 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26093 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
26094 if (!SWIG_IsOK(ecode2)) {
26095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
26096 }
26097 arg2 = static_cast< long >(val2);
26098 if (arg1) (arg1)->m_keyCode = arg2;
26099
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26110 long result;
26111 void *argp1 = 0 ;
26112 int res1 = 0 ;
26113 PyObject *swig_obj[1] ;
26114
26115 if (!args) SWIG_fail;
26116 swig_obj[0] = args;
26117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26120 }
26121 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26122 result = (long) ((arg1)->m_keyCode);
26123 resultobj = SWIG_From_long(static_cast< long >(result));
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26131 PyObject *resultobj = 0;
26132 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26133 bool arg2 ;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 bool val2 ;
26137 int ecode2 = 0 ;
26138 PyObject *swig_obj[2] ;
26139
26140 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
26141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26142 if (!SWIG_IsOK(res1)) {
26143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26144 }
26145 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26146 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26147 if (!SWIG_IsOK(ecode2)) {
26148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
26149 }
26150 arg2 = static_cast< bool >(val2);
26151 if (arg1) (arg1)->m_controlDown = arg2;
26152
26153 resultobj = SWIG_Py_Void();
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26161 PyObject *resultobj = 0;
26162 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26163 bool result;
26164 void *argp1 = 0 ;
26165 int res1 = 0 ;
26166 PyObject *swig_obj[1] ;
26167
26168 if (!args) SWIG_fail;
26169 swig_obj[0] = args;
26170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26171 if (!SWIG_IsOK(res1)) {
26172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26173 }
26174 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26175 result = (bool) ((arg1)->m_controlDown);
26176 {
26177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26178 }
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26186 PyObject *resultobj = 0;
26187 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26188 bool arg2 ;
26189 void *argp1 = 0 ;
26190 int res1 = 0 ;
26191 bool val2 ;
26192 int ecode2 = 0 ;
26193 PyObject *swig_obj[2] ;
26194
26195 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
26196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26197 if (!SWIG_IsOK(res1)) {
26198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26199 }
26200 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26201 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26202 if (!SWIG_IsOK(ecode2)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
26204 }
26205 arg2 = static_cast< bool >(val2);
26206 if (arg1) (arg1)->m_shiftDown = arg2;
26207
26208 resultobj = SWIG_Py_Void();
26209 return resultobj;
26210 fail:
26211 return NULL;
26212 }
26213
26214
26215 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26216 PyObject *resultobj = 0;
26217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26218 bool result;
26219 void *argp1 = 0 ;
26220 int res1 = 0 ;
26221 PyObject *swig_obj[1] ;
26222
26223 if (!args) SWIG_fail;
26224 swig_obj[0] = args;
26225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26226 if (!SWIG_IsOK(res1)) {
26227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26228 }
26229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26230 result = (bool) ((arg1)->m_shiftDown);
26231 {
26232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26233 }
26234 return resultobj;
26235 fail:
26236 return NULL;
26237 }
26238
26239
26240 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26241 PyObject *resultobj = 0;
26242 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26243 bool arg2 ;
26244 void *argp1 = 0 ;
26245 int res1 = 0 ;
26246 bool val2 ;
26247 int ecode2 = 0 ;
26248 PyObject *swig_obj[2] ;
26249
26250 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
26251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26252 if (!SWIG_IsOK(res1)) {
26253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26254 }
26255 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26256 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26257 if (!SWIG_IsOK(ecode2)) {
26258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
26259 }
26260 arg2 = static_cast< bool >(val2);
26261 if (arg1) (arg1)->m_altDown = arg2;
26262
26263 resultobj = SWIG_Py_Void();
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26271 PyObject *resultobj = 0;
26272 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26273 bool result;
26274 void *argp1 = 0 ;
26275 int res1 = 0 ;
26276 PyObject *swig_obj[1] ;
26277
26278 if (!args) SWIG_fail;
26279 swig_obj[0] = args;
26280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26281 if (!SWIG_IsOK(res1)) {
26282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26283 }
26284 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26285 result = (bool) ((arg1)->m_altDown);
26286 {
26287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26288 }
26289 return resultobj;
26290 fail:
26291 return NULL;
26292 }
26293
26294
26295 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26296 PyObject *resultobj = 0;
26297 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26298 bool arg2 ;
26299 void *argp1 = 0 ;
26300 int res1 = 0 ;
26301 bool val2 ;
26302 int ecode2 = 0 ;
26303 PyObject *swig_obj[2] ;
26304
26305 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
26306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26307 if (!SWIG_IsOK(res1)) {
26308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26309 }
26310 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26311 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26312 if (!SWIG_IsOK(ecode2)) {
26313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
26314 }
26315 arg2 = static_cast< bool >(val2);
26316 if (arg1) (arg1)->m_metaDown = arg2;
26317
26318 resultobj = SWIG_Py_Void();
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26326 PyObject *resultobj = 0;
26327 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26328 bool result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 PyObject *swig_obj[1] ;
26332
26333 if (!args) SWIG_fail;
26334 swig_obj[0] = args;
26335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26338 }
26339 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26340 result = (bool) ((arg1)->m_metaDown);
26341 {
26342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26343 }
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26351 PyObject *resultobj = 0;
26352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26353 bool arg2 ;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 bool val2 ;
26357 int ecode2 = 0 ;
26358 PyObject *swig_obj[2] ;
26359
26360 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
26361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26362 if (!SWIG_IsOK(res1)) {
26363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26364 }
26365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26366 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26367 if (!SWIG_IsOK(ecode2)) {
26368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
26369 }
26370 arg2 = static_cast< bool >(val2);
26371 if (arg1) (arg1)->m_scanCode = arg2;
26372
26373 resultobj = SWIG_Py_Void();
26374 return resultobj;
26375 fail:
26376 return NULL;
26377 }
26378
26379
26380 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26381 PyObject *resultobj = 0;
26382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26383 bool result;
26384 void *argp1 = 0 ;
26385 int res1 = 0 ;
26386 PyObject *swig_obj[1] ;
26387
26388 if (!args) SWIG_fail;
26389 swig_obj[0] = args;
26390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26391 if (!SWIG_IsOK(res1)) {
26392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26393 }
26394 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26395 result = (bool) ((arg1)->m_scanCode);
26396 {
26397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26398 }
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26406 PyObject *resultobj = 0;
26407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26408 unsigned int arg2 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 unsigned int val2 ;
26412 int ecode2 = 0 ;
26413 PyObject *swig_obj[2] ;
26414
26415 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
26416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26417 if (!SWIG_IsOK(res1)) {
26418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26419 }
26420 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26421 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26422 if (!SWIG_IsOK(ecode2)) {
26423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
26424 }
26425 arg2 = static_cast< unsigned int >(val2);
26426 if (arg1) (arg1)->m_rawCode = arg2;
26427
26428 resultobj = SWIG_Py_Void();
26429 return resultobj;
26430 fail:
26431 return NULL;
26432 }
26433
26434
26435 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26436 PyObject *resultobj = 0;
26437 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26438 unsigned int result;
26439 void *argp1 = 0 ;
26440 int res1 = 0 ;
26441 PyObject *swig_obj[1] ;
26442
26443 if (!args) SWIG_fail;
26444 swig_obj[0] = args;
26445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26446 if (!SWIG_IsOK(res1)) {
26447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26448 }
26449 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26450 result = (unsigned int) ((arg1)->m_rawCode);
26451 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26452 return resultobj;
26453 fail:
26454 return NULL;
26455 }
26456
26457
26458 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26459 PyObject *resultobj = 0;
26460 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26461 unsigned int arg2 ;
26462 void *argp1 = 0 ;
26463 int res1 = 0 ;
26464 unsigned int val2 ;
26465 int ecode2 = 0 ;
26466 PyObject *swig_obj[2] ;
26467
26468 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
26469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26470 if (!SWIG_IsOK(res1)) {
26471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26472 }
26473 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26474 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26475 if (!SWIG_IsOK(ecode2)) {
26476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
26477 }
26478 arg2 = static_cast< unsigned int >(val2);
26479 if (arg1) (arg1)->m_rawFlags = arg2;
26480
26481 resultobj = SWIG_Py_Void();
26482 return resultobj;
26483 fail:
26484 return NULL;
26485 }
26486
26487
26488 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26489 PyObject *resultobj = 0;
26490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26491 unsigned int result;
26492 void *argp1 = 0 ;
26493 int res1 = 0 ;
26494 PyObject *swig_obj[1] ;
26495
26496 if (!args) SWIG_fail;
26497 swig_obj[0] = args;
26498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26499 if (!SWIG_IsOK(res1)) {
26500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26501 }
26502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26503 result = (unsigned int) ((arg1)->m_rawFlags);
26504 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26505 return resultobj;
26506 fail:
26507 return NULL;
26508 }
26509
26510
26511 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26512 PyObject *obj;
26513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26514 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
26515 return SWIG_Py_Void();
26516 }
26517
26518 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 return SWIG_Python_InitShadowInstance(args);
26520 }
26521
26522 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26523 PyObject *resultobj = 0;
26524 wxSize const &arg1_defvalue = wxDefaultSize ;
26525 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26526 int arg2 = (int) 0 ;
26527 wxSizeEvent *result = 0 ;
26528 wxSize temp1 ;
26529 int val2 ;
26530 int ecode2 = 0 ;
26531 PyObject * obj0 = 0 ;
26532 PyObject * obj1 = 0 ;
26533 char * kwnames[] = {
26534 (char *) "sz",(char *) "winid", NULL
26535 };
26536
26537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26538 if (obj0) {
26539 {
26540 arg1 = &temp1;
26541 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26542 }
26543 }
26544 if (obj1) {
26545 ecode2 = SWIG_AsVal_int(obj1, &val2);
26546 if (!SWIG_IsOK(ecode2)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26548 }
26549 arg2 = static_cast< int >(val2);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *resultobj = 0;
26566 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26567 wxSize result;
26568 void *argp1 = 0 ;
26569 int res1 = 0 ;
26570 PyObject *swig_obj[1] ;
26571
26572 if (!args) SWIG_fail;
26573 swig_obj[0] = args;
26574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26575 if (!SWIG_IsOK(res1)) {
26576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26577 }
26578 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26579 {
26580 PyThreadState* __tstate = wxPyBeginAllowThreads();
26581 result = ((wxSizeEvent const *)arg1)->GetSize();
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26593 PyObject *resultobj = 0;
26594 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26595 wxRect result;
26596 void *argp1 = 0 ;
26597 int res1 = 0 ;
26598 PyObject *swig_obj[1] ;
26599
26600 if (!args) SWIG_fail;
26601 swig_obj[0] = args;
26602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26603 if (!SWIG_IsOK(res1)) {
26604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26605 }
26606 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26607 {
26608 PyThreadState* __tstate = wxPyBeginAllowThreads();
26609 result = ((wxSizeEvent const *)arg1)->GetRect();
26610 wxPyEndAllowThreads(__tstate);
26611 if (PyErr_Occurred()) SWIG_fail;
26612 }
26613 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26621 PyObject *resultobj = 0;
26622 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26623 wxRect arg2 ;
26624 void *argp1 = 0 ;
26625 int res1 = 0 ;
26626 void *argp2 ;
26627 int res2 = 0 ;
26628 PyObject * obj0 = 0 ;
26629 PyObject * obj1 = 0 ;
26630 char * kwnames[] = {
26631 (char *) "self",(char *) "rect", NULL
26632 };
26633
26634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26636 if (!SWIG_IsOK(res1)) {
26637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26638 }
26639 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26640 {
26641 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26642 if (!SWIG_IsOK(res2)) {
26643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26644 }
26645 if (!argp2) {
26646 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26647 } else {
26648 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26649 arg2 = *temp;
26650 if (SWIG_IsNewObj(res2)) delete temp;
26651 }
26652 }
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 (arg1)->SetRect(arg2);
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 resultobj = SWIG_Py_Void();
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj = 0;
26668 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26669 wxSize arg2 ;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 void *argp2 ;
26673 int res2 = 0 ;
26674 PyObject * obj0 = 0 ;
26675 PyObject * obj1 = 0 ;
26676 char * kwnames[] = {
26677 (char *) "self",(char *) "size", NULL
26678 };
26679
26680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26684 }
26685 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26686 {
26687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26688 if (!SWIG_IsOK(res2)) {
26689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26690 }
26691 if (!argp2) {
26692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26693 } else {
26694 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26695 arg2 = *temp;
26696 if (SWIG_IsNewObj(res2)) delete temp;
26697 }
26698 }
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 wxSizeEvent_SetSize(arg1,arg2);
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_Py_Void();
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26713 PyObject *resultobj = 0;
26714 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26715 wxSize *arg2 = (wxSize *) 0 ;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 void *argp2 = 0 ;
26719 int res2 = 0 ;
26720 PyObject *swig_obj[2] ;
26721
26722 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26726 }
26727 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26729 if (!SWIG_IsOK(res2)) {
26730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26731 }
26732 arg2 = reinterpret_cast< wxSize * >(argp2);
26733 if (arg1) (arg1)->m_size = *arg2;
26734
26735 resultobj = SWIG_Py_Void();
26736 return resultobj;
26737 fail:
26738 return NULL;
26739 }
26740
26741
26742 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26743 PyObject *resultobj = 0;
26744 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26745 wxSize *result = 0 ;
26746 void *argp1 = 0 ;
26747 int res1 = 0 ;
26748 PyObject *swig_obj[1] ;
26749
26750 if (!args) SWIG_fail;
26751 swig_obj[0] = args;
26752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26753 if (!SWIG_IsOK(res1)) {
26754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26755 }
26756 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26757 result = (wxSize *)& ((arg1)->m_size);
26758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26759 return resultobj;
26760 fail:
26761 return NULL;
26762 }
26763
26764
26765 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26766 PyObject *resultobj = 0;
26767 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26768 wxRect *arg2 = (wxRect *) 0 ;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 void *argp2 = 0 ;
26772 int res2 = 0 ;
26773 PyObject *swig_obj[2] ;
26774
26775 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26777 if (!SWIG_IsOK(res1)) {
26778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26779 }
26780 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26781 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26782 if (!SWIG_IsOK(res2)) {
26783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26784 }
26785 arg2 = reinterpret_cast< wxRect * >(argp2);
26786 if (arg1) (arg1)->m_rect = *arg2;
26787
26788 resultobj = SWIG_Py_Void();
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *resultobj = 0;
26797 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26798 wxRect *result = 0 ;
26799 void *argp1 = 0 ;
26800 int res1 = 0 ;
26801 PyObject *swig_obj[1] ;
26802
26803 if (!args) SWIG_fail;
26804 swig_obj[0] = args;
26805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26806 if (!SWIG_IsOK(res1)) {
26807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26808 }
26809 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26810 result = (wxRect *)& ((arg1)->m_rect);
26811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26812 return resultobj;
26813 fail:
26814 return NULL;
26815 }
26816
26817
26818 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26819 PyObject *obj;
26820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26821 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26822 return SWIG_Py_Void();
26823 }
26824
26825 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26826 return SWIG_Python_InitShadowInstance(args);
26827 }
26828
26829 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26832 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26833 int arg2 = (int) 0 ;
26834 wxMoveEvent *result = 0 ;
26835 wxPoint temp1 ;
26836 int val2 ;
26837 int ecode2 = 0 ;
26838 PyObject * obj0 = 0 ;
26839 PyObject * obj1 = 0 ;
26840 char * kwnames[] = {
26841 (char *) "pos",(char *) "winid", NULL
26842 };
26843
26844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26845 if (obj0) {
26846 {
26847 arg1 = &temp1;
26848 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26849 }
26850 }
26851 if (obj1) {
26852 ecode2 = SWIG_AsVal_int(obj1, &val2);
26853 if (!SWIG_IsOK(ecode2)) {
26854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26855 }
26856 arg2 = static_cast< int >(val2);
26857 }
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26874 wxPoint result;
26875 void *argp1 = 0 ;
26876 int res1 = 0 ;
26877 PyObject *swig_obj[1] ;
26878
26879 if (!args) SWIG_fail;
26880 swig_obj[0] = args;
26881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26884 }
26885 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = ((wxMoveEvent const *)arg1)->GetPosition();
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26893 return resultobj;
26894 fail:
26895 return NULL;
26896 }
26897
26898
26899 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26900 PyObject *resultobj = 0;
26901 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26902 wxRect result;
26903 void *argp1 = 0 ;
26904 int res1 = 0 ;
26905 PyObject *swig_obj[1] ;
26906
26907 if (!args) SWIG_fail;
26908 swig_obj[0] = args;
26909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26910 if (!SWIG_IsOK(res1)) {
26911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26912 }
26913 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 result = ((wxMoveEvent const *)arg1)->GetRect();
26917 wxPyEndAllowThreads(__tstate);
26918 if (PyErr_Occurred()) SWIG_fail;
26919 }
26920 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26921 return resultobj;
26922 fail:
26923 return NULL;
26924 }
26925
26926
26927 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26928 PyObject *resultobj = 0;
26929 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26930 wxRect *arg2 = 0 ;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 wxRect temp2 ;
26934 PyObject * obj0 = 0 ;
26935 PyObject * obj1 = 0 ;
26936 char * kwnames[] = {
26937 (char *) "self",(char *) "rect", NULL
26938 };
26939
26940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26942 if (!SWIG_IsOK(res1)) {
26943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26944 }
26945 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26946 {
26947 arg2 = &temp2;
26948 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26949 }
26950 {
26951 PyThreadState* __tstate = wxPyBeginAllowThreads();
26952 (arg1)->SetRect((wxRect const &)*arg2);
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 resultobj = SWIG_Py_Void();
26957 return resultobj;
26958 fail:
26959 return NULL;
26960 }
26961
26962
26963 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26964 PyObject *resultobj = 0;
26965 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26966 wxPoint *arg2 = 0 ;
26967 void *argp1 = 0 ;
26968 int res1 = 0 ;
26969 wxPoint temp2 ;
26970 PyObject * obj0 = 0 ;
26971 PyObject * obj1 = 0 ;
26972 char * kwnames[] = {
26973 (char *) "self",(char *) "pos", NULL
26974 };
26975
26976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26978 if (!SWIG_IsOK(res1)) {
26979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26980 }
26981 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26982 {
26983 arg2 = &temp2;
26984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26985 }
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 (arg1)->SetPosition((wxPoint const &)*arg2);
26989 wxPyEndAllowThreads(__tstate);
26990 if (PyErr_Occurred()) SWIG_fail;
26991 }
26992 resultobj = SWIG_Py_Void();
26993 return resultobj;
26994 fail:
26995 return NULL;
26996 }
26997
26998
26999 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27000 PyObject *obj;
27001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27002 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
27003 return SWIG_Py_Void();
27004 }
27005
27006 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27007 return SWIG_Python_InitShadowInstance(args);
27008 }
27009
27010 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27011 PyObject *resultobj = 0;
27012 int arg1 = (int) 0 ;
27013 wxPaintEvent *result = 0 ;
27014 int val1 ;
27015 int ecode1 = 0 ;
27016 PyObject * obj0 = 0 ;
27017 char * kwnames[] = {
27018 (char *) "Id", NULL
27019 };
27020
27021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
27022 if (obj0) {
27023 ecode1 = SWIG_AsVal_int(obj0, &val1);
27024 if (!SWIG_IsOK(ecode1)) {
27025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
27026 }
27027 arg1 = static_cast< int >(val1);
27028 }
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (wxPaintEvent *)new wxPaintEvent(arg1);
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
27036 return resultobj;
27037 fail:
27038 return NULL;
27039 }
27040
27041
27042 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27043 PyObject *obj;
27044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27045 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
27046 return SWIG_Py_Void();
27047 }
27048
27049 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27050 return SWIG_Python_InitShadowInstance(args);
27051 }
27052
27053 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27054 PyObject *resultobj = 0;
27055 int arg1 = (int) 0 ;
27056 wxNcPaintEvent *result = 0 ;
27057 int val1 ;
27058 int ecode1 = 0 ;
27059 PyObject * obj0 = 0 ;
27060 char * kwnames[] = {
27061 (char *) "winid", NULL
27062 };
27063
27064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
27065 if (obj0) {
27066 ecode1 = SWIG_AsVal_int(obj0, &val1);
27067 if (!SWIG_IsOK(ecode1)) {
27068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
27069 }
27070 arg1 = static_cast< int >(val1);
27071 }
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
27075 wxPyEndAllowThreads(__tstate);
27076 if (PyErr_Occurred()) SWIG_fail;
27077 }
27078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27086 PyObject *obj;
27087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27088 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
27089 return SWIG_Py_Void();
27090 }
27091
27092 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27093 return SWIG_Python_InitShadowInstance(args);
27094 }
27095
27096 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27097 PyObject *resultobj = 0;
27098 int arg1 = (int) 0 ;
27099 wxDC *arg2 = (wxDC *) NULL ;
27100 wxEraseEvent *result = 0 ;
27101 int val1 ;
27102 int ecode1 = 0 ;
27103 void *argp2 = 0 ;
27104 int res2 = 0 ;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 char * kwnames[] = {
27108 (char *) "Id",(char *) "dc", NULL
27109 };
27110
27111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27112 if (obj0) {
27113 ecode1 = SWIG_AsVal_int(obj0, &val1);
27114 if (!SWIG_IsOK(ecode1)) {
27115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
27116 }
27117 arg1 = static_cast< int >(val1);
27118 }
27119 if (obj1) {
27120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27121 if (!SWIG_IsOK(res2)) {
27122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
27123 }
27124 arg2 = reinterpret_cast< wxDC * >(argp2);
27125 }
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27140 PyObject *resultobj = 0;
27141 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
27142 wxDC *result = 0 ;
27143 void *argp1 = 0 ;
27144 int res1 = 0 ;
27145 PyObject *swig_obj[1] ;
27146
27147 if (!args) SWIG_fail;
27148 swig_obj[0] = args;
27149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
27150 if (!SWIG_IsOK(res1)) {
27151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
27152 }
27153 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
27157 wxPyEndAllowThreads(__tstate);
27158 if (PyErr_Occurred()) SWIG_fail;
27159 }
27160 {
27161 resultobj = wxPyMake_wxObject(result, (bool)0);
27162 }
27163 return resultobj;
27164 fail:
27165 return NULL;
27166 }
27167
27168
27169 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27170 PyObject *obj;
27171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27172 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
27173 return SWIG_Py_Void();
27174 }
27175
27176 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27177 return SWIG_Python_InitShadowInstance(args);
27178 }
27179
27180 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27183 int arg2 = (int) 0 ;
27184 wxFocusEvent *result = 0 ;
27185 int val1 ;
27186 int ecode1 = 0 ;
27187 int val2 ;
27188 int ecode2 = 0 ;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char * kwnames[] = {
27192 (char *) "type",(char *) "winid", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27196 if (obj0) {
27197 ecode1 = SWIG_AsVal_int(obj0, &val1);
27198 if (!SWIG_IsOK(ecode1)) {
27199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27200 }
27201 arg1 = static_cast< wxEventType >(val1);
27202 }
27203 if (obj1) {
27204 ecode2 = SWIG_AsVal_int(obj1, &val2);
27205 if (!SWIG_IsOK(ecode2)) {
27206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
27207 }
27208 arg2 = static_cast< int >(val2);
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 PyObject *resultobj = 0;
27225 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27226 wxWindow *result = 0 ;
27227 void *argp1 = 0 ;
27228 int res1 = 0 ;
27229 PyObject *swig_obj[1] ;
27230
27231 if (!args) SWIG_fail;
27232 swig_obj[0] = args;
27233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27234 if (!SWIG_IsOK(res1)) {
27235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
27236 }
27237 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27238 {
27239 PyThreadState* __tstate = wxPyBeginAllowThreads();
27240 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 {
27245 resultobj = wxPyMake_wxObject(result, (bool)0);
27246 }
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj = 0;
27255 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27256 wxWindow *arg2 = (wxWindow *) 0 ;
27257 void *argp1 = 0 ;
27258 int res1 = 0 ;
27259 void *argp2 = 0 ;
27260 int res2 = 0 ;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 char * kwnames[] = {
27264 (char *) "self",(char *) "win", NULL
27265 };
27266
27267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27269 if (!SWIG_IsOK(res1)) {
27270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
27271 }
27272 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27274 if (!SWIG_IsOK(res2)) {
27275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27276 }
27277 arg2 = reinterpret_cast< wxWindow * >(argp2);
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 (arg1)->SetWindow(arg2);
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_Py_Void();
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *obj;
27293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27294 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
27295 return SWIG_Py_Void();
27296 }
27297
27298 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27299 return SWIG_Python_InitShadowInstance(args);
27300 }
27301
27302 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27303 PyObject *resultobj = 0;
27304 wxWindow *arg1 = (wxWindow *) NULL ;
27305 wxChildFocusEvent *result = 0 ;
27306 void *argp1 = 0 ;
27307 int res1 = 0 ;
27308 PyObject * obj0 = 0 ;
27309 char * kwnames[] = {
27310 (char *) "win", NULL
27311 };
27312
27313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
27314 if (obj0) {
27315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27316 if (!SWIG_IsOK(res1)) {
27317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27318 }
27319 arg1 = reinterpret_cast< wxWindow * >(argp1);
27320 }
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
27324 wxPyEndAllowThreads(__tstate);
27325 if (PyErr_Occurred()) SWIG_fail;
27326 }
27327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27335 PyObject *resultobj = 0;
27336 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
27337 wxWindow *result = 0 ;
27338 void *argp1 = 0 ;
27339 int res1 = 0 ;
27340 PyObject *swig_obj[1] ;
27341
27342 if (!args) SWIG_fail;
27343 swig_obj[0] = args;
27344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
27347 }
27348 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
27349 {
27350 PyThreadState* __tstate = wxPyBeginAllowThreads();
27351 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
27352 wxPyEndAllowThreads(__tstate);
27353 if (PyErr_Occurred()) SWIG_fail;
27354 }
27355 {
27356 resultobj = wxPyMake_wxObject(result, (bool)0);
27357 }
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27365 PyObject *obj;
27366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27367 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
27368 return SWIG_Py_Void();
27369 }
27370
27371 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27372 return SWIG_Python_InitShadowInstance(args);
27373 }
27374
27375 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj = 0;
27377 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27378 bool arg2 = (bool) true ;
27379 int arg3 = (int) 0 ;
27380 wxActivateEvent *result = 0 ;
27381 int val1 ;
27382 int ecode1 = 0 ;
27383 bool val2 ;
27384 int ecode2 = 0 ;
27385 int val3 ;
27386 int ecode3 = 0 ;
27387 PyObject * obj0 = 0 ;
27388 PyObject * obj1 = 0 ;
27389 PyObject * obj2 = 0 ;
27390 char * kwnames[] = {
27391 (char *) "type",(char *) "active",(char *) "Id", NULL
27392 };
27393
27394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27395 if (obj0) {
27396 ecode1 = SWIG_AsVal_int(obj0, &val1);
27397 if (!SWIG_IsOK(ecode1)) {
27398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27399 }
27400 arg1 = static_cast< wxEventType >(val1);
27401 }
27402 if (obj1) {
27403 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27404 if (!SWIG_IsOK(ecode2)) {
27405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
27406 }
27407 arg2 = static_cast< bool >(val2);
27408 }
27409 if (obj2) {
27410 ecode3 = SWIG_AsVal_int(obj2, &val3);
27411 if (!SWIG_IsOK(ecode3)) {
27412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
27413 }
27414 arg3 = static_cast< int >(val3);
27415 }
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
27432 bool result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 PyObject *swig_obj[1] ;
27436
27437 if (!args) SWIG_fail;
27438 swig_obj[0] = args;
27439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
27440 if (!SWIG_IsOK(res1)) {
27441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
27442 }
27443 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 {
27451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27452 }
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27460 PyObject *obj;
27461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27462 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
27463 return SWIG_Py_Void();
27464 }
27465
27466 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27467 return SWIG_Python_InitShadowInstance(args);
27468 }
27469
27470 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj = 0;
27472 int arg1 = (int) 0 ;
27473 wxInitDialogEvent *result = 0 ;
27474 int val1 ;
27475 int ecode1 = 0 ;
27476 PyObject * obj0 = 0 ;
27477 char * kwnames[] = {
27478 (char *) "Id", NULL
27479 };
27480
27481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
27482 if (obj0) {
27483 ecode1 = SWIG_AsVal_int(obj0, &val1);
27484 if (!SWIG_IsOK(ecode1)) {
27485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
27486 }
27487 arg1 = static_cast< int >(val1);
27488 }
27489 {
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
27492 wxPyEndAllowThreads(__tstate);
27493 if (PyErr_Occurred()) SWIG_fail;
27494 }
27495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27503 PyObject *obj;
27504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27505 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
27506 return SWIG_Py_Void();
27507 }
27508
27509 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27510 return SWIG_Python_InitShadowInstance(args);
27511 }
27512
27513 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27514 PyObject *resultobj = 0;
27515 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27516 int arg2 = (int) 0 ;
27517 wxMenu *arg3 = (wxMenu *) NULL ;
27518 wxMenuEvent *result = 0 ;
27519 int val1 ;
27520 int ecode1 = 0 ;
27521 int val2 ;
27522 int ecode2 = 0 ;
27523 void *argp3 = 0 ;
27524 int res3 = 0 ;
27525 PyObject * obj0 = 0 ;
27526 PyObject * obj1 = 0 ;
27527 PyObject * obj2 = 0 ;
27528 char * kwnames[] = {
27529 (char *) "type",(char *) "winid",(char *) "menu", NULL
27530 };
27531
27532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27533 if (obj0) {
27534 ecode1 = SWIG_AsVal_int(obj0, &val1);
27535 if (!SWIG_IsOK(ecode1)) {
27536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27537 }
27538 arg1 = static_cast< wxEventType >(val1);
27539 }
27540 if (obj1) {
27541 ecode2 = SWIG_AsVal_int(obj1, &val2);
27542 if (!SWIG_IsOK(ecode2)) {
27543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27544 }
27545 arg2 = static_cast< int >(val2);
27546 }
27547 if (obj2) {
27548 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27549 if (!SWIG_IsOK(res3)) {
27550 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27551 }
27552 arg3 = reinterpret_cast< wxMenu * >(argp3);
27553 }
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27570 int result;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 PyObject *swig_obj[1] ;
27574
27575 if (!args) SWIG_fail;
27576 swig_obj[0] = args;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27580 }
27581 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_From_int(static_cast< int >(result));
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27598 bool result;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27608 }
27609 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 {
27617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27618 }
27619 return resultobj;
27620 fail:
27621 return NULL;
27622 }
27623
27624
27625 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27626 PyObject *resultobj = 0;
27627 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27628 wxMenu *result = 0 ;
27629 void *argp1 = 0 ;
27630 int res1 = 0 ;
27631 PyObject *swig_obj[1] ;
27632
27633 if (!args) SWIG_fail;
27634 swig_obj[0] = args;
27635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27636 if (!SWIG_IsOK(res1)) {
27637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27638 }
27639 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27640 {
27641 PyThreadState* __tstate = wxPyBeginAllowThreads();
27642 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 {
27647 resultobj = wxPyMake_wxObject(result, (bool)0);
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *obj;
27657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27659 return SWIG_Py_Void();
27660 }
27661
27662 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 return SWIG_Python_InitShadowInstance(args);
27664 }
27665
27666 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj = 0;
27668 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27669 int arg2 = (int) 0 ;
27670 wxCloseEvent *result = 0 ;
27671 int val1 ;
27672 int ecode1 = 0 ;
27673 int val2 ;
27674 int ecode2 = 0 ;
27675 PyObject * obj0 = 0 ;
27676 PyObject * obj1 = 0 ;
27677 char * kwnames[] = {
27678 (char *) "type",(char *) "winid", NULL
27679 };
27680
27681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27682 if (obj0) {
27683 ecode1 = SWIG_AsVal_int(obj0, &val1);
27684 if (!SWIG_IsOK(ecode1)) {
27685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27686 }
27687 arg1 = static_cast< wxEventType >(val1);
27688 }
27689 if (obj1) {
27690 ecode2 = SWIG_AsVal_int(obj1, &val2);
27691 if (!SWIG_IsOK(ecode2)) {
27692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27693 }
27694 arg2 = static_cast< int >(val2);
27695 }
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27710 PyObject *resultobj = 0;
27711 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27712 bool arg2 ;
27713 void *argp1 = 0 ;
27714 int res1 = 0 ;
27715 bool val2 ;
27716 int ecode2 = 0 ;
27717 PyObject * obj0 = 0 ;
27718 PyObject * obj1 = 0 ;
27719 char * kwnames[] = {
27720 (char *) "self",(char *) "logOff", NULL
27721 };
27722
27723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27725 if (!SWIG_IsOK(res1)) {
27726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27727 }
27728 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27729 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27730 if (!SWIG_IsOK(ecode2)) {
27731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27732 }
27733 arg2 = static_cast< bool >(val2);
27734 {
27735 PyThreadState* __tstate = wxPyBeginAllowThreads();
27736 (arg1)->SetLoggingOff(arg2);
27737 wxPyEndAllowThreads(__tstate);
27738 if (PyErr_Occurred()) SWIG_fail;
27739 }
27740 resultobj = SWIG_Py_Void();
27741 return resultobj;
27742 fail:
27743 return NULL;
27744 }
27745
27746
27747 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27748 PyObject *resultobj = 0;
27749 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27750 bool result;
27751 void *argp1 = 0 ;
27752 int res1 = 0 ;
27753 PyObject *swig_obj[1] ;
27754
27755 if (!args) SWIG_fail;
27756 swig_obj[0] = args;
27757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27758 if (!SWIG_IsOK(res1)) {
27759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27760 }
27761 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27762 {
27763 PyThreadState* __tstate = wxPyBeginAllowThreads();
27764 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27765 wxPyEndAllowThreads(__tstate);
27766 if (PyErr_Occurred()) SWIG_fail;
27767 }
27768 {
27769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27770 }
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj = 0;
27779 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27780 bool arg2 = (bool) true ;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 bool val2 ;
27784 int ecode2 = 0 ;
27785 PyObject * obj0 = 0 ;
27786 PyObject * obj1 = 0 ;
27787 char * kwnames[] = {
27788 (char *) "self",(char *) "veto", NULL
27789 };
27790
27791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27793 if (!SWIG_IsOK(res1)) {
27794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27795 }
27796 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27797 if (obj1) {
27798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27799 if (!SWIG_IsOK(ecode2)) {
27800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27801 }
27802 arg2 = static_cast< bool >(val2);
27803 }
27804 {
27805 PyThreadState* __tstate = wxPyBeginAllowThreads();
27806 (arg1)->Veto(arg2);
27807 wxPyEndAllowThreads(__tstate);
27808 if (PyErr_Occurred()) SWIG_fail;
27809 }
27810 resultobj = SWIG_Py_Void();
27811 return resultobj;
27812 fail:
27813 return NULL;
27814 }
27815
27816
27817 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27818 PyObject *resultobj = 0;
27819 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27820 bool result;
27821 void *argp1 = 0 ;
27822 int res1 = 0 ;
27823 PyObject *swig_obj[1] ;
27824
27825 if (!args) SWIG_fail;
27826 swig_obj[0] = args;
27827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27828 if (!SWIG_IsOK(res1)) {
27829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27830 }
27831 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27832 {
27833 PyThreadState* __tstate = wxPyBeginAllowThreads();
27834 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 {
27839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27840 }
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27848 PyObject *resultobj = 0;
27849 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27850 bool arg2 ;
27851 void *argp1 = 0 ;
27852 int res1 = 0 ;
27853 bool val2 ;
27854 int ecode2 = 0 ;
27855 PyObject * obj0 = 0 ;
27856 PyObject * obj1 = 0 ;
27857 char * kwnames[] = {
27858 (char *) "self",(char *) "canVeto", NULL
27859 };
27860
27861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27863 if (!SWIG_IsOK(res1)) {
27864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27865 }
27866 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27868 if (!SWIG_IsOK(ecode2)) {
27869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27870 }
27871 arg2 = static_cast< bool >(val2);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 (arg1)->SetCanVeto(arg2);
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 resultobj = SWIG_Py_Void();
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27888 bool result;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 PyObject *swig_obj[1] ;
27892
27893 if (!args) SWIG_fail;
27894 swig_obj[0] = args;
27895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27898 }
27899 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27916 PyObject *obj;
27917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27918 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27919 return SWIG_Py_Void();
27920 }
27921
27922 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27923 return SWIG_Python_InitShadowInstance(args);
27924 }
27925
27926 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj = 0;
27928 int arg1 = (int) 0 ;
27929 bool arg2 = (bool) false ;
27930 wxShowEvent *result = 0 ;
27931 int val1 ;
27932 int ecode1 = 0 ;
27933 bool val2 ;
27934 int ecode2 = 0 ;
27935 PyObject * obj0 = 0 ;
27936 PyObject * obj1 = 0 ;
27937 char * kwnames[] = {
27938 (char *) "winid",(char *) "show", NULL
27939 };
27940
27941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27942 if (obj0) {
27943 ecode1 = SWIG_AsVal_int(obj0, &val1);
27944 if (!SWIG_IsOK(ecode1)) {
27945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27946 }
27947 arg1 = static_cast< int >(val1);
27948 }
27949 if (obj1) {
27950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27951 if (!SWIG_IsOK(ecode2)) {
27952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27953 }
27954 arg2 = static_cast< bool >(val2);
27955 }
27956 {
27957 PyThreadState* __tstate = wxPyBeginAllowThreads();
27958 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27959 wxPyEndAllowThreads(__tstate);
27960 if (PyErr_Occurred()) SWIG_fail;
27961 }
27962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27963 return resultobj;
27964 fail:
27965 return NULL;
27966 }
27967
27968
27969 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj = 0;
27971 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27972 bool arg2 ;
27973 void *argp1 = 0 ;
27974 int res1 = 0 ;
27975 bool val2 ;
27976 int ecode2 = 0 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char * kwnames[] = {
27980 (char *) "self",(char *) "show", NULL
27981 };
27982
27983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27985 if (!SWIG_IsOK(res1)) {
27986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27987 }
27988 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27990 if (!SWIG_IsOK(ecode2)) {
27991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27992 }
27993 arg2 = static_cast< bool >(val2);
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 (arg1)->SetShow(arg2);
27997 wxPyEndAllowThreads(__tstate);
27998 if (PyErr_Occurred()) SWIG_fail;
27999 }
28000 resultobj = SWIG_Py_Void();
28001 return resultobj;
28002 fail:
28003 return NULL;
28004 }
28005
28006
28007 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28008 PyObject *resultobj = 0;
28009 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
28010 bool result;
28011 void *argp1 = 0 ;
28012 int res1 = 0 ;
28013 PyObject *swig_obj[1] ;
28014
28015 if (!args) SWIG_fail;
28016 swig_obj[0] = args;
28017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28018 if (!SWIG_IsOK(res1)) {
28019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
28020 }
28021 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28022 {
28023 PyThreadState* __tstate = wxPyBeginAllowThreads();
28024 result = (bool)((wxShowEvent const *)arg1)->GetShow();
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 {
28029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28030 }
28031 return resultobj;
28032 fail:
28033 return NULL;
28034 }
28035
28036
28037 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28038 PyObject *obj;
28039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28040 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
28041 return SWIG_Py_Void();
28042 }
28043
28044 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28045 return SWIG_Python_InitShadowInstance(args);
28046 }
28047
28048 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28049 PyObject *resultobj = 0;
28050 int arg1 = (int) 0 ;
28051 bool arg2 = (bool) true ;
28052 wxIconizeEvent *result = 0 ;
28053 int val1 ;
28054 int ecode1 = 0 ;
28055 bool val2 ;
28056 int ecode2 = 0 ;
28057 PyObject * obj0 = 0 ;
28058 PyObject * obj1 = 0 ;
28059 char * kwnames[] = {
28060 (char *) "id",(char *) "iconized", NULL
28061 };
28062
28063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28064 if (obj0) {
28065 ecode1 = SWIG_AsVal_int(obj0, &val1);
28066 if (!SWIG_IsOK(ecode1)) {
28067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
28068 }
28069 arg1 = static_cast< int >(val1);
28070 }
28071 if (obj1) {
28072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28073 if (!SWIG_IsOK(ecode2)) {
28074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
28075 }
28076 arg2 = static_cast< bool >(val2);
28077 }
28078 {
28079 PyThreadState* __tstate = wxPyBeginAllowThreads();
28080 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28092 PyObject *resultobj = 0;
28093 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
28094 bool result;
28095 void *argp1 = 0 ;
28096 int res1 = 0 ;
28097 PyObject *swig_obj[1] ;
28098
28099 if (!args) SWIG_fail;
28100 swig_obj[0] = args;
28101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
28102 if (!SWIG_IsOK(res1)) {
28103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
28104 }
28105 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (bool)(arg1)->Iconized();
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28122 PyObject *obj;
28123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28124 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
28125 return SWIG_Py_Void();
28126 }
28127
28128 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28129 return SWIG_Python_InitShadowInstance(args);
28130 }
28131
28132 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 int arg1 = (int) 0 ;
28135 wxMaximizeEvent *result = 0 ;
28136 int val1 ;
28137 int ecode1 = 0 ;
28138 PyObject * obj0 = 0 ;
28139 char * kwnames[] = {
28140 (char *) "id", NULL
28141 };
28142
28143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
28144 if (obj0) {
28145 ecode1 = SWIG_AsVal_int(obj0, &val1);
28146 if (!SWIG_IsOK(ecode1)) {
28147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
28148 }
28149 arg1 = static_cast< int >(val1);
28150 }
28151 {
28152 PyThreadState* __tstate = wxPyBeginAllowThreads();
28153 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
28158 return resultobj;
28159 fail:
28160 return NULL;
28161 }
28162
28163
28164 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28165 PyObject *obj;
28166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28167 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
28168 return SWIG_Py_Void();
28169 }
28170
28171 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28172 return SWIG_Python_InitShadowInstance(args);
28173 }
28174
28175 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28176 PyObject *resultobj = 0;
28177 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28178 wxPoint result;
28179 void *argp1 = 0 ;
28180 int res1 = 0 ;
28181 PyObject *swig_obj[1] ;
28182
28183 if (!args) SWIG_fail;
28184 swig_obj[0] = args;
28185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28186 if (!SWIG_IsOK(res1)) {
28187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28188 }
28189 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (arg1)->GetPosition();
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28204 PyObject *resultobj = 0;
28205 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28206 int result;
28207 void *argp1 = 0 ;
28208 int res1 = 0 ;
28209 PyObject *swig_obj[1] ;
28210
28211 if (!args) SWIG_fail;
28212 swig_obj[0] = args;
28213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28214 if (!SWIG_IsOK(res1)) {
28215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28216 }
28217 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = (int)(arg1)->GetNumberOfFiles();
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_From_int(static_cast< int >(result));
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 PyObject *resultobj = 0;
28233 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28234 PyObject *result = 0 ;
28235 void *argp1 = 0 ;
28236 int res1 = 0 ;
28237 PyObject *swig_obj[1] ;
28238
28239 if (!args) SWIG_fail;
28240 swig_obj[0] = args;
28241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28242 if (!SWIG_IsOK(res1)) {
28243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28244 }
28245 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
28249 wxPyEndAllowThreads(__tstate);
28250 if (PyErr_Occurred()) SWIG_fail;
28251 }
28252 resultobj = result;
28253 return resultobj;
28254 fail:
28255 return NULL;
28256 }
28257
28258
28259 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 PyObject *obj;
28261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28262 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
28263 return SWIG_Py_Void();
28264 }
28265
28266 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj = 0;
28268 int arg1 = (int) 0 ;
28269 wxUpdateUIEvent *result = 0 ;
28270 int val1 ;
28271 int ecode1 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 char * kwnames[] = {
28274 (char *) "commandId", NULL
28275 };
28276
28277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
28278 if (obj0) {
28279 ecode1 = SWIG_AsVal_int(obj0, &val1);
28280 if (!SWIG_IsOK(ecode1)) {
28281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
28282 }
28283 arg1 = static_cast< int >(val1);
28284 }
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 PyObject *resultobj = 0;
28300 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28301 bool result;
28302 void *argp1 = 0 ;
28303 int res1 = 0 ;
28304 PyObject *swig_obj[1] ;
28305
28306 if (!args) SWIG_fail;
28307 swig_obj[0] = args;
28308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28309 if (!SWIG_IsOK(res1)) {
28310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28311 }
28312 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28313 {
28314 PyThreadState* __tstate = wxPyBeginAllowThreads();
28315 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 {
28320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 PyObject *resultobj = 0;
28330 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28331 bool result;
28332 void *argp1 = 0 ;
28333 int res1 = 0 ;
28334 PyObject *swig_obj[1] ;
28335
28336 if (!args) SWIG_fail;
28337 swig_obj[0] = args;
28338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28339 if (!SWIG_IsOK(res1)) {
28340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28341 }
28342 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
28346 wxPyEndAllowThreads(__tstate);
28347 if (PyErr_Occurred()) SWIG_fail;
28348 }
28349 {
28350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28351 }
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 PyObject *resultobj = 0;
28360 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28361 bool result;
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_wxUpdateUIEvent, 0 | 0 );
28369 if (!SWIG_IsOK(res1)) {
28370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28371 }
28372 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 {
28380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28381 }
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 PyObject *resultobj = 0;
28390 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28391 wxString result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 PyObject *swig_obj[1] ;
28395
28396 if (!args) SWIG_fail;
28397 swig_obj[0] = args;
28398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28399 if (!SWIG_IsOK(res1)) {
28400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28401 }
28402 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = ((wxUpdateUIEvent const *)arg1)->GetText();
28406 wxPyEndAllowThreads(__tstate);
28407 if (PyErr_Occurred()) SWIG_fail;
28408 }
28409 {
28410 #if wxUSE_UNICODE
28411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28412 #else
28413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28414 #endif
28415 }
28416 return resultobj;
28417 fail:
28418 return NULL;
28419 }
28420
28421
28422 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28423 PyObject *resultobj = 0;
28424 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28425 bool result;
28426 void *argp1 = 0 ;
28427 int res1 = 0 ;
28428 PyObject *swig_obj[1] ;
28429
28430 if (!args) SWIG_fail;
28431 swig_obj[0] = args;
28432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28433 if (!SWIG_IsOK(res1)) {
28434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28435 }
28436 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28437 {
28438 PyThreadState* __tstate = wxPyBeginAllowThreads();
28439 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
28440 wxPyEndAllowThreads(__tstate);
28441 if (PyErr_Occurred()) SWIG_fail;
28442 }
28443 {
28444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28445 }
28446 return resultobj;
28447 fail:
28448 return NULL;
28449 }
28450
28451
28452 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28453 PyObject *resultobj = 0;
28454 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28455 bool result;
28456 void *argp1 = 0 ;
28457 int res1 = 0 ;
28458 PyObject *swig_obj[1] ;
28459
28460 if (!args) SWIG_fail;
28461 swig_obj[0] = args;
28462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28463 if (!SWIG_IsOK(res1)) {
28464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28465 }
28466 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28467 {
28468 PyThreadState* __tstate = wxPyBeginAllowThreads();
28469 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 {
28474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28475 }
28476 return resultobj;
28477 fail:
28478 return NULL;
28479 }
28480
28481
28482 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28483 PyObject *resultobj = 0;
28484 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28485 bool result;
28486 void *argp1 = 0 ;
28487 int res1 = 0 ;
28488 PyObject *swig_obj[1] ;
28489
28490 if (!args) SWIG_fail;
28491 swig_obj[0] = args;
28492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28495 }
28496 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28497 {
28498 PyThreadState* __tstate = wxPyBeginAllowThreads();
28499 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
28500 wxPyEndAllowThreads(__tstate);
28501 if (PyErr_Occurred()) SWIG_fail;
28502 }
28503 {
28504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28505 }
28506 return resultobj;
28507 fail:
28508 return NULL;
28509 }
28510
28511
28512 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28513 PyObject *resultobj = 0;
28514 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28515 bool result;
28516 void *argp1 = 0 ;
28517 int res1 = 0 ;
28518 PyObject *swig_obj[1] ;
28519
28520 if (!args) SWIG_fail;
28521 swig_obj[0] = args;
28522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28523 if (!SWIG_IsOK(res1)) {
28524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28525 }
28526 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28527 {
28528 PyThreadState* __tstate = wxPyBeginAllowThreads();
28529 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28530 wxPyEndAllowThreads(__tstate);
28531 if (PyErr_Occurred()) SWIG_fail;
28532 }
28533 {
28534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28535 }
28536 return resultobj;
28537 fail:
28538 return NULL;
28539 }
28540
28541
28542 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28543 PyObject *resultobj = 0;
28544 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28545 bool arg2 ;
28546 void *argp1 = 0 ;
28547 int res1 = 0 ;
28548 bool val2 ;
28549 int ecode2 = 0 ;
28550 PyObject * obj0 = 0 ;
28551 PyObject * obj1 = 0 ;
28552 char * kwnames[] = {
28553 (char *) "self",(char *) "check", NULL
28554 };
28555
28556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28558 if (!SWIG_IsOK(res1)) {
28559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28560 }
28561 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28562 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28563 if (!SWIG_IsOK(ecode2)) {
28564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28565 }
28566 arg2 = static_cast< bool >(val2);
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 (arg1)->Check(arg2);
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 resultobj = SWIG_Py_Void();
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj = 0;
28582 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28583 bool arg2 ;
28584 void *argp1 = 0 ;
28585 int res1 = 0 ;
28586 bool val2 ;
28587 int ecode2 = 0 ;
28588 PyObject * obj0 = 0 ;
28589 PyObject * obj1 = 0 ;
28590 char * kwnames[] = {
28591 (char *) "self",(char *) "enable", NULL
28592 };
28593
28594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28598 }
28599 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28601 if (!SWIG_IsOK(ecode2)) {
28602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28603 }
28604 arg2 = static_cast< bool >(val2);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 (arg1)->Enable(arg2);
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 resultobj = SWIG_Py_Void();
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28619 PyObject *resultobj = 0;
28620 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28621 bool arg2 ;
28622 void *argp1 = 0 ;
28623 int res1 = 0 ;
28624 bool val2 ;
28625 int ecode2 = 0 ;
28626 PyObject * obj0 = 0 ;
28627 PyObject * obj1 = 0 ;
28628 char * kwnames[] = {
28629 (char *) "self",(char *) "show", NULL
28630 };
28631
28632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28634 if (!SWIG_IsOK(res1)) {
28635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28636 }
28637 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28639 if (!SWIG_IsOK(ecode2)) {
28640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28641 }
28642 arg2 = static_cast< bool >(val2);
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 (arg1)->Show(arg2);
28646 wxPyEndAllowThreads(__tstate);
28647 if (PyErr_Occurred()) SWIG_fail;
28648 }
28649 resultobj = SWIG_Py_Void();
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28657 PyObject *resultobj = 0;
28658 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28659 wxString *arg2 = 0 ;
28660 void *argp1 = 0 ;
28661 int res1 = 0 ;
28662 bool temp2 = false ;
28663 PyObject * obj0 = 0 ;
28664 PyObject * obj1 = 0 ;
28665 char * kwnames[] = {
28666 (char *) "self",(char *) "text", NULL
28667 };
28668
28669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28673 }
28674 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28675 {
28676 arg2 = wxString_in_helper(obj1);
28677 if (arg2 == NULL) SWIG_fail;
28678 temp2 = true;
28679 }
28680 {
28681 PyThreadState* __tstate = wxPyBeginAllowThreads();
28682 (arg1)->SetText((wxString const &)*arg2);
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 resultobj = SWIG_Py_Void();
28687 {
28688 if (temp2)
28689 delete arg2;
28690 }
28691 return resultobj;
28692 fail:
28693 {
28694 if (temp2)
28695 delete arg2;
28696 }
28697 return NULL;
28698 }
28699
28700
28701 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28702 PyObject *resultobj = 0;
28703 long arg1 ;
28704 long val1 ;
28705 int ecode1 = 0 ;
28706 PyObject * obj0 = 0 ;
28707 char * kwnames[] = {
28708 (char *) "updateInterval", NULL
28709 };
28710
28711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28712 ecode1 = SWIG_AsVal_long(obj0, &val1);
28713 if (!SWIG_IsOK(ecode1)) {
28714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28715 }
28716 arg1 = static_cast< long >(val1);
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 wxUpdateUIEvent::SetUpdateInterval(arg1);
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 resultobj = SWIG_Py_Void();
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *resultobj = 0;
28732 long result;
28733
28734 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_From_long(static_cast< long >(result));
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj = 0;
28750 wxWindow *arg1 = (wxWindow *) 0 ;
28751 bool result;
28752 void *argp1 = 0 ;
28753 int res1 = 0 ;
28754 PyObject * obj0 = 0 ;
28755 char * kwnames[] = {
28756 (char *) "win", NULL
28757 };
28758
28759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28761 if (!SWIG_IsOK(res1)) {
28762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28763 }
28764 arg1 = reinterpret_cast< wxWindow * >(argp1);
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 {
28772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28773 }
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782
28783 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28784 {
28785 PyThreadState* __tstate = wxPyBeginAllowThreads();
28786 wxUpdateUIEvent::ResetUpdateTime();
28787 wxPyEndAllowThreads(__tstate);
28788 if (PyErr_Occurred()) SWIG_fail;
28789 }
28790 resultobj = SWIG_Py_Void();
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28798 PyObject *resultobj = 0;
28799 wxUpdateUIMode arg1 ;
28800 int val1 ;
28801 int ecode1 = 0 ;
28802 PyObject * obj0 = 0 ;
28803 char * kwnames[] = {
28804 (char *) "mode", NULL
28805 };
28806
28807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28808 ecode1 = SWIG_AsVal_int(obj0, &val1);
28809 if (!SWIG_IsOK(ecode1)) {
28810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28811 }
28812 arg1 = static_cast< wxUpdateUIMode >(val1);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 wxUpdateUIEvent::SetMode(arg1);
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_Py_Void();
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 wxUpdateUIMode result;
28829
28830 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 resultobj = SWIG_From_int(static_cast< int >(result));
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28845 PyObject *obj;
28846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28847 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28848 return SWIG_Py_Void();
28849 }
28850
28851 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28852 return SWIG_Python_InitShadowInstance(args);
28853 }
28854
28855 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28856 PyObject *resultobj = 0;
28857 wxSysColourChangedEvent *result = 0 ;
28858
28859 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28867 return resultobj;
28868 fail:
28869 return NULL;
28870 }
28871
28872
28873 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28874 PyObject *obj;
28875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28876 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28877 return SWIG_Py_Void();
28878 }
28879
28880 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28881 return SWIG_Python_InitShadowInstance(args);
28882 }
28883
28884 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28885 PyObject *resultobj = 0;
28886 int arg1 = (int) 0 ;
28887 wxWindow *arg2 = (wxWindow *) NULL ;
28888 wxMouseCaptureChangedEvent *result = 0 ;
28889 int val1 ;
28890 int ecode1 = 0 ;
28891 void *argp2 = 0 ;
28892 int res2 = 0 ;
28893 PyObject * obj0 = 0 ;
28894 PyObject * obj1 = 0 ;
28895 char * kwnames[] = {
28896 (char *) "winid",(char *) "gainedCapture", NULL
28897 };
28898
28899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28900 if (obj0) {
28901 ecode1 = SWIG_AsVal_int(obj0, &val1);
28902 if (!SWIG_IsOK(ecode1)) {
28903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28904 }
28905 arg1 = static_cast< int >(val1);
28906 }
28907 if (obj1) {
28908 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28909 if (!SWIG_IsOK(res2)) {
28910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28911 }
28912 arg2 = reinterpret_cast< wxWindow * >(argp2);
28913 }
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28930 wxWindow *result = 0 ;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject *swig_obj[1] ;
28934
28935 if (!args) SWIG_fail;
28936 swig_obj[0] = args;
28937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28938 if (!SWIG_IsOK(res1)) {
28939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28940 }
28941 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 {
28949 resultobj = wxPyMake_wxObject(result, (bool)0);
28950 }
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28958 PyObject *obj;
28959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28960 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28961 return SWIG_Py_Void();
28962 }
28963
28964 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28965 return SWIG_Python_InitShadowInstance(args);
28966 }
28967
28968 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj = 0;
28970 int arg1 = (int) 0 ;
28971 wxMouseCaptureLostEvent *result = 0 ;
28972 int val1 ;
28973 int ecode1 = 0 ;
28974 PyObject * obj0 = 0 ;
28975 char * kwnames[] = {
28976 (char *) "winid", NULL
28977 };
28978
28979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28980 if (obj0) {
28981 ecode1 = SWIG_AsVal_int(obj0, &val1);
28982 if (!SWIG_IsOK(ecode1)) {
28983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28984 }
28985 arg1 = static_cast< int >(val1);
28986 }
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29001 PyObject *obj;
29002 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29003 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
29004 return SWIG_Py_Void();
29005 }
29006
29007 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29008 return SWIG_Python_InitShadowInstance(args);
29009 }
29010
29011 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29012 PyObject *resultobj = 0;
29013 wxDisplayChangedEvent *result = 0 ;
29014
29015 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
29023 return resultobj;
29024 fail:
29025 return NULL;
29026 }
29027
29028
29029 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29030 PyObject *obj;
29031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29032 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
29033 return SWIG_Py_Void();
29034 }
29035
29036 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29037 return SWIG_Python_InitShadowInstance(args);
29038 }
29039
29040 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29041 PyObject *resultobj = 0;
29042 int arg1 = (int) 0 ;
29043 wxPaletteChangedEvent *result = 0 ;
29044 int val1 ;
29045 int ecode1 = 0 ;
29046 PyObject * obj0 = 0 ;
29047 char * kwnames[] = {
29048 (char *) "id", NULL
29049 };
29050
29051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
29052 if (obj0) {
29053 ecode1 = SWIG_AsVal_int(obj0, &val1);
29054 if (!SWIG_IsOK(ecode1)) {
29055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
29056 }
29057 arg1 = static_cast< int >(val1);
29058 }
29059 {
29060 PyThreadState* __tstate = wxPyBeginAllowThreads();
29061 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
29062 wxPyEndAllowThreads(__tstate);
29063 if (PyErr_Occurred()) SWIG_fail;
29064 }
29065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
29066 return resultobj;
29067 fail:
29068 return NULL;
29069 }
29070
29071
29072 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29073 PyObject *resultobj = 0;
29074 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29075 wxWindow *arg2 = (wxWindow *) 0 ;
29076 void *argp1 = 0 ;
29077 int res1 = 0 ;
29078 void *argp2 = 0 ;
29079 int res2 = 0 ;
29080 PyObject * obj0 = 0 ;
29081 PyObject * obj1 = 0 ;
29082 char * kwnames[] = {
29083 (char *) "self",(char *) "win", NULL
29084 };
29085
29086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
29087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29088 if (!SWIG_IsOK(res1)) {
29089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29090 }
29091 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29093 if (!SWIG_IsOK(res2)) {
29094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
29095 }
29096 arg2 = reinterpret_cast< wxWindow * >(argp2);
29097 {
29098 PyThreadState* __tstate = wxPyBeginAllowThreads();
29099 (arg1)->SetChangedWindow(arg2);
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 resultobj = SWIG_Py_Void();
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29111 PyObject *resultobj = 0;
29112 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29113 wxWindow *result = 0 ;
29114 void *argp1 = 0 ;
29115 int res1 = 0 ;
29116 PyObject *swig_obj[1] ;
29117
29118 if (!args) SWIG_fail;
29119 swig_obj[0] = args;
29120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29121 if (!SWIG_IsOK(res1)) {
29122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29123 }
29124 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29125 {
29126 PyThreadState* __tstate = wxPyBeginAllowThreads();
29127 result = (wxWindow *)(arg1)->GetChangedWindow();
29128 wxPyEndAllowThreads(__tstate);
29129 if (PyErr_Occurred()) SWIG_fail;
29130 }
29131 {
29132 resultobj = wxPyMake_wxObject(result, (bool)0);
29133 }
29134 return resultobj;
29135 fail:
29136 return NULL;
29137 }
29138
29139
29140 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29141 PyObject *obj;
29142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29143 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
29144 return SWIG_Py_Void();
29145 }
29146
29147 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29148 return SWIG_Python_InitShadowInstance(args);
29149 }
29150
29151 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29152 PyObject *resultobj = 0;
29153 int arg1 = (int) 0 ;
29154 wxQueryNewPaletteEvent *result = 0 ;
29155 int val1 ;
29156 int ecode1 = 0 ;
29157 PyObject * obj0 = 0 ;
29158 char * kwnames[] = {
29159 (char *) "winid", NULL
29160 };
29161
29162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
29163 if (obj0) {
29164 ecode1 = SWIG_AsVal_int(obj0, &val1);
29165 if (!SWIG_IsOK(ecode1)) {
29166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
29167 }
29168 arg1 = static_cast< int >(val1);
29169 }
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29184 PyObject *resultobj = 0;
29185 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29186 bool arg2 ;
29187 void *argp1 = 0 ;
29188 int res1 = 0 ;
29189 bool val2 ;
29190 int ecode2 = 0 ;
29191 PyObject * obj0 = 0 ;
29192 PyObject * obj1 = 0 ;
29193 char * kwnames[] = {
29194 (char *) "self",(char *) "realized", NULL
29195 };
29196
29197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
29198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29199 if (!SWIG_IsOK(res1)) {
29200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
29201 }
29202 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29204 if (!SWIG_IsOK(ecode2)) {
29205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
29206 }
29207 arg2 = static_cast< bool >(val2);
29208 {
29209 PyThreadState* __tstate = wxPyBeginAllowThreads();
29210 (arg1)->SetPaletteRealized(arg2);
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 resultobj = SWIG_Py_Void();
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 PyObject *resultobj = 0;
29223 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29224 bool result;
29225 void *argp1 = 0 ;
29226 int res1 = 0 ;
29227 PyObject *swig_obj[1] ;
29228
29229 if (!args) SWIG_fail;
29230 swig_obj[0] = args;
29231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29232 if (!SWIG_IsOK(res1)) {
29233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
29234 }
29235 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
29239 wxPyEndAllowThreads(__tstate);
29240 if (PyErr_Occurred()) SWIG_fail;
29241 }
29242 {
29243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29244 }
29245 return resultobj;
29246 fail:
29247 return NULL;
29248 }
29249
29250
29251 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29252 PyObject *obj;
29253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29254 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
29255 return SWIG_Py_Void();
29256 }
29257
29258 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29259 return SWIG_Python_InitShadowInstance(args);
29260 }
29261
29262 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *resultobj = 0;
29264 wxNavigationKeyEvent *result = 0 ;
29265
29266 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29281 PyObject *resultobj = 0;
29282 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29283 bool result;
29284 void *argp1 = 0 ;
29285 int res1 = 0 ;
29286 PyObject *swig_obj[1] ;
29287
29288 if (!args) SWIG_fail;
29289 swig_obj[0] = args;
29290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29293 }
29294 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
29298 wxPyEndAllowThreads(__tstate);
29299 if (PyErr_Occurred()) SWIG_fail;
29300 }
29301 {
29302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29303 }
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj = 0;
29312 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29313 bool arg2 ;
29314 void *argp1 = 0 ;
29315 int res1 = 0 ;
29316 bool val2 ;
29317 int ecode2 = 0 ;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 char * kwnames[] = {
29321 (char *) "self",(char *) "forward", NULL
29322 };
29323
29324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
29325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29328 }
29329 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29331 if (!SWIG_IsOK(ecode2)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
29333 }
29334 arg2 = static_cast< bool >(val2);
29335 {
29336 PyThreadState* __tstate = wxPyBeginAllowThreads();
29337 (arg1)->SetDirection(arg2);
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 resultobj = SWIG_Py_Void();
29342 return resultobj;
29343 fail:
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29351 bool result;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 PyObject *swig_obj[1] ;
29355
29356 if (!args) SWIG_fail;
29357 swig_obj[0] = args;
29358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29359 if (!SWIG_IsOK(res1)) {
29360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29361 }
29362 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 {
29370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29371 }
29372 return resultobj;
29373 fail:
29374 return NULL;
29375 }
29376
29377
29378 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29379 PyObject *resultobj = 0;
29380 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29381 bool arg2 ;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 bool val2 ;
29385 int ecode2 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char * kwnames[] = {
29389 (char *) "self",(char *) "ischange", NULL
29390 };
29391
29392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
29393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29396 }
29397 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29398 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29399 if (!SWIG_IsOK(ecode2)) {
29400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
29401 }
29402 arg2 = static_cast< bool >(val2);
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 (arg1)->SetWindowChange(arg2);
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_Py_Void();
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29419 bool result;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject *swig_obj[1] ;
29423
29424 if (!args) SWIG_fail;
29425 swig_obj[0] = args;
29426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29429 }
29430 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29449 bool arg2 ;
29450 void *argp1 = 0 ;
29451 int res1 = 0 ;
29452 bool val2 ;
29453 int ecode2 = 0 ;
29454 PyObject * obj0 = 0 ;
29455 PyObject * obj1 = 0 ;
29456 char * kwnames[] = {
29457 (char *) "self",(char *) "bIs", NULL
29458 };
29459
29460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
29461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29462 if (!SWIG_IsOK(res1)) {
29463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29464 }
29465 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29466 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29467 if (!SWIG_IsOK(ecode2)) {
29468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
29469 }
29470 arg2 = static_cast< bool >(val2);
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 (arg1)->SetFromTab(arg2);
29474 wxPyEndAllowThreads(__tstate);
29475 if (PyErr_Occurred()) SWIG_fail;
29476 }
29477 resultobj = SWIG_Py_Void();
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29485 PyObject *resultobj = 0;
29486 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29487 long arg2 ;
29488 void *argp1 = 0 ;
29489 int res1 = 0 ;
29490 long val2 ;
29491 int ecode2 = 0 ;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 char * kwnames[] = {
29495 (char *) "self",(char *) "flags", NULL
29496 };
29497
29498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
29499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29500 if (!SWIG_IsOK(res1)) {
29501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29502 }
29503 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29504 ecode2 = SWIG_AsVal_long(obj1, &val2);
29505 if (!SWIG_IsOK(ecode2)) {
29506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
29507 }
29508 arg2 = static_cast< long >(val2);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 (arg1)->SetFlags(arg2);
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 resultobj = SWIG_Py_Void();
29516 return resultobj;
29517 fail:
29518 return NULL;
29519 }
29520
29521
29522 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29523 PyObject *resultobj = 0;
29524 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29525 wxWindow *result = 0 ;
29526 void *argp1 = 0 ;
29527 int res1 = 0 ;
29528 PyObject *swig_obj[1] ;
29529
29530 if (!args) SWIG_fail;
29531 swig_obj[0] = args;
29532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29533 if (!SWIG_IsOK(res1)) {
29534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29535 }
29536 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29537 {
29538 PyThreadState* __tstate = wxPyBeginAllowThreads();
29539 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29540 wxPyEndAllowThreads(__tstate);
29541 if (PyErr_Occurred()) SWIG_fail;
29542 }
29543 {
29544 resultobj = wxPyMake_wxObject(result, (bool)0);
29545 }
29546 return resultobj;
29547 fail:
29548 return NULL;
29549 }
29550
29551
29552 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29553 PyObject *resultobj = 0;
29554 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29555 wxWindow *arg2 = (wxWindow *) 0 ;
29556 void *argp1 = 0 ;
29557 int res1 = 0 ;
29558 void *argp2 = 0 ;
29559 int res2 = 0 ;
29560 PyObject * obj0 = 0 ;
29561 PyObject * obj1 = 0 ;
29562 char * kwnames[] = {
29563 (char *) "self",(char *) "win", NULL
29564 };
29565
29566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29570 }
29571 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29573 if (!SWIG_IsOK(res2)) {
29574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29575 }
29576 arg2 = reinterpret_cast< wxWindow * >(argp2);
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 (arg1)->SetCurrentFocus(arg2);
29580 wxPyEndAllowThreads(__tstate);
29581 if (PyErr_Occurred()) SWIG_fail;
29582 }
29583 resultobj = SWIG_Py_Void();
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29591 PyObject *obj;
29592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29593 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29594 return SWIG_Py_Void();
29595 }
29596
29597 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29598 return SWIG_Python_InitShadowInstance(args);
29599 }
29600
29601 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29602 PyObject *resultobj = 0;
29603 wxWindow *arg1 = (wxWindow *) NULL ;
29604 wxWindowCreateEvent *result = 0 ;
29605 void *argp1 = 0 ;
29606 int res1 = 0 ;
29607 PyObject * obj0 = 0 ;
29608 char * kwnames[] = {
29609 (char *) "win", NULL
29610 };
29611
29612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29613 if (obj0) {
29614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29615 if (!SWIG_IsOK(res1)) {
29616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29617 }
29618 arg1 = reinterpret_cast< wxWindow * >(argp1);
29619 }
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29634 PyObject *resultobj = 0;
29635 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29636 wxWindow *result = 0 ;
29637 void *argp1 = 0 ;
29638 int res1 = 0 ;
29639 PyObject *swig_obj[1] ;
29640
29641 if (!args) SWIG_fail;
29642 swig_obj[0] = args;
29643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29644 if (!SWIG_IsOK(res1)) {
29645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29646 }
29647 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29648 {
29649 PyThreadState* __tstate = wxPyBeginAllowThreads();
29650 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 {
29655 resultobj = wxPyMake_wxObject(result, (bool)0);
29656 }
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29664 PyObject *obj;
29665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29666 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29667 return SWIG_Py_Void();
29668 }
29669
29670 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29671 return SWIG_Python_InitShadowInstance(args);
29672 }
29673
29674 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29675 PyObject *resultobj = 0;
29676 wxWindow *arg1 = (wxWindow *) NULL ;
29677 wxWindowDestroyEvent *result = 0 ;
29678 void *argp1 = 0 ;
29679 int res1 = 0 ;
29680 PyObject * obj0 = 0 ;
29681 char * kwnames[] = {
29682 (char *) "win", NULL
29683 };
29684
29685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29686 if (obj0) {
29687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29690 }
29691 arg1 = reinterpret_cast< wxWindow * >(argp1);
29692 }
29693 {
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29696 wxPyEndAllowThreads(__tstate);
29697 if (PyErr_Occurred()) SWIG_fail;
29698 }
29699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29700 return resultobj;
29701 fail:
29702 return NULL;
29703 }
29704
29705
29706 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29707 PyObject *resultobj = 0;
29708 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29709 wxWindow *result = 0 ;
29710 void *argp1 = 0 ;
29711 int res1 = 0 ;
29712 PyObject *swig_obj[1] ;
29713
29714 if (!args) SWIG_fail;
29715 swig_obj[0] = args;
29716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29719 }
29720 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 {
29728 resultobj = wxPyMake_wxObject(result, (bool)0);
29729 }
29730 return resultobj;
29731 fail:
29732 return NULL;
29733 }
29734
29735
29736 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29737 PyObject *obj;
29738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29739 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29740 return SWIG_Py_Void();
29741 }
29742
29743 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29744 return SWIG_Python_InitShadowInstance(args);
29745 }
29746
29747 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29748 PyObject *resultobj = 0;
29749 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29750 int arg2 = (int) 0 ;
29751 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29752 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29753 wxContextMenuEvent *result = 0 ;
29754 int val1 ;
29755 int ecode1 = 0 ;
29756 int val2 ;
29757 int ecode2 = 0 ;
29758 wxPoint temp3 ;
29759 PyObject * obj0 = 0 ;
29760 PyObject * obj1 = 0 ;
29761 PyObject * obj2 = 0 ;
29762 char * kwnames[] = {
29763 (char *) "type",(char *) "winid",(char *) "pt", NULL
29764 };
29765
29766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29767 if (obj0) {
29768 ecode1 = SWIG_AsVal_int(obj0, &val1);
29769 if (!SWIG_IsOK(ecode1)) {
29770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29771 }
29772 arg1 = static_cast< wxEventType >(val1);
29773 }
29774 if (obj1) {
29775 ecode2 = SWIG_AsVal_int(obj1, &val2);
29776 if (!SWIG_IsOK(ecode2)) {
29777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29778 }
29779 arg2 = static_cast< int >(val2);
29780 }
29781 if (obj2) {
29782 {
29783 arg3 = &temp3;
29784 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29785 }
29786 }
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29801 PyObject *resultobj = 0;
29802 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29803 wxPoint *result = 0 ;
29804 void *argp1 = 0 ;
29805 int res1 = 0 ;
29806 PyObject *swig_obj[1] ;
29807
29808 if (!args) SWIG_fail;
29809 swig_obj[0] = args;
29810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29811 if (!SWIG_IsOK(res1)) {
29812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29813 }
29814 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29815 {
29816 PyThreadState* __tstate = wxPyBeginAllowThreads();
29817 {
29818 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29819 result = (wxPoint *) &_result_ref;
29820 }
29821 wxPyEndAllowThreads(__tstate);
29822 if (PyErr_Occurred()) SWIG_fail;
29823 }
29824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29825 return resultobj;
29826 fail:
29827 return NULL;
29828 }
29829
29830
29831 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29832 PyObject *resultobj = 0;
29833 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29834 wxPoint *arg2 = 0 ;
29835 void *argp1 = 0 ;
29836 int res1 = 0 ;
29837 wxPoint temp2 ;
29838 PyObject * obj0 = 0 ;
29839 PyObject * obj1 = 0 ;
29840 char * kwnames[] = {
29841 (char *) "self",(char *) "pos", NULL
29842 };
29843
29844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29848 }
29849 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29850 {
29851 arg2 = &temp2;
29852 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 (arg1)->SetPosition((wxPoint const &)*arg2);
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 resultobj = SWIG_Py_Void();
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29868 PyObject *obj;
29869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29870 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29871 return SWIG_Py_Void();
29872 }
29873
29874 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29875 return SWIG_Python_InitShadowInstance(args);
29876 }
29877
29878 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29879 PyObject *resultobj = 0;
29880 wxIdleEvent *result = 0 ;
29881
29882 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29883 {
29884 PyThreadState* __tstate = wxPyBeginAllowThreads();
29885 result = (wxIdleEvent *)new wxIdleEvent();
29886 wxPyEndAllowThreads(__tstate);
29887 if (PyErr_Occurred()) SWIG_fail;
29888 }
29889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29890 return resultobj;
29891 fail:
29892 return NULL;
29893 }
29894
29895
29896 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29897 PyObject *resultobj = 0;
29898 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29899 bool arg2 = (bool) true ;
29900 void *argp1 = 0 ;
29901 int res1 = 0 ;
29902 bool val2 ;
29903 int ecode2 = 0 ;
29904 PyObject * obj0 = 0 ;
29905 PyObject * obj1 = 0 ;
29906 char * kwnames[] = {
29907 (char *) "self",(char *) "needMore", NULL
29908 };
29909
29910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29912 if (!SWIG_IsOK(res1)) {
29913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29914 }
29915 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29916 if (obj1) {
29917 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29918 if (!SWIG_IsOK(ecode2)) {
29919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29920 }
29921 arg2 = static_cast< bool >(val2);
29922 }
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 (arg1)->RequestMore(arg2);
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 resultobj = SWIG_Py_Void();
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29937 PyObject *resultobj = 0;
29938 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29939 bool result;
29940 void *argp1 = 0 ;
29941 int res1 = 0 ;
29942 PyObject *swig_obj[1] ;
29943
29944 if (!args) SWIG_fail;
29945 swig_obj[0] = args;
29946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29947 if (!SWIG_IsOK(res1)) {
29948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29949 }
29950 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 {
29958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29959 }
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = 0;
29968 wxIdleMode arg1 ;
29969 int val1 ;
29970 int ecode1 = 0 ;
29971 PyObject * obj0 = 0 ;
29972 char * kwnames[] = {
29973 (char *) "mode", NULL
29974 };
29975
29976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29977 ecode1 = SWIG_AsVal_int(obj0, &val1);
29978 if (!SWIG_IsOK(ecode1)) {
29979 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29980 }
29981 arg1 = static_cast< wxIdleMode >(val1);
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 wxIdleEvent::SetMode(arg1);
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 resultobj = SWIG_Py_Void();
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *resultobj = 0;
29997 wxIdleMode result;
29998
29999 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = (wxIdleMode)wxIdleEvent::GetMode();
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 resultobj = SWIG_From_int(static_cast< int >(result));
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj = 0;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 bool result;
30017 void *argp1 = 0 ;
30018 int res1 = 0 ;
30019 PyObject * obj0 = 0 ;
30020 char * kwnames[] = {
30021 (char *) "win", NULL
30022 };
30023
30024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
30025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30026 if (!SWIG_IsOK(res1)) {
30027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
30028 }
30029 arg1 = reinterpret_cast< wxWindow * >(argp1);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 result = (bool)wxIdleEvent::CanSend(arg1);
30033 wxPyEndAllowThreads(__tstate);
30034 if (PyErr_Occurred()) SWIG_fail;
30035 }
30036 {
30037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30038 }
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30046 PyObject *obj;
30047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30048 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
30049 return SWIG_Py_Void();
30050 }
30051
30052 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30053 return SWIG_Python_InitShadowInstance(args);
30054 }
30055
30056 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj = 0;
30058 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30059 int arg2 = (int) 0 ;
30060 wxClipboardTextEvent *result = 0 ;
30061 int val1 ;
30062 int ecode1 = 0 ;
30063 int val2 ;
30064 int ecode2 = 0 ;
30065 PyObject * obj0 = 0 ;
30066 PyObject * obj1 = 0 ;
30067 char * kwnames[] = {
30068 (char *) "type",(char *) "winid", NULL
30069 };
30070
30071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30072 if (obj0) {
30073 ecode1 = SWIG_AsVal_int(obj0, &val1);
30074 if (!SWIG_IsOK(ecode1)) {
30075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30076 }
30077 arg1 = static_cast< wxEventType >(val1);
30078 }
30079 if (obj1) {
30080 ecode2 = SWIG_AsVal_int(obj1, &val2);
30081 if (!SWIG_IsOK(ecode2)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
30083 }
30084 arg2 = static_cast< int >(val2);
30085 }
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *obj;
30101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30102 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
30103 return SWIG_Py_Void();
30104 }
30105
30106 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30107 return SWIG_Python_InitShadowInstance(args);
30108 }
30109
30110 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30111 PyObject *resultobj = 0;
30112 int arg1 = (int) 0 ;
30113 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
30114 wxPyEvent *result = 0 ;
30115 int val1 ;
30116 int ecode1 = 0 ;
30117 int val2 ;
30118 int ecode2 = 0 ;
30119 PyObject * obj0 = 0 ;
30120 PyObject * obj1 = 0 ;
30121 char * kwnames[] = {
30122 (char *) "winid",(char *) "eventType", NULL
30123 };
30124
30125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30126 if (obj0) {
30127 ecode1 = SWIG_AsVal_int(obj0, &val1);
30128 if (!SWIG_IsOK(ecode1)) {
30129 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
30130 }
30131 arg1 = static_cast< int >(val1);
30132 }
30133 if (obj1) {
30134 ecode2 = SWIG_AsVal_int(obj1, &val2);
30135 if (!SWIG_IsOK(ecode2)) {
30136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
30137 }
30138 arg2 = static_cast< wxEventType >(val2);
30139 }
30140 {
30141 PyThreadState* __tstate = wxPyBeginAllowThreads();
30142 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
30143 wxPyEndAllowThreads(__tstate);
30144 if (PyErr_Occurred()) SWIG_fail;
30145 }
30146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
30147 return resultobj;
30148 fail:
30149 return NULL;
30150 }
30151
30152
30153 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30154 PyObject *resultobj = 0;
30155 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30156 void *argp1 = 0 ;
30157 int res1 = 0 ;
30158 PyObject *swig_obj[1] ;
30159
30160 if (!args) SWIG_fail;
30161 swig_obj[0] = args;
30162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
30163 if (!SWIG_IsOK(res1)) {
30164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30165 }
30166 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30167 {
30168 PyThreadState* __tstate = wxPyBeginAllowThreads();
30169 delete arg1;
30170
30171 wxPyEndAllowThreads(__tstate);
30172 if (PyErr_Occurred()) SWIG_fail;
30173 }
30174 resultobj = SWIG_Py_Void();
30175 return resultobj;
30176 fail:
30177 return NULL;
30178 }
30179
30180
30181 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30182 PyObject *resultobj = 0;
30183 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30184 PyObject *arg2 = (PyObject *) 0 ;
30185 void *argp1 = 0 ;
30186 int res1 = 0 ;
30187 PyObject * obj0 = 0 ;
30188 PyObject * obj1 = 0 ;
30189 char * kwnames[] = {
30190 (char *) "self",(char *) "self", NULL
30191 };
30192
30193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30195 if (!SWIG_IsOK(res1)) {
30196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30197 }
30198 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30199 arg2 = obj1;
30200 {
30201 PyThreadState* __tstate = wxPyBeginAllowThreads();
30202 (arg1)->SetSelf(arg2);
30203 wxPyEndAllowThreads(__tstate);
30204 if (PyErr_Occurred()) SWIG_fail;
30205 }
30206 resultobj = SWIG_Py_Void();
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30214 PyObject *resultobj = 0;
30215 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30216 PyObject *result = 0 ;
30217 void *argp1 = 0 ;
30218 int res1 = 0 ;
30219 PyObject *swig_obj[1] ;
30220
30221 if (!args) SWIG_fail;
30222 swig_obj[0] = args;
30223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30224 if (!SWIG_IsOK(res1)) {
30225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30226 }
30227 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30228 {
30229 PyThreadState* __tstate = wxPyBeginAllowThreads();
30230 result = (PyObject *)(arg1)->GetSelf();
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 resultobj = result;
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30242 PyObject *obj;
30243 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30244 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
30245 return SWIG_Py_Void();
30246 }
30247
30248 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30249 return SWIG_Python_InitShadowInstance(args);
30250 }
30251
30252 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30253 PyObject *resultobj = 0;
30254 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30255 int arg2 = (int) 0 ;
30256 wxPyCommandEvent *result = 0 ;
30257 int val1 ;
30258 int ecode1 = 0 ;
30259 int val2 ;
30260 int ecode2 = 0 ;
30261 PyObject * obj0 = 0 ;
30262 PyObject * obj1 = 0 ;
30263 char * kwnames[] = {
30264 (char *) "eventType",(char *) "id", NULL
30265 };
30266
30267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30268 if (obj0) {
30269 ecode1 = SWIG_AsVal_int(obj0, &val1);
30270 if (!SWIG_IsOK(ecode1)) {
30271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30272 }
30273 arg1 = static_cast< wxEventType >(val1);
30274 }
30275 if (obj1) {
30276 ecode2 = SWIG_AsVal_int(obj1, &val2);
30277 if (!SWIG_IsOK(ecode2)) {
30278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
30279 }
30280 arg2 = static_cast< int >(val2);
30281 }
30282 {
30283 PyThreadState* __tstate = wxPyBeginAllowThreads();
30284 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
30285 wxPyEndAllowThreads(__tstate);
30286 if (PyErr_Occurred()) SWIG_fail;
30287 }
30288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30296 PyObject *resultobj = 0;
30297 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30298 void *argp1 = 0 ;
30299 int res1 = 0 ;
30300 PyObject *swig_obj[1] ;
30301
30302 if (!args) SWIG_fail;
30303 swig_obj[0] = args;
30304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
30305 if (!SWIG_IsOK(res1)) {
30306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30307 }
30308 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 delete arg1;
30312
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 resultobj = SWIG_Py_Void();
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj = 0;
30325 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30326 PyObject *arg2 = (PyObject *) 0 ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 PyObject * obj0 = 0 ;
30330 PyObject * obj1 = 0 ;
30331 char * kwnames[] = {
30332 (char *) "self",(char *) "self", NULL
30333 };
30334
30335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30337 if (!SWIG_IsOK(res1)) {
30338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30339 }
30340 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30341 arg2 = obj1;
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 (arg1)->SetSelf(arg2);
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 resultobj = SWIG_Py_Void();
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30356 PyObject *resultobj = 0;
30357 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30358 PyObject *result = 0 ;
30359 void *argp1 = 0 ;
30360 int res1 = 0 ;
30361 PyObject *swig_obj[1] ;
30362
30363 if (!args) SWIG_fail;
30364 swig_obj[0] = args;
30365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30366 if (!SWIG_IsOK(res1)) {
30367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30368 }
30369 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (PyObject *)(arg1)->GetSelf();
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 resultobj = result;
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *obj;
30385 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30386 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
30387 return SWIG_Py_Void();
30388 }
30389
30390 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 return SWIG_Python_InitShadowInstance(args);
30392 }
30393
30394 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30395 PyObject *resultobj = 0;
30396 wxWindow *arg1 = (wxWindow *) 0 ;
30397 wxDateTime *arg2 = 0 ;
30398 wxEventType arg3 ;
30399 wxDateEvent *result = 0 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 void *argp2 = 0 ;
30403 int res2 = 0 ;
30404 int val3 ;
30405 int ecode3 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char * kwnames[] = {
30410 (char *) "win",(char *) "dt",(char *) "type", NULL
30411 };
30412
30413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
30417 }
30418 arg1 = reinterpret_cast< wxWindow * >(argp1);
30419 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30420 if (!SWIG_IsOK(res2)) {
30421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30422 }
30423 if (!argp2) {
30424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30425 }
30426 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30427 ecode3 = SWIG_AsVal_int(obj2, &val3);
30428 if (!SWIG_IsOK(ecode3)) {
30429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
30430 }
30431 arg3 = static_cast< wxEventType >(val3);
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
30435 wxPyEndAllowThreads(__tstate);
30436 if (PyErr_Occurred()) SWIG_fail;
30437 }
30438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
30439 return resultobj;
30440 fail:
30441 return NULL;
30442 }
30443
30444
30445 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30446 PyObject *resultobj = 0;
30447 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30448 wxDateTime *result = 0 ;
30449 void *argp1 = 0 ;
30450 int res1 = 0 ;
30451 PyObject *swig_obj[1] ;
30452
30453 if (!args) SWIG_fail;
30454 swig_obj[0] = args;
30455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30456 if (!SWIG_IsOK(res1)) {
30457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
30458 }
30459 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30460 {
30461 PyThreadState* __tstate = wxPyBeginAllowThreads();
30462 {
30463 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
30464 result = (wxDateTime *) &_result_ref;
30465 }
30466 wxPyEndAllowThreads(__tstate);
30467 if (PyErr_Occurred()) SWIG_fail;
30468 }
30469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
30470 return resultobj;
30471 fail:
30472 return NULL;
30473 }
30474
30475
30476 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30477 PyObject *resultobj = 0;
30478 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30479 wxDateTime *arg2 = 0 ;
30480 void *argp1 = 0 ;
30481 int res1 = 0 ;
30482 void *argp2 = 0 ;
30483 int res2 = 0 ;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 char * kwnames[] = {
30487 (char *) "self",(char *) "date", NULL
30488 };
30489
30490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
30491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30492 if (!SWIG_IsOK(res1)) {
30493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
30494 }
30495 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30497 if (!SWIG_IsOK(res2)) {
30498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30499 }
30500 if (!argp2) {
30501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30502 }
30503 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 (arg1)->SetDate((wxDateTime const &)*arg2);
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 resultobj = SWIG_Py_Void();
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30518 PyObject *obj;
30519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30520 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30521 return SWIG_Py_Void();
30522 }
30523
30524 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30525 return SWIG_Python_InitShadowInstance(args);
30526 }
30527
30528 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30529 PyObject *resultobj = 0;
30530 wxWindow *arg1 = (wxWindow *) 0 ;
30531 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30532 wxEventBlocker *result = 0 ;
30533 void *argp1 = 0 ;
30534 int res1 = 0 ;
30535 int val2 ;
30536 int ecode2 = 0 ;
30537 PyObject * obj0 = 0 ;
30538 PyObject * obj1 = 0 ;
30539 char * kwnames[] = {
30540 (char *) "win",(char *) "type", NULL
30541 };
30542
30543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30545 if (!SWIG_IsOK(res1)) {
30546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30547 }
30548 arg1 = reinterpret_cast< wxWindow * >(argp1);
30549 if (obj1) {
30550 ecode2 = SWIG_AsVal_int(obj1, &val2);
30551 if (!SWIG_IsOK(ecode2)) {
30552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30553 }
30554 arg2 = static_cast< wxEventType >(val2);
30555 }
30556 {
30557 PyThreadState* __tstate = wxPyBeginAllowThreads();
30558 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30559 wxPyEndAllowThreads(__tstate);
30560 if (PyErr_Occurred()) SWIG_fail;
30561 }
30562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30563 return resultobj;
30564 fail:
30565 return NULL;
30566 }
30567
30568
30569 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30570 PyObject *resultobj = 0;
30571 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 PyObject *swig_obj[1] ;
30575
30576 if (!args) SWIG_fail;
30577 swig_obj[0] = args;
30578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30581 }
30582 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 delete arg1;
30586
30587 wxPyEndAllowThreads(__tstate);
30588 if (PyErr_Occurred()) SWIG_fail;
30589 }
30590 resultobj = SWIG_Py_Void();
30591 return resultobj;
30592 fail:
30593 return NULL;
30594 }
30595
30596
30597 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30598 PyObject *resultobj = 0;
30599 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30600 wxEventType arg2 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 int val2 ;
30604 int ecode2 = 0 ;
30605 PyObject * obj0 = 0 ;
30606 PyObject * obj1 = 0 ;
30607 char * kwnames[] = {
30608 (char *) "self",(char *) "type", NULL
30609 };
30610
30611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30615 }
30616 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30617 ecode2 = SWIG_AsVal_int(obj1, &val2);
30618 if (!SWIG_IsOK(ecode2)) {
30619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30620 }
30621 arg2 = static_cast< wxEventType >(val2);
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 (arg1)->Block(arg2);
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 resultobj = SWIG_Py_Void();
30629 return resultobj;
30630 fail:
30631 return NULL;
30632 }
30633
30634
30635 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30636 PyObject *obj;
30637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30638 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30639 return SWIG_Py_Void();
30640 }
30641
30642 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30643 return SWIG_Python_InitShadowInstance(args);
30644 }
30645
30646 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30647 PyObject *resultobj = 0;
30648 wxPyApp *result = 0 ;
30649
30650 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30651 {
30652 PyThreadState* __tstate = wxPyBeginAllowThreads();
30653 result = (wxPyApp *)new_wxPyApp();
30654 wxPyEndAllowThreads(__tstate);
30655 if (PyErr_Occurred()) SWIG_fail;
30656 }
30657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30658 return resultobj;
30659 fail:
30660 return NULL;
30661 }
30662
30663
30664 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30665 PyObject *resultobj = 0;
30666 wxPyApp *arg1 = (wxPyApp *) 0 ;
30667 void *argp1 = 0 ;
30668 int res1 = 0 ;
30669 PyObject *swig_obj[1] ;
30670
30671 if (!args) SWIG_fail;
30672 swig_obj[0] = args;
30673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30674 if (!SWIG_IsOK(res1)) {
30675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30676 }
30677 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30678 {
30679 PyThreadState* __tstate = wxPyBeginAllowThreads();
30680 delete arg1;
30681
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_Py_Void();
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj = 0;
30694 wxPyApp *arg1 = (wxPyApp *) 0 ;
30695 PyObject *arg2 = (PyObject *) 0 ;
30696 PyObject *arg3 = (PyObject *) 0 ;
30697 bool arg4 = (bool) false ;
30698 void *argp1 = 0 ;
30699 int res1 = 0 ;
30700 bool val4 ;
30701 int ecode4 = 0 ;
30702 PyObject * obj0 = 0 ;
30703 PyObject * obj1 = 0 ;
30704 PyObject * obj2 = 0 ;
30705 PyObject * obj3 = 0 ;
30706 char * kwnames[] = {
30707 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30708 };
30709
30710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30712 if (!SWIG_IsOK(res1)) {
30713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30714 }
30715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30716 arg2 = obj1;
30717 arg3 = obj2;
30718 if (obj3) {
30719 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30720 if (!SWIG_IsOK(ecode4)) {
30721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30722 }
30723 arg4 = static_cast< bool >(val4);
30724 }
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 resultobj = SWIG_Py_Void();
30732 return resultobj;
30733 fail:
30734 return NULL;
30735 }
30736
30737
30738 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30739 PyObject *resultobj = 0;
30740 wxPyApp *arg1 = (wxPyApp *) 0 ;
30741 wxString result;
30742 void *argp1 = 0 ;
30743 int res1 = 0 ;
30744 PyObject *swig_obj[1] ;
30745
30746 if (!args) SWIG_fail;
30747 swig_obj[0] = args;
30748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30749 if (!SWIG_IsOK(res1)) {
30750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30751 }
30752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30753 {
30754 PyThreadState* __tstate = wxPyBeginAllowThreads();
30755 result = ((wxPyApp const *)arg1)->GetAppName();
30756 wxPyEndAllowThreads(__tstate);
30757 if (PyErr_Occurred()) SWIG_fail;
30758 }
30759 {
30760 #if wxUSE_UNICODE
30761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30762 #else
30763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30764 #endif
30765 }
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30773 PyObject *resultobj = 0;
30774 wxPyApp *arg1 = (wxPyApp *) 0 ;
30775 wxString *arg2 = 0 ;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 bool temp2 = false ;
30779 PyObject * obj0 = 0 ;
30780 PyObject * obj1 = 0 ;
30781 char * kwnames[] = {
30782 (char *) "self",(char *) "name", NULL
30783 };
30784
30785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30787 if (!SWIG_IsOK(res1)) {
30788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30789 }
30790 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30791 {
30792 arg2 = wxString_in_helper(obj1);
30793 if (arg2 == NULL) SWIG_fail;
30794 temp2 = true;
30795 }
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 (arg1)->SetAppName((wxString const &)*arg2);
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 resultobj = SWIG_Py_Void();
30803 {
30804 if (temp2)
30805 delete arg2;
30806 }
30807 return resultobj;
30808 fail:
30809 {
30810 if (temp2)
30811 delete arg2;
30812 }
30813 return NULL;
30814 }
30815
30816
30817 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30818 PyObject *resultobj = 0;
30819 wxPyApp *arg1 = (wxPyApp *) 0 ;
30820 wxString result;
30821 void *argp1 = 0 ;
30822 int res1 = 0 ;
30823 PyObject *swig_obj[1] ;
30824
30825 if (!args) SWIG_fail;
30826 swig_obj[0] = args;
30827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30828 if (!SWIG_IsOK(res1)) {
30829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30830 }
30831 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 result = ((wxPyApp const *)arg1)->GetClassName();
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 {
30839 #if wxUSE_UNICODE
30840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30841 #else
30842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30843 #endif
30844 }
30845 return resultobj;
30846 fail:
30847 return NULL;
30848 }
30849
30850
30851 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30852 PyObject *resultobj = 0;
30853 wxPyApp *arg1 = (wxPyApp *) 0 ;
30854 wxString *arg2 = 0 ;
30855 void *argp1 = 0 ;
30856 int res1 = 0 ;
30857 bool temp2 = false ;
30858 PyObject * obj0 = 0 ;
30859 PyObject * obj1 = 0 ;
30860 char * kwnames[] = {
30861 (char *) "self",(char *) "name", NULL
30862 };
30863
30864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30868 }
30869 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30870 {
30871 arg2 = wxString_in_helper(obj1);
30872 if (arg2 == NULL) SWIG_fail;
30873 temp2 = true;
30874 }
30875 {
30876 PyThreadState* __tstate = wxPyBeginAllowThreads();
30877 (arg1)->SetClassName((wxString const &)*arg2);
30878 wxPyEndAllowThreads(__tstate);
30879 if (PyErr_Occurred()) SWIG_fail;
30880 }
30881 resultobj = SWIG_Py_Void();
30882 {
30883 if (temp2)
30884 delete arg2;
30885 }
30886 return resultobj;
30887 fail:
30888 {
30889 if (temp2)
30890 delete arg2;
30891 }
30892 return NULL;
30893 }
30894
30895
30896 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30897 PyObject *resultobj = 0;
30898 wxPyApp *arg1 = (wxPyApp *) 0 ;
30899 wxString *result = 0 ;
30900 void *argp1 = 0 ;
30901 int res1 = 0 ;
30902 PyObject *swig_obj[1] ;
30903
30904 if (!args) SWIG_fail;
30905 swig_obj[0] = args;
30906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30907 if (!SWIG_IsOK(res1)) {
30908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30909 }
30910 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 {
30914 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30915 result = (wxString *) &_result_ref;
30916 }
30917 wxPyEndAllowThreads(__tstate);
30918 if (PyErr_Occurred()) SWIG_fail;
30919 }
30920 {
30921 #if wxUSE_UNICODE
30922 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30923 #else
30924 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30925 #endif
30926 }
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj = 0;
30935 wxPyApp *arg1 = (wxPyApp *) 0 ;
30936 wxString *arg2 = 0 ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 bool temp2 = false ;
30940 PyObject * obj0 = 0 ;
30941 PyObject * obj1 = 0 ;
30942 char * kwnames[] = {
30943 (char *) "self",(char *) "name", NULL
30944 };
30945
30946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30948 if (!SWIG_IsOK(res1)) {
30949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30950 }
30951 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30952 {
30953 arg2 = wxString_in_helper(obj1);
30954 if (arg2 == NULL) SWIG_fail;
30955 temp2 = true;
30956 }
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 (arg1)->SetVendorName((wxString const &)*arg2);
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 resultobj = SWIG_Py_Void();
30964 {
30965 if (temp2)
30966 delete arg2;
30967 }
30968 return resultobj;
30969 fail:
30970 {
30971 if (temp2)
30972 delete arg2;
30973 }
30974 return NULL;
30975 }
30976
30977
30978 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30979 PyObject *resultobj = 0;
30980 wxPyApp *arg1 = (wxPyApp *) 0 ;
30981 wxAppTraits *result = 0 ;
30982 void *argp1 = 0 ;
30983 int res1 = 0 ;
30984 PyObject *swig_obj[1] ;
30985
30986 if (!args) SWIG_fail;
30987 swig_obj[0] = args;
30988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30989 if (!SWIG_IsOK(res1)) {
30990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30991 }
30992 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30993 {
30994 PyThreadState* __tstate = wxPyBeginAllowThreads();
30995 result = (wxAppTraits *)(arg1)->GetTraits();
30996 wxPyEndAllowThreads(__tstate);
30997 if (PyErr_Occurred()) SWIG_fail;
30998 }
30999 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
31000 return resultobj;
31001 fail:
31002 return NULL;
31003 }
31004
31005
31006 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31007 PyObject *resultobj = 0;
31008 wxPyApp *arg1 = (wxPyApp *) 0 ;
31009 void *argp1 = 0 ;
31010 int res1 = 0 ;
31011 PyObject *swig_obj[1] ;
31012
31013 if (!args) SWIG_fail;
31014 swig_obj[0] = args;
31015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31018 }
31019 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 (arg1)->ProcessPendingEvents();
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 resultobj = SWIG_Py_Void();
31027 return resultobj;
31028 fail:
31029 return NULL;
31030 }
31031
31032
31033 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31034 PyObject *resultobj = 0;
31035 wxPyApp *arg1 = (wxPyApp *) 0 ;
31036 bool arg2 = (bool) false ;
31037 bool result;
31038 void *argp1 = 0 ;
31039 int res1 = 0 ;
31040 bool val2 ;
31041 int ecode2 = 0 ;
31042 PyObject * obj0 = 0 ;
31043 PyObject * obj1 = 0 ;
31044 char * kwnames[] = {
31045 (char *) "self",(char *) "onlyIfNeeded", NULL
31046 };
31047
31048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
31049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31050 if (!SWIG_IsOK(res1)) {
31051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
31052 }
31053 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31054 if (obj1) {
31055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31056 if (!SWIG_IsOK(ecode2)) {
31057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
31058 }
31059 arg2 = static_cast< bool >(val2);
31060 }
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 result = (bool)(arg1)->Yield(arg2);
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 {
31068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31069 }
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31077 PyObject *resultobj = 0;
31078 wxPyApp *arg1 = (wxPyApp *) 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 PyObject *swig_obj[1] ;
31082
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31088 }
31089 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 (arg1)->WakeUpIdle();
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_Py_Void();
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31104 PyObject *resultobj = 0;
31105 bool result;
31106
31107 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
31108 {
31109 PyThreadState* __tstate = wxPyBeginAllowThreads();
31110 result = (bool)wxPyApp::IsMainLoopRunning();
31111 wxPyEndAllowThreads(__tstate);
31112 if (PyErr_Occurred()) SWIG_fail;
31113 }
31114 {
31115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31116 }
31117 return resultobj;
31118 fail:
31119 return NULL;
31120 }
31121
31122
31123 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31124 PyObject *resultobj = 0;
31125 wxPyApp *arg1 = (wxPyApp *) 0 ;
31126 int result;
31127 void *argp1 = 0 ;
31128 int res1 = 0 ;
31129 PyObject *swig_obj[1] ;
31130
31131 if (!args) SWIG_fail;
31132 swig_obj[0] = args;
31133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31134 if (!SWIG_IsOK(res1)) {
31135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31136 }
31137 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 result = (int)(arg1)->MainLoop();
31141 wxPyEndAllowThreads(__tstate);
31142 if (PyErr_Occurred()) SWIG_fail;
31143 }
31144 resultobj = SWIG_From_int(static_cast< int >(result));
31145 return resultobj;
31146 fail:
31147 return NULL;
31148 }
31149
31150
31151 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31152 PyObject *resultobj = 0;
31153 wxPyApp *arg1 = (wxPyApp *) 0 ;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 PyObject *swig_obj[1] ;
31157
31158 if (!args) SWIG_fail;
31159 swig_obj[0] = args;
31160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31161 if (!SWIG_IsOK(res1)) {
31162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
31163 }
31164 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 (arg1)->Exit();
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_Py_Void();
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 wxPyApp *arg1 = (wxPyApp *) 0 ;
31181 wxLayoutDirection result;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject *swig_obj[1] ;
31185
31186 if (!args) SWIG_fail;
31187 swig_obj[0] = args;
31188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31189 if (!SWIG_IsOK(res1)) {
31190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31191 }
31192 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_From_int(static_cast< int >(result));
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 PyObject *resultobj = 0;
31208 wxPyApp *arg1 = (wxPyApp *) 0 ;
31209 void *argp1 = 0 ;
31210 int res1 = 0 ;
31211 PyObject *swig_obj[1] ;
31212
31213 if (!args) SWIG_fail;
31214 swig_obj[0] = args;
31215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31216 if (!SWIG_IsOK(res1)) {
31217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31218 }
31219 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 (arg1)->ExitMainLoop();
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 resultobj = SWIG_Py_Void();
31227 return resultobj;
31228 fail:
31229 return NULL;
31230 }
31231
31232
31233 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31234 PyObject *resultobj = 0;
31235 wxPyApp *arg1 = (wxPyApp *) 0 ;
31236 bool result;
31237 void *argp1 = 0 ;
31238 int res1 = 0 ;
31239 PyObject *swig_obj[1] ;
31240
31241 if (!args) SWIG_fail;
31242 swig_obj[0] = args;
31243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31244 if (!SWIG_IsOK(res1)) {
31245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
31246 }
31247 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 result = (bool)(arg1)->Pending();
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 {
31255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31256 }
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31264 PyObject *resultobj = 0;
31265 wxPyApp *arg1 = (wxPyApp *) 0 ;
31266 bool result;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 PyObject *swig_obj[1] ;
31270
31271 if (!args) SWIG_fail;
31272 swig_obj[0] = args;
31273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31274 if (!SWIG_IsOK(res1)) {
31275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
31276 }
31277 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31278 {
31279 PyThreadState* __tstate = wxPyBeginAllowThreads();
31280 result = (bool)(arg1)->Dispatch();
31281 wxPyEndAllowThreads(__tstate);
31282 if (PyErr_Occurred()) SWIG_fail;
31283 }
31284 {
31285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31286 }
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31294 PyObject *resultobj = 0;
31295 wxPyApp *arg1 = (wxPyApp *) 0 ;
31296 bool result;
31297 void *argp1 = 0 ;
31298 int res1 = 0 ;
31299 PyObject *swig_obj[1] ;
31300
31301 if (!args) SWIG_fail;
31302 swig_obj[0] = args;
31303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31304 if (!SWIG_IsOK(res1)) {
31305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31306 }
31307 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 result = (bool)(arg1)->ProcessIdle();
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 {
31315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31316 }
31317 return resultobj;
31318 fail:
31319 return NULL;
31320 }
31321
31322
31323 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31324 PyObject *resultobj = 0;
31325 wxPyApp *arg1 = (wxPyApp *) 0 ;
31326 wxWindow *arg2 = (wxWindow *) 0 ;
31327 wxIdleEvent *arg3 = 0 ;
31328 bool result;
31329 void *argp1 = 0 ;
31330 int res1 = 0 ;
31331 void *argp2 = 0 ;
31332 int res2 = 0 ;
31333 void *argp3 = 0 ;
31334 int res3 = 0 ;
31335 PyObject * obj0 = 0 ;
31336 PyObject * obj1 = 0 ;
31337 PyObject * obj2 = 0 ;
31338 char * kwnames[] = {
31339 (char *) "self",(char *) "win",(char *) "event", NULL
31340 };
31341
31342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31344 if (!SWIG_IsOK(res1)) {
31345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31346 }
31347 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31348 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31349 if (!SWIG_IsOK(res2)) {
31350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
31351 }
31352 arg2 = reinterpret_cast< wxWindow * >(argp2);
31353 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
31354 if (!SWIG_IsOK(res3)) {
31355 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31356 }
31357 if (!argp3) {
31358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31359 }
31360 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 {
31368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31369 }
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31377 PyObject *resultobj = 0;
31378 wxPyApp *arg1 = (wxPyApp *) 0 ;
31379 bool result;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 PyObject *swig_obj[1] ;
31383
31384 if (!args) SWIG_fail;
31385 swig_obj[0] = args;
31386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31387 if (!SWIG_IsOK(res1)) {
31388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31389 }
31390 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = (bool)((wxPyApp const *)arg1)->IsActive();
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 {
31398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31399 }
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31407 PyObject *resultobj = 0;
31408 wxPyApp *arg1 = (wxPyApp *) 0 ;
31409 wxWindow *arg2 = (wxWindow *) 0 ;
31410 void *argp1 = 0 ;
31411 int res1 = 0 ;
31412 void *argp2 = 0 ;
31413 int res2 = 0 ;
31414 PyObject * obj0 = 0 ;
31415 PyObject * obj1 = 0 ;
31416 char * kwnames[] = {
31417 (char *) "self",(char *) "win", NULL
31418 };
31419
31420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
31421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31422 if (!SWIG_IsOK(res1)) {
31423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
31424 }
31425 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31427 if (!SWIG_IsOK(res2)) {
31428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
31429 }
31430 arg2 = reinterpret_cast< wxWindow * >(argp2);
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 (arg1)->SetTopWindow(arg2);
31434 wxPyEndAllowThreads(__tstate);
31435 if (PyErr_Occurred()) SWIG_fail;
31436 }
31437 resultobj = SWIG_Py_Void();
31438 return resultobj;
31439 fail:
31440 return NULL;
31441 }
31442
31443
31444 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31445 PyObject *resultobj = 0;
31446 wxPyApp *arg1 = (wxPyApp *) 0 ;
31447 wxWindow *result = 0 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 PyObject *swig_obj[1] ;
31451
31452 if (!args) SWIG_fail;
31453 swig_obj[0] = args;
31454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31455 if (!SWIG_IsOK(res1)) {
31456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31457 }
31458 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 {
31466 resultobj = wxPyMake_wxObject(result, (bool)0);
31467 }
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31475 PyObject *resultobj = 0;
31476 wxPyApp *arg1 = (wxPyApp *) 0 ;
31477 bool arg2 ;
31478 void *argp1 = 0 ;
31479 int res1 = 0 ;
31480 bool val2 ;
31481 int ecode2 = 0 ;
31482 PyObject * obj0 = 0 ;
31483 PyObject * obj1 = 0 ;
31484 char * kwnames[] = {
31485 (char *) "self",(char *) "flag", NULL
31486 };
31487
31488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
31489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31490 if (!SWIG_IsOK(res1)) {
31491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
31492 }
31493 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31494 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31495 if (!SWIG_IsOK(ecode2)) {
31496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
31497 }
31498 arg2 = static_cast< bool >(val2);
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 (arg1)->SetExitOnFrameDelete(arg2);
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 resultobj = SWIG_Py_Void();
31506 return resultobj;
31507 fail:
31508 return NULL;
31509 }
31510
31511
31512 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31513 PyObject *resultobj = 0;
31514 wxPyApp *arg1 = (wxPyApp *) 0 ;
31515 bool result;
31516 void *argp1 = 0 ;
31517 int res1 = 0 ;
31518 PyObject *swig_obj[1] ;
31519
31520 if (!args) SWIG_fail;
31521 swig_obj[0] = args;
31522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31523 if (!SWIG_IsOK(res1)) {
31524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31525 }
31526 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31527 {
31528 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31530 wxPyEndAllowThreads(__tstate);
31531 if (PyErr_Occurred()) SWIG_fail;
31532 }
31533 {
31534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31535 }
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxPyApp *arg1 = (wxPyApp *) 0 ;
31545 bool arg2 ;
31546 bool arg3 = (bool) false ;
31547 void *argp1 = 0 ;
31548 int res1 = 0 ;
31549 bool val2 ;
31550 int ecode2 = 0 ;
31551 bool val3 ;
31552 int ecode3 = 0 ;
31553 PyObject * obj0 = 0 ;
31554 PyObject * obj1 = 0 ;
31555 PyObject * obj2 = 0 ;
31556 char * kwnames[] = {
31557 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31558 };
31559
31560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31564 }
31565 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31566 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31567 if (!SWIG_IsOK(ecode2)) {
31568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31569 }
31570 arg2 = static_cast< bool >(val2);
31571 if (obj2) {
31572 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31573 if (!SWIG_IsOK(ecode3)) {
31574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31575 }
31576 arg3 = static_cast< bool >(val3);
31577 }
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 (arg1)->SetUseBestVisual(arg2,arg3);
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_Py_Void();
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31592 PyObject *resultobj = 0;
31593 wxPyApp *arg1 = (wxPyApp *) 0 ;
31594 bool result;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 PyObject *swig_obj[1] ;
31598
31599 if (!args) SWIG_fail;
31600 swig_obj[0] = args;
31601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31602 if (!SWIG_IsOK(res1)) {
31603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31604 }
31605 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 {
31613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31614 }
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31622 PyObject *resultobj = 0;
31623 wxPyApp *arg1 = (wxPyApp *) 0 ;
31624 int arg2 ;
31625 void *argp1 = 0 ;
31626 int res1 = 0 ;
31627 int val2 ;
31628 int ecode2 = 0 ;
31629 PyObject * obj0 = 0 ;
31630 PyObject * obj1 = 0 ;
31631 char * kwnames[] = {
31632 (char *) "self",(char *) "mode", NULL
31633 };
31634
31635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31637 if (!SWIG_IsOK(res1)) {
31638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31639 }
31640 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31641 ecode2 = SWIG_AsVal_int(obj1, &val2);
31642 if (!SWIG_IsOK(ecode2)) {
31643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31644 }
31645 arg2 = static_cast< int >(val2);
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 (arg1)->SetPrintMode(arg2);
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 resultobj = SWIG_Py_Void();
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661 wxPyApp *arg1 = (wxPyApp *) 0 ;
31662 int result;
31663 void *argp1 = 0 ;
31664 int res1 = 0 ;
31665 PyObject *swig_obj[1] ;
31666
31667 if (!args) SWIG_fail;
31668 swig_obj[0] = args;
31669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31670 if (!SWIG_IsOK(res1)) {
31671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31672 }
31673 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31677 wxPyEndAllowThreads(__tstate);
31678 if (PyErr_Occurred()) SWIG_fail;
31679 }
31680 resultobj = SWIG_From_int(static_cast< int >(result));
31681 return resultobj;
31682 fail:
31683 return NULL;
31684 }
31685
31686
31687 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31688 PyObject *resultobj = 0;
31689 wxPyApp *arg1 = (wxPyApp *) 0 ;
31690 int arg2 ;
31691 void *argp1 = 0 ;
31692 int res1 = 0 ;
31693 int val2 ;
31694 int ecode2 = 0 ;
31695 PyObject * obj0 = 0 ;
31696 PyObject * obj1 = 0 ;
31697 char * kwnames[] = {
31698 (char *) "self",(char *) "mode", NULL
31699 };
31700
31701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31705 }
31706 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31707 ecode2 = SWIG_AsVal_int(obj1, &val2);
31708 if (!SWIG_IsOK(ecode2)) {
31709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31710 }
31711 arg2 = static_cast< int >(val2);
31712 {
31713 PyThreadState* __tstate = wxPyBeginAllowThreads();
31714 (arg1)->SetAssertMode(arg2);
31715 wxPyEndAllowThreads(__tstate);
31716 if (PyErr_Occurred()) SWIG_fail;
31717 }
31718 resultobj = SWIG_Py_Void();
31719 return resultobj;
31720 fail:
31721 return NULL;
31722 }
31723
31724
31725 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31726 PyObject *resultobj = 0;
31727 wxPyApp *arg1 = (wxPyApp *) 0 ;
31728 int result;
31729 void *argp1 = 0 ;
31730 int res1 = 0 ;
31731 PyObject *swig_obj[1] ;
31732
31733 if (!args) SWIG_fail;
31734 swig_obj[0] = args;
31735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31736 if (!SWIG_IsOK(res1)) {
31737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31738 }
31739 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31740 {
31741 PyThreadState* __tstate = wxPyBeginAllowThreads();
31742 result = (int)(arg1)->GetAssertMode();
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 resultobj = SWIG_From_int(static_cast< int >(result));
31747 return resultobj;
31748 fail:
31749 return NULL;
31750 }
31751
31752
31753 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31754 PyObject *resultobj = 0;
31755 bool result;
31756
31757 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 {
31765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31766 }
31767 return resultobj;
31768 fail:
31769 return NULL;
31770 }
31771
31772
31773 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31774 PyObject *resultobj = 0;
31775 long result;
31776
31777 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 result = (long)wxPyApp::GetMacAboutMenuItemId();
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 resultobj = SWIG_From_long(static_cast< long >(result));
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 PyObject *resultobj = 0;
31793 long result;
31794
31795 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31796 {
31797 PyThreadState* __tstate = wxPyBeginAllowThreads();
31798 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31799 wxPyEndAllowThreads(__tstate);
31800 if (PyErr_Occurred()) SWIG_fail;
31801 }
31802 resultobj = SWIG_From_long(static_cast< long >(result));
31803 return resultobj;
31804 fail:
31805 return NULL;
31806 }
31807
31808
31809 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31810 PyObject *resultobj = 0;
31811 long result;
31812
31813 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (long)wxPyApp::GetMacExitMenuItemId();
31817 wxPyEndAllowThreads(__tstate);
31818 if (PyErr_Occurred()) SWIG_fail;
31819 }
31820 resultobj = SWIG_From_long(static_cast< long >(result));
31821 return resultobj;
31822 fail:
31823 return NULL;
31824 }
31825
31826
31827 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31828 PyObject *resultobj = 0;
31829 wxString result;
31830
31831 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31832 {
31833 PyThreadState* __tstate = wxPyBeginAllowThreads();
31834 result = wxPyApp::GetMacHelpMenuTitleName();
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 {
31839 #if wxUSE_UNICODE
31840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31841 #else
31842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31843 #endif
31844 }
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj = 0;
31853 bool arg1 ;
31854 bool val1 ;
31855 int ecode1 = 0 ;
31856 PyObject * obj0 = 0 ;
31857 char * kwnames[] = {
31858 (char *) "val", NULL
31859 };
31860
31861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31862 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31863 if (!SWIG_IsOK(ecode1)) {
31864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31865 }
31866 arg1 = static_cast< bool >(val1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_Py_Void();
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31881 PyObject *resultobj = 0;
31882 long arg1 ;
31883 long val1 ;
31884 int ecode1 = 0 ;
31885 PyObject * obj0 = 0 ;
31886 char * kwnames[] = {
31887 (char *) "val", NULL
31888 };
31889
31890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31891 ecode1 = SWIG_AsVal_long(obj0, &val1);
31892 if (!SWIG_IsOK(ecode1)) {
31893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31894 }
31895 arg1 = static_cast< long >(val1);
31896 {
31897 PyThreadState* __tstate = wxPyBeginAllowThreads();
31898 wxPyApp::SetMacAboutMenuItemId(arg1);
31899 wxPyEndAllowThreads(__tstate);
31900 if (PyErr_Occurred()) SWIG_fail;
31901 }
31902 resultobj = SWIG_Py_Void();
31903 return resultobj;
31904 fail:
31905 return NULL;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31910 PyObject *resultobj = 0;
31911 long arg1 ;
31912 long val1 ;
31913 int ecode1 = 0 ;
31914 PyObject * obj0 = 0 ;
31915 char * kwnames[] = {
31916 (char *) "val", NULL
31917 };
31918
31919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31920 ecode1 = SWIG_AsVal_long(obj0, &val1);
31921 if (!SWIG_IsOK(ecode1)) {
31922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31923 }
31924 arg1 = static_cast< long >(val1);
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_Py_Void();
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31939 PyObject *resultobj = 0;
31940 long arg1 ;
31941 long val1 ;
31942 int ecode1 = 0 ;
31943 PyObject * obj0 = 0 ;
31944 char * kwnames[] = {
31945 (char *) "val", NULL
31946 };
31947
31948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31949 ecode1 = SWIG_AsVal_long(obj0, &val1);
31950 if (!SWIG_IsOK(ecode1)) {
31951 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31952 }
31953 arg1 = static_cast< long >(val1);
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 wxPyApp::SetMacExitMenuItemId(arg1);
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_Py_Void();
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31968 PyObject *resultobj = 0;
31969 wxString *arg1 = 0 ;
31970 bool temp1 = false ;
31971 PyObject * obj0 = 0 ;
31972 char * kwnames[] = {
31973 (char *) "val", NULL
31974 };
31975
31976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31977 {
31978 arg1 = wxString_in_helper(obj0);
31979 if (arg1 == NULL) SWIG_fail;
31980 temp1 = true;
31981 }
31982 {
31983 PyThreadState* __tstate = wxPyBeginAllowThreads();
31984 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 resultobj = SWIG_Py_Void();
31989 {
31990 if (temp1)
31991 delete arg1;
31992 }
31993 return resultobj;
31994 fail:
31995 {
31996 if (temp1)
31997 delete arg1;
31998 }
31999 return NULL;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32004 PyObject *resultobj = 0;
32005 wxPyApp *arg1 = (wxPyApp *) 0 ;
32006 void *argp1 = 0 ;
32007 int res1 = 0 ;
32008 PyObject *swig_obj[1] ;
32009
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
32015 }
32016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 (arg1)->_BootstrapApp();
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_Py_Void();
32024 return resultobj;
32025 fail:
32026 return NULL;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32031 PyObject *resultobj = 0;
32032 int result;
32033
32034 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
32035 {
32036 PyThreadState* __tstate = wxPyBeginAllowThreads();
32037 result = (int)wxPyApp::GetComCtl32Version();
32038 wxPyEndAllowThreads(__tstate);
32039 if (PyErr_Occurred()) SWIG_fail;
32040 }
32041 resultobj = SWIG_From_int(static_cast< int >(result));
32042 return resultobj;
32043 fail:
32044 return NULL;
32045 }
32046
32047
32048 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32049 PyObject *resultobj = 0;
32050 bool result;
32051
32052 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
32053 {
32054 PyThreadState* __tstate = wxPyBeginAllowThreads();
32055 result = (bool)wxPyApp_IsDisplayAvailable();
32056 wxPyEndAllowThreads(__tstate);
32057 if (PyErr_Occurred()) SWIG_fail;
32058 }
32059 {
32060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32061 }
32062 return resultobj;
32063 fail:
32064 return NULL;
32065 }
32066
32067
32068 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32069 PyObject *obj;
32070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32071 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
32072 return SWIG_Py_Void();
32073 }
32074
32075 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32076 return SWIG_Python_InitShadowInstance(args);
32077 }
32078
32079 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32080 PyObject *resultobj = 0;
32081
32082 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 wxExit();
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 resultobj = SWIG_Py_Void();
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32097 PyObject *resultobj = 0;
32098 bool result;
32099
32100 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
32101 {
32102 PyThreadState* __tstate = wxPyBeginAllowThreads();
32103 result = (bool)wxYield();
32104 wxPyEndAllowThreads(__tstate);
32105 if (PyErr_Occurred()) SWIG_fail;
32106 }
32107 {
32108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32109 }
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 bool result;
32119
32120 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (bool)wxYieldIfNeeded();
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 {
32128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32129 }
32130 return resultobj;
32131 fail:
32132 return NULL;
32133 }
32134
32135
32136 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32137 PyObject *resultobj = 0;
32138 wxWindow *arg1 = (wxWindow *) NULL ;
32139 bool arg2 = (bool) false ;
32140 bool result;
32141 void *argp1 = 0 ;
32142 int res1 = 0 ;
32143 bool val2 ;
32144 int ecode2 = 0 ;
32145 PyObject * obj0 = 0 ;
32146 PyObject * obj1 = 0 ;
32147 char * kwnames[] = {
32148 (char *) "win",(char *) "onlyIfNeeded", NULL
32149 };
32150
32151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
32152 if (obj0) {
32153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32154 if (!SWIG_IsOK(res1)) {
32155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
32156 }
32157 arg1 = reinterpret_cast< wxWindow * >(argp1);
32158 }
32159 if (obj1) {
32160 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32161 if (!SWIG_IsOK(ecode2)) {
32162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
32163 }
32164 arg2 = static_cast< bool >(val2);
32165 }
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (bool)wxSafeYield(arg1,arg2);
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 {
32173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32174 }
32175 return resultobj;
32176 fail:
32177 return NULL;
32178 }
32179
32180
32181 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32182 PyObject *resultobj = 0;
32183
32184 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 wxWakeUpIdle();
32188 wxPyEndAllowThreads(__tstate);
32189 if (PyErr_Occurred()) SWIG_fail;
32190 }
32191 resultobj = SWIG_Py_Void();
32192 return resultobj;
32193 fail:
32194 return NULL;
32195 }
32196
32197
32198 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32199 PyObject *resultobj = 0;
32200 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
32201 wxEvent *arg2 = 0 ;
32202 void *argp1 = 0 ;
32203 int res1 = 0 ;
32204 void *argp2 = 0 ;
32205 int res2 = 0 ;
32206 PyObject * obj0 = 0 ;
32207 PyObject * obj1 = 0 ;
32208 char * kwnames[] = {
32209 (char *) "dest",(char *) "event", NULL
32210 };
32211
32212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
32213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
32214 if (!SWIG_IsOK(res1)) {
32215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
32216 }
32217 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
32218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
32219 if (!SWIG_IsOK(res2)) {
32220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32221 }
32222 if (!argp2) {
32223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32224 }
32225 arg2 = reinterpret_cast< wxEvent * >(argp2);
32226 {
32227 PyThreadState* __tstate = wxPyBeginAllowThreads();
32228 wxPostEvent(arg1,*arg2);
32229 wxPyEndAllowThreads(__tstate);
32230 if (PyErr_Occurred()) SWIG_fail;
32231 }
32232 resultobj = SWIG_Py_Void();
32233 return resultobj;
32234 fail:
32235 return NULL;
32236 }
32237
32238
32239 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32240 PyObject *resultobj = 0;
32241
32242 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 wxApp_CleanUp();
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 resultobj = SWIG_Py_Void();
32250 return resultobj;
32251 fail:
32252 return NULL;
32253 }
32254
32255
32256 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32257 PyObject *resultobj = 0;
32258 wxPyApp *result = 0 ;
32259
32260 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 result = (wxPyApp *)wxPyGetApp();
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 {
32268 resultobj = wxPyMake_wxObject(result, 0);
32269 }
32270 return resultobj;
32271 fail:
32272 return NULL;
32273 }
32274
32275
32276 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32277 PyObject *resultobj = 0;
32278 char *arg1 = (char *) 0 ;
32279 int res1 ;
32280 char *buf1 = 0 ;
32281 int alloc1 = 0 ;
32282 PyObject * obj0 = 0 ;
32283 char * kwnames[] = {
32284 (char *) "encoding", NULL
32285 };
32286
32287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
32288 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
32289 if (!SWIG_IsOK(res1)) {
32290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
32291 }
32292 arg1 = buf1;
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 wxSetDefaultPyEncoding((char const *)arg1);
32296 wxPyEndAllowThreads(__tstate);
32297 if (PyErr_Occurred()) SWIG_fail;
32298 }
32299 resultobj = SWIG_Py_Void();
32300 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32301 return resultobj;
32302 fail:
32303 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32304 return NULL;
32305 }
32306
32307
32308 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32309 PyObject *resultobj = 0;
32310 char *result = 0 ;
32311
32312 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 result = (char *)wxGetDefaultPyEncoding();
32316 wxPyEndAllowThreads(__tstate);
32317 if (PyErr_Occurred()) SWIG_fail;
32318 }
32319 resultobj = SWIG_FromCharPtr(result);
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32327 PyObject *resultobj = 0;
32328 wxEventLoop *result = 0 ;
32329
32330 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
32331 {
32332 PyThreadState* __tstate = wxPyBeginAllowThreads();
32333 result = (wxEventLoop *)new wxEventLoop();
32334 wxPyEndAllowThreads(__tstate);
32335 if (PyErr_Occurred()) SWIG_fail;
32336 }
32337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
32338 return resultobj;
32339 fail:
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *resultobj = 0;
32346 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 PyObject *swig_obj[1] ;
32350
32351 if (!args) SWIG_fail;
32352 swig_obj[0] = args;
32353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
32354 if (!SWIG_IsOK(res1)) {
32355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32356 }
32357 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 delete arg1;
32361
32362 wxPyEndAllowThreads(__tstate);
32363 if (PyErr_Occurred()) SWIG_fail;
32364 }
32365 resultobj = SWIG_Py_Void();
32366 return resultobj;
32367 fail:
32368 return NULL;
32369 }
32370
32371
32372 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32373 PyObject *resultobj = 0;
32374 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32375 int result;
32376 void *argp1 = 0 ;
32377 int res1 = 0 ;
32378 PyObject *swig_obj[1] ;
32379
32380 if (!args) SWIG_fail;
32381 swig_obj[0] = args;
32382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32383 if (!SWIG_IsOK(res1)) {
32384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32385 }
32386 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32387 {
32388 PyThreadState* __tstate = wxPyBeginAllowThreads();
32389 result = (int)(arg1)->Run();
32390 wxPyEndAllowThreads(__tstate);
32391 if (PyErr_Occurred()) SWIG_fail;
32392 }
32393 resultobj = SWIG_From_int(static_cast< int >(result));
32394 return resultobj;
32395 fail:
32396 return NULL;
32397 }
32398
32399
32400 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32401 PyObject *resultobj = 0;
32402 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32403 int arg2 = (int) 0 ;
32404 void *argp1 = 0 ;
32405 int res1 = 0 ;
32406 int val2 ;
32407 int ecode2 = 0 ;
32408 PyObject * obj0 = 0 ;
32409 PyObject * obj1 = 0 ;
32410 char * kwnames[] = {
32411 (char *) "self",(char *) "rc", NULL
32412 };
32413
32414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
32415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32416 if (!SWIG_IsOK(res1)) {
32417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32418 }
32419 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32420 if (obj1) {
32421 ecode2 = SWIG_AsVal_int(obj1, &val2);
32422 if (!SWIG_IsOK(ecode2)) {
32423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
32424 }
32425 arg2 = static_cast< int >(val2);
32426 }
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 (arg1)->Exit(arg2);
32430 wxPyEndAllowThreads(__tstate);
32431 if (PyErr_Occurred()) SWIG_fail;
32432 }
32433 resultobj = SWIG_Py_Void();
32434 return resultobj;
32435 fail:
32436 return NULL;
32437 }
32438
32439
32440 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 PyObject *resultobj = 0;
32442 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32443 bool result;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 PyObject *swig_obj[1] ;
32447
32448 if (!args) SWIG_fail;
32449 swig_obj[0] = args;
32450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32453 }
32454 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (bool)((wxEventLoop const *)arg1)->Pending();
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 {
32462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32463 }
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32471 PyObject *resultobj = 0;
32472 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32473 bool result;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 PyObject *swig_obj[1] ;
32477
32478 if (!args) SWIG_fail;
32479 swig_obj[0] = args;
32480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32481 if (!SWIG_IsOK(res1)) {
32482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32483 }
32484 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (bool)(arg1)->Dispatch();
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 {
32492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32503 bool result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxEventLoop *result = 0 ;
32533
32534 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32535 {
32536 PyThreadState* __tstate = wxPyBeginAllowThreads();
32537 result = (wxEventLoop *)wxEventLoop::GetActive();
32538 wxPyEndAllowThreads(__tstate);
32539 if (PyErr_Occurred()) SWIG_fail;
32540 }
32541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32542 return resultobj;
32543 fail:
32544 return NULL;
32545 }
32546
32547
32548 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32549 PyObject *resultobj = 0;
32550 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32551 void *argp1 = 0 ;
32552 int res1 = 0 ;
32553 PyObject * obj0 = 0 ;
32554 char * kwnames[] = {
32555 (char *) "loop", NULL
32556 };
32557
32558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32560 if (!SWIG_IsOK(res1)) {
32561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32562 }
32563 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32564 {
32565 PyThreadState* __tstate = wxPyBeginAllowThreads();
32566 wxEventLoop::SetActive(arg1);
32567 wxPyEndAllowThreads(__tstate);
32568 if (PyErr_Occurred()) SWIG_fail;
32569 }
32570 resultobj = SWIG_Py_Void();
32571 return resultobj;
32572 fail:
32573 return NULL;
32574 }
32575
32576
32577 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32578 PyObject *obj;
32579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32580 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32581 return SWIG_Py_Void();
32582 }
32583
32584 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32585 return SWIG_Python_InitShadowInstance(args);
32586 }
32587
32588 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32589 PyObject *resultobj = 0;
32590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32591 wxEventLoopActivator *result = 0 ;
32592 void *argp1 = 0 ;
32593 int res1 = 0 ;
32594 PyObject * obj0 = 0 ;
32595 char * kwnames[] = {
32596 (char *) "evtLoop", NULL
32597 };
32598
32599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32601 if (!SWIG_IsOK(res1)) {
32602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32603 }
32604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32612 return resultobj;
32613 fail:
32614 return NULL;
32615 }
32616
32617
32618 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32619 PyObject *resultobj = 0;
32620 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32621 void *argp1 = 0 ;
32622 int res1 = 0 ;
32623 PyObject *swig_obj[1] ;
32624
32625 if (!args) SWIG_fail;
32626 swig_obj[0] = args;
32627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32628 if (!SWIG_IsOK(res1)) {
32629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32630 }
32631 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32632 {
32633 PyThreadState* __tstate = wxPyBeginAllowThreads();
32634 delete arg1;
32635
32636 wxPyEndAllowThreads(__tstate);
32637 if (PyErr_Occurred()) SWIG_fail;
32638 }
32639 resultobj = SWIG_Py_Void();
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32647 PyObject *obj;
32648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32649 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32650 return SWIG_Py_Void();
32651 }
32652
32653 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 return SWIG_Python_InitShadowInstance(args);
32655 }
32656
32657 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32658 PyObject *resultobj = 0;
32659 int arg1 = (int) 0 ;
32660 int arg2 = (int) 0 ;
32661 int arg3 = (int) 0 ;
32662 wxAcceleratorEntry *result = 0 ;
32663 int val1 ;
32664 int ecode1 = 0 ;
32665 int val2 ;
32666 int ecode2 = 0 ;
32667 int val3 ;
32668 int ecode3 = 0 ;
32669 PyObject * obj0 = 0 ;
32670 PyObject * obj1 = 0 ;
32671 PyObject * obj2 = 0 ;
32672 char * kwnames[] = {
32673 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32674 };
32675
32676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32677 if (obj0) {
32678 ecode1 = SWIG_AsVal_int(obj0, &val1);
32679 if (!SWIG_IsOK(ecode1)) {
32680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32681 }
32682 arg1 = static_cast< int >(val1);
32683 }
32684 if (obj1) {
32685 ecode2 = SWIG_AsVal_int(obj1, &val2);
32686 if (!SWIG_IsOK(ecode2)) {
32687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32688 }
32689 arg2 = static_cast< int >(val2);
32690 }
32691 if (obj2) {
32692 ecode3 = SWIG_AsVal_int(obj2, &val3);
32693 if (!SWIG_IsOK(ecode3)) {
32694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32695 }
32696 arg3 = static_cast< int >(val3);
32697 }
32698 {
32699 PyThreadState* __tstate = wxPyBeginAllowThreads();
32700 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32701 wxPyEndAllowThreads(__tstate);
32702 if (PyErr_Occurred()) SWIG_fail;
32703 }
32704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32705 return resultobj;
32706 fail:
32707 return NULL;
32708 }
32709
32710
32711 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32712 PyObject *resultobj = 0;
32713 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32714 void *argp1 = 0 ;
32715 int res1 = 0 ;
32716 PyObject *swig_obj[1] ;
32717
32718 if (!args) SWIG_fail;
32719 swig_obj[0] = args;
32720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32721 if (!SWIG_IsOK(res1)) {
32722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32723 }
32724 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32725 {
32726 PyThreadState* __tstate = wxPyBeginAllowThreads();
32727 delete arg1;
32728
32729 wxPyEndAllowThreads(__tstate);
32730 if (PyErr_Occurred()) SWIG_fail;
32731 }
32732 resultobj = SWIG_Py_Void();
32733 return resultobj;
32734 fail:
32735 return NULL;
32736 }
32737
32738
32739 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32740 PyObject *resultobj = 0;
32741 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32742 int arg2 ;
32743 int arg3 ;
32744 int arg4 ;
32745 void *argp1 = 0 ;
32746 int res1 = 0 ;
32747 int val2 ;
32748 int ecode2 = 0 ;
32749 int val3 ;
32750 int ecode3 = 0 ;
32751 int val4 ;
32752 int ecode4 = 0 ;
32753 PyObject * obj0 = 0 ;
32754 PyObject * obj1 = 0 ;
32755 PyObject * obj2 = 0 ;
32756 PyObject * obj3 = 0 ;
32757 char * kwnames[] = {
32758 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32759 };
32760
32761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32763 if (!SWIG_IsOK(res1)) {
32764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32765 }
32766 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32767 ecode2 = SWIG_AsVal_int(obj1, &val2);
32768 if (!SWIG_IsOK(ecode2)) {
32769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32770 }
32771 arg2 = static_cast< int >(val2);
32772 ecode3 = SWIG_AsVal_int(obj2, &val3);
32773 if (!SWIG_IsOK(ecode3)) {
32774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32775 }
32776 arg3 = static_cast< int >(val3);
32777 ecode4 = SWIG_AsVal_int(obj3, &val4);
32778 if (!SWIG_IsOK(ecode4)) {
32779 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32780 }
32781 arg4 = static_cast< int >(val4);
32782 {
32783 PyThreadState* __tstate = wxPyBeginAllowThreads();
32784 (arg1)->Set(arg2,arg3,arg4);
32785 wxPyEndAllowThreads(__tstate);
32786 if (PyErr_Occurred()) SWIG_fail;
32787 }
32788 resultobj = SWIG_Py_Void();
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32796 PyObject *resultobj = 0;
32797 wxString *arg1 = 0 ;
32798 wxAcceleratorEntry *result = 0 ;
32799 bool temp1 = false ;
32800 PyObject * obj0 = 0 ;
32801 char * kwnames[] = {
32802 (char *) "str", NULL
32803 };
32804
32805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32806 {
32807 arg1 = wxString_in_helper(obj0);
32808 if (arg1 == NULL) SWIG_fail;
32809 temp1 = true;
32810 }
32811 {
32812 PyThreadState* __tstate = wxPyBeginAllowThreads();
32813 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32814 wxPyEndAllowThreads(__tstate);
32815 if (PyErr_Occurred()) SWIG_fail;
32816 }
32817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32818 {
32819 if (temp1)
32820 delete arg1;
32821 }
32822 return resultobj;
32823 fail:
32824 {
32825 if (temp1)
32826 delete arg1;
32827 }
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32833 PyObject *resultobj = 0;
32834 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32835 int result;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 PyObject *swig_obj[1] ;
32839
32840 if (!args) SWIG_fail;
32841 swig_obj[0] = args;
32842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32843 if (!SWIG_IsOK(res1)) {
32844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32845 }
32846 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32847 {
32848 PyThreadState* __tstate = wxPyBeginAllowThreads();
32849 result = (int)(arg1)->GetFlags();
32850 wxPyEndAllowThreads(__tstate);
32851 if (PyErr_Occurred()) SWIG_fail;
32852 }
32853 resultobj = SWIG_From_int(static_cast< int >(result));
32854 return resultobj;
32855 fail:
32856 return NULL;
32857 }
32858
32859
32860 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32861 PyObject *resultobj = 0;
32862 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32863 int result;
32864 void *argp1 = 0 ;
32865 int res1 = 0 ;
32866 PyObject *swig_obj[1] ;
32867
32868 if (!args) SWIG_fail;
32869 swig_obj[0] = args;
32870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32871 if (!SWIG_IsOK(res1)) {
32872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32873 }
32874 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32875 {
32876 PyThreadState* __tstate = wxPyBeginAllowThreads();
32877 result = (int)(arg1)->GetKeyCode();
32878 wxPyEndAllowThreads(__tstate);
32879 if (PyErr_Occurred()) SWIG_fail;
32880 }
32881 resultobj = SWIG_From_int(static_cast< int >(result));
32882 return resultobj;
32883 fail:
32884 return NULL;
32885 }
32886
32887
32888 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32889 PyObject *resultobj = 0;
32890 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32891 int result;
32892 void *argp1 = 0 ;
32893 int res1 = 0 ;
32894 PyObject *swig_obj[1] ;
32895
32896 if (!args) SWIG_fail;
32897 swig_obj[0] = args;
32898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32899 if (!SWIG_IsOK(res1)) {
32900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32901 }
32902 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32903 {
32904 PyThreadState* __tstate = wxPyBeginAllowThreads();
32905 result = (int)(arg1)->GetCommand();
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 resultobj = SWIG_From_int(static_cast< int >(result));
32910 return resultobj;
32911 fail:
32912 return NULL;
32913 }
32914
32915
32916 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32917 PyObject *resultobj = 0;
32918 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32919 bool result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 PyObject *swig_obj[1] ;
32923
32924 if (!args) SWIG_fail;
32925 swig_obj[0] = args;
32926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32927 if (!SWIG_IsOK(res1)) {
32928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32929 }
32930 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32931 {
32932 PyThreadState* __tstate = wxPyBeginAllowThreads();
32933 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32934 wxPyEndAllowThreads(__tstate);
32935 if (PyErr_Occurred()) SWIG_fail;
32936 }
32937 {
32938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32939 }
32940 return resultobj;
32941 fail:
32942 return NULL;
32943 }
32944
32945
32946 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32947 PyObject *resultobj = 0;
32948 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32949 wxString result;
32950 void *argp1 = 0 ;
32951 int res1 = 0 ;
32952 PyObject *swig_obj[1] ;
32953
32954 if (!args) SWIG_fail;
32955 swig_obj[0] = args;
32956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32957 if (!SWIG_IsOK(res1)) {
32958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32959 }
32960 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32961 {
32962 PyThreadState* __tstate = wxPyBeginAllowThreads();
32963 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32964 wxPyEndAllowThreads(__tstate);
32965 if (PyErr_Occurred()) SWIG_fail;
32966 }
32967 {
32968 #if wxUSE_UNICODE
32969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32970 #else
32971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32972 #endif
32973 }
32974 return resultobj;
32975 fail:
32976 return NULL;
32977 }
32978
32979
32980 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32981 PyObject *resultobj = 0;
32982 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32983 wxString *arg2 = 0 ;
32984 bool result;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 bool temp2 = false ;
32988 PyObject * obj0 = 0 ;
32989 PyObject * obj1 = 0 ;
32990 char * kwnames[] = {
32991 (char *) "self",(char *) "str", NULL
32992 };
32993
32994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32996 if (!SWIG_IsOK(res1)) {
32997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32998 }
32999 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
33000 {
33001 arg2 = wxString_in_helper(obj1);
33002 if (arg2 == NULL) SWIG_fail;
33003 temp2 = true;
33004 }
33005 {
33006 PyThreadState* __tstate = wxPyBeginAllowThreads();
33007 result = (bool)(arg1)->FromString((wxString const &)*arg2);
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 {
33012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33013 }
33014 {
33015 if (temp2)
33016 delete arg2;
33017 }
33018 return resultobj;
33019 fail:
33020 {
33021 if (temp2)
33022 delete arg2;
33023 }
33024 return NULL;
33025 }
33026
33027
33028 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33029 PyObject *obj;
33030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33031 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
33032 return SWIG_Py_Void();
33033 }
33034
33035 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33036 return SWIG_Python_InitShadowInstance(args);
33037 }
33038
33039 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33040 PyObject *resultobj = 0;
33041 int arg1 ;
33042 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
33043 wxAcceleratorTable *result = 0 ;
33044 PyObject * obj0 = 0 ;
33045 char * kwnames[] = {
33046 (char *) "n", NULL
33047 };
33048
33049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
33050 {
33051 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
33052 if (arg2) arg1 = PyList_Size(obj0);
33053 else arg1 = 0;
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 PyObject *swig_obj[1] ;
33074
33075 if (!args) SWIG_fail;
33076 swig_obj[0] = args;
33077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
33078 if (!SWIG_IsOK(res1)) {
33079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
33080 }
33081 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33082 {
33083 PyThreadState* __tstate = wxPyBeginAllowThreads();
33084 delete arg1;
33085
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = SWIG_Py_Void();
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33097 PyObject *resultobj = 0;
33098 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33099 bool result;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 PyObject *swig_obj[1] ;
33103
33104 if (!args) SWIG_fail;
33105 swig_obj[0] = args;
33106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 {
33118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33119 }
33120 return resultobj;
33121 fail:
33122 return NULL;
33123 }
33124
33125
33126 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33127 PyObject *obj;
33128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33129 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
33130 return SWIG_Py_Void();
33131 }
33132
33133 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33134 return SWIG_Python_InitShadowInstance(args);
33135 }
33136
33137 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
33138 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
33139 return 1;
33140 }
33141
33142
33143 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
33144 PyObject *pyobj = 0;
33145
33146 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
33147 return pyobj;
33148 }
33149
33150
33151 SWIGINTERN int PanelNameStr_set(PyObject *) {
33152 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
33153 return 1;
33154 }
33155
33156
33157 SWIGINTERN PyObject *PanelNameStr_get(void) {
33158 PyObject *pyobj = 0;
33159
33160 {
33161 #if wxUSE_UNICODE
33162 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33163 #else
33164 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33165 #endif
33166 }
33167 return pyobj;
33168 }
33169
33170
33171 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33172 PyObject *resultobj = 0;
33173 wxVisualAttributes *result = 0 ;
33174
33175 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
33176 {
33177 PyThreadState* __tstate = wxPyBeginAllowThreads();
33178 result = (wxVisualAttributes *)new_wxVisualAttributes();
33179 wxPyEndAllowThreads(__tstate);
33180 if (PyErr_Occurred()) SWIG_fail;
33181 }
33182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
33183 return resultobj;
33184 fail:
33185 return NULL;
33186 }
33187
33188
33189 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33190 PyObject *resultobj = 0;
33191 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 PyObject *swig_obj[1] ;
33195
33196 if (!args) SWIG_fail;
33197 swig_obj[0] = args;
33198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
33199 if (!SWIG_IsOK(res1)) {
33200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33201 }
33202 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33203 {
33204 PyThreadState* __tstate = wxPyBeginAllowThreads();
33205 delete_wxVisualAttributes(arg1);
33206
33207 wxPyEndAllowThreads(__tstate);
33208 if (PyErr_Occurred()) SWIG_fail;
33209 }
33210 resultobj = SWIG_Py_Void();
33211 return resultobj;
33212 fail:
33213 return NULL;
33214 }
33215
33216
33217 SWIGINTERN PyObject *_wrap_VisualAttributes__get_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33218 PyObject *resultobj = 0;
33219 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33220 wxFont result;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 PyObject *swig_obj[1] ;
33224
33225 if (!args) SWIG_fail;
33226 swig_obj[0] = args;
33227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33228 if (!SWIG_IsOK(res1)) {
33229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_font" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33230 }
33231 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 result = wxVisualAttributes__get_font(arg1);
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colFg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33246 PyObject *resultobj = 0;
33247 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33248 wxColour result;
33249 void *argp1 = 0 ;
33250 int res1 = 0 ;
33251 PyObject *swig_obj[1] ;
33252
33253 if (!args) SWIG_fail;
33254 swig_obj[0] = args;
33255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colFg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33258 }
33259 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = wxVisualAttributes__get_colFg(arg1);
33263 wxPyEndAllowThreads(__tstate);
33264 if (PyErr_Occurred()) SWIG_fail;
33265 }
33266 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33267 return resultobj;
33268 fail:
33269 return NULL;
33270 }
33271
33272
33273 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colBg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33274 PyObject *resultobj = 0;
33275 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33276 wxColour result;
33277 void *argp1 = 0 ;
33278 int res1 = 0 ;
33279 PyObject *swig_obj[1] ;
33280
33281 if (!args) SWIG_fail;
33282 swig_obj[0] = args;
33283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33284 if (!SWIG_IsOK(res1)) {
33285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colBg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33286 }
33287 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33288 {
33289 PyThreadState* __tstate = wxPyBeginAllowThreads();
33290 result = wxVisualAttributes__get_colBg(arg1);
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33295 return resultobj;
33296 fail:
33297 return NULL;
33298 }
33299
33300
33301 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33302 PyObject *obj;
33303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33304 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
33305 return SWIG_Py_Void();
33306 }
33307
33308 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33309 return SWIG_Python_InitShadowInstance(args);
33310 }
33311
33312 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33313 PyObject *resultobj = 0;
33314 wxWindow *arg1 = (wxWindow *) 0 ;
33315 int arg2 = (int) (int)-1 ;
33316 wxPoint const &arg3_defvalue = wxDefaultPosition ;
33317 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33318 wxSize const &arg4_defvalue = wxDefaultSize ;
33319 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33320 long arg5 = (long) 0 ;
33321 wxString const &arg6_defvalue = wxPyPanelNameStr ;
33322 wxString *arg6 = (wxString *) &arg6_defvalue ;
33323 wxWindow *result = 0 ;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 int val2 ;
33327 int ecode2 = 0 ;
33328 wxPoint temp3 ;
33329 wxSize temp4 ;
33330 long val5 ;
33331 int ecode5 = 0 ;
33332 bool temp6 = false ;
33333 PyObject * obj0 = 0 ;
33334 PyObject * obj1 = 0 ;
33335 PyObject * obj2 = 0 ;
33336 PyObject * obj3 = 0 ;
33337 PyObject * obj4 = 0 ;
33338 PyObject * obj5 = 0 ;
33339 char * kwnames[] = {
33340 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33341 };
33342
33343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33345 if (!SWIG_IsOK(res1)) {
33346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
33347 }
33348 arg1 = reinterpret_cast< wxWindow * >(argp1);
33349 if (obj1) {
33350 ecode2 = SWIG_AsVal_int(obj1, &val2);
33351 if (!SWIG_IsOK(ecode2)) {
33352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
33353 }
33354 arg2 = static_cast< int >(val2);
33355 }
33356 if (obj2) {
33357 {
33358 arg3 = &temp3;
33359 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33360 }
33361 }
33362 if (obj3) {
33363 {
33364 arg4 = &temp4;
33365 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33366 }
33367 }
33368 if (obj4) {
33369 ecode5 = SWIG_AsVal_long(obj4, &val5);
33370 if (!SWIG_IsOK(ecode5)) {
33371 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
33372 }
33373 arg5 = static_cast< long >(val5);
33374 }
33375 if (obj5) {
33376 {
33377 arg6 = wxString_in_helper(obj5);
33378 if (arg6 == NULL) SWIG_fail;
33379 temp6 = true;
33380 }
33381 }
33382 {
33383 if (!wxPyCheckForApp()) SWIG_fail;
33384 PyThreadState* __tstate = wxPyBeginAllowThreads();
33385 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
33386 wxPyEndAllowThreads(__tstate);
33387 if (PyErr_Occurred()) SWIG_fail;
33388 }
33389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
33390 {
33391 if (temp6)
33392 delete arg6;
33393 }
33394 return resultobj;
33395 fail:
33396 {
33397 if (temp6)
33398 delete arg6;
33399 }
33400 return NULL;
33401 }
33402
33403
33404 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33405 PyObject *resultobj = 0;
33406 wxWindow *result = 0 ;
33407
33408 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
33409 {
33410 if (!wxPyCheckForApp()) SWIG_fail;
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (wxWindow *)new wxWindow();
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
33417 return resultobj;
33418 fail:
33419 return NULL;
33420 }
33421
33422
33423 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33424 PyObject *resultobj = 0;
33425 wxWindow *arg1 = (wxWindow *) 0 ;
33426 wxWindow *arg2 = (wxWindow *) 0 ;
33427 int arg3 = (int) (int)-1 ;
33428 wxPoint const &arg4_defvalue = wxDefaultPosition ;
33429 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
33430 wxSize const &arg5_defvalue = wxDefaultSize ;
33431 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
33432 long arg6 = (long) 0 ;
33433 wxString const &arg7_defvalue = wxPyPanelNameStr ;
33434 wxString *arg7 = (wxString *) &arg7_defvalue ;
33435 bool result;
33436 void *argp1 = 0 ;
33437 int res1 = 0 ;
33438 void *argp2 = 0 ;
33439 int res2 = 0 ;
33440 int val3 ;
33441 int ecode3 = 0 ;
33442 wxPoint temp4 ;
33443 wxSize temp5 ;
33444 long val6 ;
33445 int ecode6 = 0 ;
33446 bool temp7 = false ;
33447 PyObject * obj0 = 0 ;
33448 PyObject * obj1 = 0 ;
33449 PyObject * obj2 = 0 ;
33450 PyObject * obj3 = 0 ;
33451 PyObject * obj4 = 0 ;
33452 PyObject * obj5 = 0 ;
33453 PyObject * obj6 = 0 ;
33454 char * kwnames[] = {
33455 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33456 };
33457
33458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33460 if (!SWIG_IsOK(res1)) {
33461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33462 }
33463 arg1 = reinterpret_cast< wxWindow * >(argp1);
33464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33465 if (!SWIG_IsOK(res2)) {
33466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33467 }
33468 arg2 = reinterpret_cast< wxWindow * >(argp2);
33469 if (obj2) {
33470 ecode3 = SWIG_AsVal_int(obj2, &val3);
33471 if (!SWIG_IsOK(ecode3)) {
33472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33473 }
33474 arg3 = static_cast< int >(val3);
33475 }
33476 if (obj3) {
33477 {
33478 arg4 = &temp4;
33479 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33480 }
33481 }
33482 if (obj4) {
33483 {
33484 arg5 = &temp5;
33485 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33486 }
33487 }
33488 if (obj5) {
33489 ecode6 = SWIG_AsVal_long(obj5, &val6);
33490 if (!SWIG_IsOK(ecode6)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33492 }
33493 arg6 = static_cast< long >(val6);
33494 }
33495 if (obj6) {
33496 {
33497 arg7 = wxString_in_helper(obj6);
33498 if (arg7 == NULL) SWIG_fail;
33499 temp7 = true;
33500 }
33501 }
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33510 }
33511 {
33512 if (temp7)
33513 delete arg7;
33514 }
33515 return resultobj;
33516 fail:
33517 {
33518 if (temp7)
33519 delete arg7;
33520 }
33521 return NULL;
33522 }
33523
33524
33525 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33526 PyObject *resultobj = 0;
33527 wxWindow *arg1 = (wxWindow *) 0 ;
33528 bool arg2 = (bool) false ;
33529 bool result;
33530 void *argp1 = 0 ;
33531 int res1 = 0 ;
33532 bool val2 ;
33533 int ecode2 = 0 ;
33534 PyObject * obj0 = 0 ;
33535 PyObject * obj1 = 0 ;
33536 char * kwnames[] = {
33537 (char *) "self",(char *) "force", NULL
33538 };
33539
33540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33542 if (!SWIG_IsOK(res1)) {
33543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33544 }
33545 arg1 = reinterpret_cast< wxWindow * >(argp1);
33546 if (obj1) {
33547 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33548 if (!SWIG_IsOK(ecode2)) {
33549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33550 }
33551 arg2 = static_cast< bool >(val2);
33552 }
33553 {
33554 PyThreadState* __tstate = wxPyBeginAllowThreads();
33555 result = (bool)(arg1)->Close(arg2);
33556 wxPyEndAllowThreads(__tstate);
33557 if (PyErr_Occurred()) SWIG_fail;
33558 }
33559 {
33560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33561 }
33562 return resultobj;
33563 fail:
33564 return NULL;
33565 }
33566
33567
33568 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33569 PyObject *resultobj = 0;
33570 wxWindow *arg1 = (wxWindow *) 0 ;
33571 bool result;
33572 void *argp1 = 0 ;
33573 int res1 = 0 ;
33574 PyObject *swig_obj[1] ;
33575
33576 if (!args) SWIG_fail;
33577 swig_obj[0] = args;
33578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33579 if (!SWIG_IsOK(res1)) {
33580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33581 }
33582 arg1 = reinterpret_cast< wxWindow * >(argp1);
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 result = (bool)(arg1)->Destroy();
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 {
33590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33591 }
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33599 PyObject *resultobj = 0;
33600 wxWindow *arg1 = (wxWindow *) 0 ;
33601 bool result;
33602 void *argp1 = 0 ;
33603 int res1 = 0 ;
33604 PyObject *swig_obj[1] ;
33605
33606 if (!args) SWIG_fail;
33607 swig_obj[0] = args;
33608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33609 if (!SWIG_IsOK(res1)) {
33610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33611 }
33612 arg1 = reinterpret_cast< wxWindow * >(argp1);
33613 {
33614 PyThreadState* __tstate = wxPyBeginAllowThreads();
33615 result = (bool)(arg1)->DestroyChildren();
33616 wxPyEndAllowThreads(__tstate);
33617 if (PyErr_Occurred()) SWIG_fail;
33618 }
33619 {
33620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33621 }
33622 return resultobj;
33623 fail:
33624 return NULL;
33625 }
33626
33627
33628 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33629 PyObject *resultobj = 0;
33630 wxWindow *arg1 = (wxWindow *) 0 ;
33631 bool result;
33632 void *argp1 = 0 ;
33633 int res1 = 0 ;
33634 PyObject *swig_obj[1] ;
33635
33636 if (!args) SWIG_fail;
33637 swig_obj[0] = args;
33638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33639 if (!SWIG_IsOK(res1)) {
33640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33641 }
33642 arg1 = reinterpret_cast< wxWindow * >(argp1);
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 {
33650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33651 }
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33659 PyObject *resultobj = 0;
33660 wxWindow *arg1 = (wxWindow *) 0 ;
33661 wxString *arg2 = 0 ;
33662 void *argp1 = 0 ;
33663 int res1 = 0 ;
33664 bool temp2 = false ;
33665 PyObject * obj0 = 0 ;
33666 PyObject * obj1 = 0 ;
33667 char * kwnames[] = {
33668 (char *) "self",(char *) "label", NULL
33669 };
33670
33671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 {
33678 arg2 = wxString_in_helper(obj1);
33679 if (arg2 == NULL) SWIG_fail;
33680 temp2 = true;
33681 }
33682 {
33683 PyThreadState* __tstate = wxPyBeginAllowThreads();
33684 (arg1)->SetLabel((wxString const &)*arg2);
33685 wxPyEndAllowThreads(__tstate);
33686 if (PyErr_Occurred()) SWIG_fail;
33687 }
33688 resultobj = SWIG_Py_Void();
33689 {
33690 if (temp2)
33691 delete arg2;
33692 }
33693 return resultobj;
33694 fail:
33695 {
33696 if (temp2)
33697 delete arg2;
33698 }
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 wxString result;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 PyObject *swig_obj[1] ;
33710
33711 if (!args) SWIG_fail;
33712 swig_obj[0] = args;
33713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33714 if (!SWIG_IsOK(res1)) {
33715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33716 }
33717 arg1 = reinterpret_cast< wxWindow * >(argp1);
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 result = ((wxWindow const *)arg1)->GetLabel();
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 {
33725 #if wxUSE_UNICODE
33726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33727 #else
33728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33729 #endif
33730 }
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxWindow *arg1 = (wxWindow *) 0 ;
33740 wxString *arg2 = 0 ;
33741 void *argp1 = 0 ;
33742 int res1 = 0 ;
33743 bool temp2 = false ;
33744 PyObject * obj0 = 0 ;
33745 PyObject * obj1 = 0 ;
33746 char * kwnames[] = {
33747 (char *) "self",(char *) "name", NULL
33748 };
33749
33750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33752 if (!SWIG_IsOK(res1)) {
33753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33754 }
33755 arg1 = reinterpret_cast< wxWindow * >(argp1);
33756 {
33757 arg2 = wxString_in_helper(obj1);
33758 if (arg2 == NULL) SWIG_fail;
33759 temp2 = true;
33760 }
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 (arg1)->SetName((wxString const &)*arg2);
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 resultobj = SWIG_Py_Void();
33768 {
33769 if (temp2)
33770 delete arg2;
33771 }
33772 return resultobj;
33773 fail:
33774 {
33775 if (temp2)
33776 delete arg2;
33777 }
33778 return NULL;
33779 }
33780
33781
33782 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33783 PyObject *resultobj = 0;
33784 wxWindow *arg1 = (wxWindow *) 0 ;
33785 wxString result;
33786 void *argp1 = 0 ;
33787 int res1 = 0 ;
33788 PyObject *swig_obj[1] ;
33789
33790 if (!args) SWIG_fail;
33791 swig_obj[0] = args;
33792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res1)) {
33794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33795 }
33796 arg1 = reinterpret_cast< wxWindow * >(argp1);
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 result = ((wxWindow const *)arg1)->GetName();
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 {
33804 #if wxUSE_UNICODE
33805 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33806 #else
33807 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33808 #endif
33809 }
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 wxWindowVariant arg2 ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 int val2 ;
33823 int ecode2 = 0 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 char * kwnames[] = {
33827 (char *) "self",(char *) "variant", NULL
33828 };
33829
33830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33832 if (!SWIG_IsOK(res1)) {
33833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33834 }
33835 arg1 = reinterpret_cast< wxWindow * >(argp1);
33836 ecode2 = SWIG_AsVal_int(obj1, &val2);
33837 if (!SWIG_IsOK(ecode2)) {
33838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33839 }
33840 arg2 = static_cast< wxWindowVariant >(val2);
33841 {
33842 PyThreadState* __tstate = wxPyBeginAllowThreads();
33843 (arg1)->SetWindowVariant(arg2);
33844 wxPyEndAllowThreads(__tstate);
33845 if (PyErr_Occurred()) SWIG_fail;
33846 }
33847 resultobj = SWIG_Py_Void();
33848 return resultobj;
33849 fail:
33850 return NULL;
33851 }
33852
33853
33854 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33855 PyObject *resultobj = 0;
33856 wxWindow *arg1 = (wxWindow *) 0 ;
33857 wxWindowVariant result;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 PyObject *swig_obj[1] ;
33861
33862 if (!args) SWIG_fail;
33863 swig_obj[0] = args;
33864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33867 }
33868 arg1 = reinterpret_cast< wxWindow * >(argp1);
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33872 wxPyEndAllowThreads(__tstate);
33873 if (PyErr_Occurred()) SWIG_fail;
33874 }
33875 resultobj = SWIG_From_int(static_cast< int >(result));
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj = 0;
33884 wxWindow *arg1 = (wxWindow *) 0 ;
33885 int arg2 ;
33886 void *argp1 = 0 ;
33887 int res1 = 0 ;
33888 int val2 ;
33889 int ecode2 = 0 ;
33890 PyObject * obj0 = 0 ;
33891 PyObject * obj1 = 0 ;
33892 char * kwnames[] = {
33893 (char *) "self",(char *) "winid", NULL
33894 };
33895
33896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33898 if (!SWIG_IsOK(res1)) {
33899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33900 }
33901 arg1 = reinterpret_cast< wxWindow * >(argp1);
33902 ecode2 = SWIG_AsVal_int(obj1, &val2);
33903 if (!SWIG_IsOK(ecode2)) {
33904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33905 }
33906 arg2 = static_cast< int >(val2);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 (arg1)->SetId(arg2);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_Py_Void();
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 int result;
33924 void *argp1 = 0 ;
33925 int res1 = 0 ;
33926 PyObject *swig_obj[1] ;
33927
33928 if (!args) SWIG_fail;
33929 swig_obj[0] = args;
33930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 result = (int)((wxWindow const *)arg1)->GetId();
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 resultobj = SWIG_From_int(static_cast< int >(result));
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33949 PyObject *resultobj = 0;
33950 int result;
33951
33952 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33953 {
33954 PyThreadState* __tstate = wxPyBeginAllowThreads();
33955 result = (int)wxWindow::NewControlId();
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 resultobj = SWIG_From_int(static_cast< int >(result));
33960 return resultobj;
33961 fail:
33962 return NULL;
33963 }
33964
33965
33966 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33967 PyObject *resultobj = 0;
33968 int arg1 ;
33969 int result;
33970 int val1 ;
33971 int ecode1 = 0 ;
33972 PyObject * obj0 = 0 ;
33973 char * kwnames[] = {
33974 (char *) "winid", NULL
33975 };
33976
33977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33978 ecode1 = SWIG_AsVal_int(obj0, &val1);
33979 if (!SWIG_IsOK(ecode1)) {
33980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33981 }
33982 arg1 = static_cast< int >(val1);
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 result = (int)wxWindow::NextControlId(arg1);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_From_int(static_cast< int >(result));
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 int arg1 ;
33999 int result;
34000 int val1 ;
34001 int ecode1 = 0 ;
34002 PyObject * obj0 = 0 ;
34003 char * kwnames[] = {
34004 (char *) "winid", NULL
34005 };
34006
34007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
34008 ecode1 = SWIG_AsVal_int(obj0, &val1);
34009 if (!SWIG_IsOK(ecode1)) {
34010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
34011 }
34012 arg1 = static_cast< int >(val1);
34013 {
34014 PyThreadState* __tstate = wxPyBeginAllowThreads();
34015 result = (int)wxWindow::PrevControlId(arg1);
34016 wxPyEndAllowThreads(__tstate);
34017 if (PyErr_Occurred()) SWIG_fail;
34018 }
34019 resultobj = SWIG_From_int(static_cast< int >(result));
34020 return resultobj;
34021 fail:
34022 return NULL;
34023 }
34024
34025
34026 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34027 PyObject *resultobj = 0;
34028 wxWindow *arg1 = (wxWindow *) 0 ;
34029 wxLayoutDirection result;
34030 void *argp1 = 0 ;
34031 int res1 = 0 ;
34032 PyObject *swig_obj[1] ;
34033
34034 if (!args) SWIG_fail;
34035 swig_obj[0] = args;
34036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34037 if (!SWIG_IsOK(res1)) {
34038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34039 }
34040 arg1 = reinterpret_cast< wxWindow * >(argp1);
34041 {
34042 PyThreadState* __tstate = wxPyBeginAllowThreads();
34043 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
34044 wxPyEndAllowThreads(__tstate);
34045 if (PyErr_Occurred()) SWIG_fail;
34046 }
34047 resultobj = SWIG_From_int(static_cast< int >(result));
34048 return resultobj;
34049 fail:
34050 return NULL;
34051 }
34052
34053
34054 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34055 PyObject *resultobj = 0;
34056 wxWindow *arg1 = (wxWindow *) 0 ;
34057 wxLayoutDirection arg2 ;
34058 void *argp1 = 0 ;
34059 int res1 = 0 ;
34060 int val2 ;
34061 int ecode2 = 0 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "dir", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 ecode2 = SWIG_AsVal_int(obj1, &val2);
34075 if (!SWIG_IsOK(ecode2)) {
34076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
34077 }
34078 arg2 = static_cast< wxLayoutDirection >(val2);
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 (arg1)->SetLayoutDirection(arg2);
34082 wxPyEndAllowThreads(__tstate);
34083 if (PyErr_Occurred()) SWIG_fail;
34084 }
34085 resultobj = SWIG_Py_Void();
34086 return resultobj;
34087 fail:
34088 return NULL;
34089 }
34090
34091
34092 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34093 PyObject *resultobj = 0;
34094 wxWindow *arg1 = (wxWindow *) 0 ;
34095 int arg2 ;
34096 int arg3 ;
34097 int arg4 ;
34098 int result;
34099 void *argp1 = 0 ;
34100 int res1 = 0 ;
34101 int val2 ;
34102 int ecode2 = 0 ;
34103 int val3 ;
34104 int ecode3 = 0 ;
34105 int val4 ;
34106 int ecode4 = 0 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 PyObject * obj2 = 0 ;
34110 PyObject * obj3 = 0 ;
34111 char * kwnames[] = {
34112 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
34113 };
34114
34115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34117 if (!SWIG_IsOK(res1)) {
34118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34119 }
34120 arg1 = reinterpret_cast< wxWindow * >(argp1);
34121 ecode2 = SWIG_AsVal_int(obj1, &val2);
34122 if (!SWIG_IsOK(ecode2)) {
34123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
34124 }
34125 arg2 = static_cast< int >(val2);
34126 ecode3 = SWIG_AsVal_int(obj2, &val3);
34127 if (!SWIG_IsOK(ecode3)) {
34128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
34129 }
34130 arg3 = static_cast< int >(val3);
34131 ecode4 = SWIG_AsVal_int(obj3, &val4);
34132 if (!SWIG_IsOK(ecode4)) {
34133 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
34134 }
34135 arg4 = static_cast< int >(val4);
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 resultobj = SWIG_From_int(static_cast< int >(result));
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34150 PyObject *resultobj = 0;
34151 wxWindow *arg1 = (wxWindow *) 0 ;
34152 wxSize *arg2 = 0 ;
34153 void *argp1 = 0 ;
34154 int res1 = 0 ;
34155 wxSize temp2 ;
34156 PyObject * obj0 = 0 ;
34157 PyObject * obj1 = 0 ;
34158 char * kwnames[] = {
34159 (char *) "self",(char *) "size", NULL
34160 };
34161
34162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
34163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34164 if (!SWIG_IsOK(res1)) {
34165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34166 }
34167 arg1 = reinterpret_cast< wxWindow * >(argp1);
34168 {
34169 arg2 = &temp2;
34170 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34171 }
34172 {
34173 PyThreadState* __tstate = wxPyBeginAllowThreads();
34174 (arg1)->SetSize((wxSize const &)*arg2);
34175 wxPyEndAllowThreads(__tstate);
34176 if (PyErr_Occurred()) SWIG_fail;
34177 }
34178 resultobj = SWIG_Py_Void();
34179 return resultobj;
34180 fail:
34181 return NULL;
34182 }
34183
34184
34185 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34186 PyObject *resultobj = 0;
34187 wxWindow *arg1 = (wxWindow *) 0 ;
34188 int arg2 ;
34189 int arg3 ;
34190 int arg4 ;
34191 int arg5 ;
34192 int arg6 = (int) wxSIZE_AUTO ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 int val2 ;
34196 int ecode2 = 0 ;
34197 int val3 ;
34198 int ecode3 = 0 ;
34199 int val4 ;
34200 int ecode4 = 0 ;
34201 int val5 ;
34202 int ecode5 = 0 ;
34203 int val6 ;
34204 int ecode6 = 0 ;
34205 PyObject * obj0 = 0 ;
34206 PyObject * obj1 = 0 ;
34207 PyObject * obj2 = 0 ;
34208 PyObject * obj3 = 0 ;
34209 PyObject * obj4 = 0 ;
34210 PyObject * obj5 = 0 ;
34211 char * kwnames[] = {
34212 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
34213 };
34214
34215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34217 if (!SWIG_IsOK(res1)) {
34218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
34219 }
34220 arg1 = reinterpret_cast< wxWindow * >(argp1);
34221 ecode2 = SWIG_AsVal_int(obj1, &val2);
34222 if (!SWIG_IsOK(ecode2)) {
34223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
34224 }
34225 arg2 = static_cast< int >(val2);
34226 ecode3 = SWIG_AsVal_int(obj2, &val3);
34227 if (!SWIG_IsOK(ecode3)) {
34228 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
34229 }
34230 arg3 = static_cast< int >(val3);
34231 ecode4 = SWIG_AsVal_int(obj3, &val4);
34232 if (!SWIG_IsOK(ecode4)) {
34233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
34234 }
34235 arg4 = static_cast< int >(val4);
34236 ecode5 = SWIG_AsVal_int(obj4, &val5);
34237 if (!SWIG_IsOK(ecode5)) {
34238 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
34239 }
34240 arg5 = static_cast< int >(val5);
34241 if (obj5) {
34242 ecode6 = SWIG_AsVal_int(obj5, &val6);
34243 if (!SWIG_IsOK(ecode6)) {
34244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
34245 }
34246 arg6 = static_cast< int >(val6);
34247 }
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 resultobj = SWIG_Py_Void();
34255 return resultobj;
34256 fail:
34257 return NULL;
34258 }
34259
34260
34261 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34262 PyObject *resultobj = 0;
34263 wxWindow *arg1 = (wxWindow *) 0 ;
34264 wxRect *arg2 = 0 ;
34265 int arg3 = (int) wxSIZE_AUTO ;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 wxRect temp2 ;
34269 int val3 ;
34270 int ecode3 = 0 ;
34271 PyObject * obj0 = 0 ;
34272 PyObject * obj1 = 0 ;
34273 PyObject * obj2 = 0 ;
34274 char * kwnames[] = {
34275 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
34276 };
34277
34278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34280 if (!SWIG_IsOK(res1)) {
34281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34282 }
34283 arg1 = reinterpret_cast< wxWindow * >(argp1);
34284 {
34285 arg2 = &temp2;
34286 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34287 }
34288 if (obj2) {
34289 ecode3 = SWIG_AsVal_int(obj2, &val3);
34290 if (!SWIG_IsOK(ecode3)) {
34291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
34292 }
34293 arg3 = static_cast< int >(val3);
34294 }
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 (arg1)->SetSize((wxRect const &)*arg2,arg3);
34298 wxPyEndAllowThreads(__tstate);
34299 if (PyErr_Occurred()) SWIG_fail;
34300 }
34301 resultobj = SWIG_Py_Void();
34302 return resultobj;
34303 fail:
34304 return NULL;
34305 }
34306
34307
34308 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34309 PyObject *resultobj = 0;
34310 wxWindow *arg1 = (wxWindow *) 0 ;
34311 int arg2 ;
34312 int arg3 ;
34313 void *argp1 = 0 ;
34314 int res1 = 0 ;
34315 int val2 ;
34316 int ecode2 = 0 ;
34317 int val3 ;
34318 int ecode3 = 0 ;
34319 PyObject * obj0 = 0 ;
34320 PyObject * obj1 = 0 ;
34321 PyObject * obj2 = 0 ;
34322 char * kwnames[] = {
34323 (char *) "self",(char *) "width",(char *) "height", NULL
34324 };
34325
34326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34330 }
34331 arg1 = reinterpret_cast< wxWindow * >(argp1);
34332 ecode2 = SWIG_AsVal_int(obj1, &val2);
34333 if (!SWIG_IsOK(ecode2)) {
34334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
34335 }
34336 arg2 = static_cast< int >(val2);
34337 ecode3 = SWIG_AsVal_int(obj2, &val3);
34338 if (!SWIG_IsOK(ecode3)) {
34339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
34340 }
34341 arg3 = static_cast< int >(val3);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 (arg1)->SetSize(arg2,arg3);
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_Py_Void();
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34356 PyObject *resultobj = 0;
34357 wxWindow *arg1 = (wxWindow *) 0 ;
34358 wxPoint *arg2 = 0 ;
34359 int arg3 = (int) wxSIZE_USE_EXISTING ;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 wxPoint temp2 ;
34363 int val3 ;
34364 int ecode3 = 0 ;
34365 PyObject * obj0 = 0 ;
34366 PyObject * obj1 = 0 ;
34367 PyObject * obj2 = 0 ;
34368 char * kwnames[] = {
34369 (char *) "self",(char *) "pt",(char *) "flags", NULL
34370 };
34371
34372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34374 if (!SWIG_IsOK(res1)) {
34375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
34376 }
34377 arg1 = reinterpret_cast< wxWindow * >(argp1);
34378 {
34379 arg2 = &temp2;
34380 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34381 }
34382 if (obj2) {
34383 ecode3 = SWIG_AsVal_int(obj2, &val3);
34384 if (!SWIG_IsOK(ecode3)) {
34385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
34386 }
34387 arg3 = static_cast< int >(val3);
34388 }
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->Move((wxPoint const &)*arg2,arg3);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 int arg2 ;
34406 int arg3 ;
34407 int arg4 = (int) wxSIZE_USE_EXISTING ;
34408 void *argp1 = 0 ;
34409 int res1 = 0 ;
34410 int val2 ;
34411 int ecode2 = 0 ;
34412 int val3 ;
34413 int ecode3 = 0 ;
34414 int val4 ;
34415 int ecode4 = 0 ;
34416 PyObject * obj0 = 0 ;
34417 PyObject * obj1 = 0 ;
34418 PyObject * obj2 = 0 ;
34419 PyObject * obj3 = 0 ;
34420 char * kwnames[] = {
34421 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
34422 };
34423
34424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34426 if (!SWIG_IsOK(res1)) {
34427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
34428 }
34429 arg1 = reinterpret_cast< wxWindow * >(argp1);
34430 ecode2 = SWIG_AsVal_int(obj1, &val2);
34431 if (!SWIG_IsOK(ecode2)) {
34432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
34433 }
34434 arg2 = static_cast< int >(val2);
34435 ecode3 = SWIG_AsVal_int(obj2, &val3);
34436 if (!SWIG_IsOK(ecode3)) {
34437 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
34438 }
34439 arg3 = static_cast< int >(val3);
34440 if (obj3) {
34441 ecode4 = SWIG_AsVal_int(obj3, &val4);
34442 if (!SWIG_IsOK(ecode4)) {
34443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
34444 }
34445 arg4 = static_cast< int >(val4);
34446 }
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 (arg1)->Move(arg2,arg3,arg4);
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 resultobj = SWIG_Py_Void();
34454 return resultobj;
34455 fail:
34456 return NULL;
34457 }
34458
34459
34460 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34461 PyObject *resultobj = 0;
34462 wxWindow *arg1 = (wxWindow *) 0 ;
34463 wxSize const &arg2_defvalue = wxDefaultSize ;
34464 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34465 void *argp1 = 0 ;
34466 int res1 = 0 ;
34467 wxSize temp2 ;
34468 PyObject * obj0 = 0 ;
34469 PyObject * obj1 = 0 ;
34470 char * kwnames[] = {
34471 (char *) "self",(char *) "size", NULL
34472 };
34473
34474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34476 if (!SWIG_IsOK(res1)) {
34477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34478 }
34479 arg1 = reinterpret_cast< wxWindow * >(argp1);
34480 if (obj1) {
34481 {
34482 arg2 = &temp2;
34483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34484 }
34485 }
34486 {
34487 PyThreadState* __tstate = wxPyBeginAllowThreads();
34488 (arg1)->SetInitialSize((wxSize const &)*arg2);
34489 wxPyEndAllowThreads(__tstate);
34490 if (PyErr_Occurred()) SWIG_fail;
34491 }
34492 resultobj = SWIG_Py_Void();
34493 return resultobj;
34494 fail:
34495 return NULL;
34496 }
34497
34498
34499 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34500 PyObject *resultobj = 0;
34501 wxWindow *arg1 = (wxWindow *) 0 ;
34502 void *argp1 = 0 ;
34503 int res1 = 0 ;
34504 PyObject *swig_obj[1] ;
34505
34506 if (!args) SWIG_fail;
34507 swig_obj[0] = args;
34508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34509 if (!SWIG_IsOK(res1)) {
34510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34511 }
34512 arg1 = reinterpret_cast< wxWindow * >(argp1);
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 (arg1)->Raise();
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_Py_Void();
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 PyObject *resultobj = 0;
34528 wxWindow *arg1 = (wxWindow *) 0 ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 PyObject *swig_obj[1] ;
34532
34533 if (!args) SWIG_fail;
34534 swig_obj[0] = args;
34535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34536 if (!SWIG_IsOK(res1)) {
34537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34538 }
34539 arg1 = reinterpret_cast< wxWindow * >(argp1);
34540 {
34541 PyThreadState* __tstate = wxPyBeginAllowThreads();
34542 (arg1)->Lower();
34543 wxPyEndAllowThreads(__tstate);
34544 if (PyErr_Occurred()) SWIG_fail;
34545 }
34546 resultobj = SWIG_Py_Void();
34547 return resultobj;
34548 fail:
34549 return NULL;
34550 }
34551
34552
34553 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34554 PyObject *resultobj = 0;
34555 wxWindow *arg1 = (wxWindow *) 0 ;
34556 wxSize *arg2 = 0 ;
34557 void *argp1 = 0 ;
34558 int res1 = 0 ;
34559 wxSize temp2 ;
34560 PyObject * obj0 = 0 ;
34561 PyObject * obj1 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "size", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34570 }
34571 arg1 = reinterpret_cast< wxWindow * >(argp1);
34572 {
34573 arg2 = &temp2;
34574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34575 }
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 (arg1)->SetClientSize((wxSize const &)*arg2);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_Py_Void();
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 int arg2 ;
34593 int arg3 ;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 int val2 ;
34597 int ecode2 = 0 ;
34598 int val3 ;
34599 int ecode3 = 0 ;
34600 PyObject * obj0 = 0 ;
34601 PyObject * obj1 = 0 ;
34602 PyObject * obj2 = 0 ;
34603 char * kwnames[] = {
34604 (char *) "self",(char *) "width",(char *) "height", NULL
34605 };
34606
34607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34611 }
34612 arg1 = reinterpret_cast< wxWindow * >(argp1);
34613 ecode2 = SWIG_AsVal_int(obj1, &val2);
34614 if (!SWIG_IsOK(ecode2)) {
34615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34616 }
34617 arg2 = static_cast< int >(val2);
34618 ecode3 = SWIG_AsVal_int(obj2, &val3);
34619 if (!SWIG_IsOK(ecode3)) {
34620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34621 }
34622 arg3 = static_cast< int >(val3);
34623 {
34624 PyThreadState* __tstate = wxPyBeginAllowThreads();
34625 (arg1)->SetClientSize(arg2,arg3);
34626 wxPyEndAllowThreads(__tstate);
34627 if (PyErr_Occurred()) SWIG_fail;
34628 }
34629 resultobj = SWIG_Py_Void();
34630 return resultobj;
34631 fail:
34632 return NULL;
34633 }
34634
34635
34636 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34637 PyObject *resultobj = 0;
34638 wxWindow *arg1 = (wxWindow *) 0 ;
34639 wxRect *arg2 = 0 ;
34640 void *argp1 = 0 ;
34641 int res1 = 0 ;
34642 wxRect temp2 ;
34643 PyObject * obj0 = 0 ;
34644 PyObject * obj1 = 0 ;
34645 char * kwnames[] = {
34646 (char *) "self",(char *) "rect", NULL
34647 };
34648
34649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34651 if (!SWIG_IsOK(res1)) {
34652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34653 }
34654 arg1 = reinterpret_cast< wxWindow * >(argp1);
34655 {
34656 arg2 = &temp2;
34657 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34658 }
34659 {
34660 PyThreadState* __tstate = wxPyBeginAllowThreads();
34661 (arg1)->SetClientSize((wxRect const &)*arg2);
34662 wxPyEndAllowThreads(__tstate);
34663 if (PyErr_Occurred()) SWIG_fail;
34664 }
34665 resultobj = SWIG_Py_Void();
34666 return resultobj;
34667 fail:
34668 return NULL;
34669 }
34670
34671
34672 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34673 PyObject *resultobj = 0;
34674 wxWindow *arg1 = (wxWindow *) 0 ;
34675 wxPoint result;
34676 void *argp1 = 0 ;
34677 int res1 = 0 ;
34678 PyObject *swig_obj[1] ;
34679
34680 if (!args) SWIG_fail;
34681 swig_obj[0] = args;
34682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34685 }
34686 arg1 = reinterpret_cast< wxWindow * >(argp1);
34687 {
34688 PyThreadState* __tstate = wxPyBeginAllowThreads();
34689 result = ((wxWindow const *)arg1)->GetPosition();
34690 wxPyEndAllowThreads(__tstate);
34691 if (PyErr_Occurred()) SWIG_fail;
34692 }
34693 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34694 return resultobj;
34695 fail:
34696 return NULL;
34697 }
34698
34699
34700 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34701 PyObject *resultobj = 0;
34702 wxWindow *arg1 = (wxWindow *) 0 ;
34703 int *arg2 = (int *) 0 ;
34704 int *arg3 = (int *) 0 ;
34705 void *argp1 = 0 ;
34706 int res1 = 0 ;
34707 int temp2 ;
34708 int res2 = SWIG_TMPOBJ ;
34709 int temp3 ;
34710 int res3 = SWIG_TMPOBJ ;
34711 PyObject *swig_obj[1] ;
34712
34713 arg2 = &temp2;
34714 arg3 = &temp3;
34715 if (!args) SWIG_fail;
34716 swig_obj[0] = args;
34717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34720 }
34721 arg1 = reinterpret_cast< wxWindow * >(argp1);
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34725 wxPyEndAllowThreads(__tstate);
34726 if (PyErr_Occurred()) SWIG_fail;
34727 }
34728 resultobj = SWIG_Py_Void();
34729 if (SWIG_IsTmpObj(res2)) {
34730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34731 } else {
34732 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34734 }
34735 if (SWIG_IsTmpObj(res3)) {
34736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34737 } else {
34738 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34740 }
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34748 PyObject *resultobj = 0;
34749 wxWindow *arg1 = (wxWindow *) 0 ;
34750 wxPoint result;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 PyObject *swig_obj[1] ;
34754
34755 if (!args) SWIG_fail;
34756 swig_obj[0] = args;
34757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34758 if (!SWIG_IsOK(res1)) {
34759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34760 }
34761 arg1 = reinterpret_cast< wxWindow * >(argp1);
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 result = ((wxWindow const *)arg1)->GetScreenPosition();
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxWindow *arg1 = (wxWindow *) 0 ;
34778 int *arg2 = (int *) 0 ;
34779 int *arg3 = (int *) 0 ;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 int temp2 ;
34783 int res2 = SWIG_TMPOBJ ;
34784 int temp3 ;
34785 int res3 = SWIG_TMPOBJ ;
34786 PyObject *swig_obj[1] ;
34787
34788 arg2 = &temp2;
34789 arg3 = &temp3;
34790 if (!args) SWIG_fail;
34791 swig_obj[0] = args;
34792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 {
34798 PyThreadState* __tstate = wxPyBeginAllowThreads();
34799 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 resultobj = SWIG_Py_Void();
34804 if (SWIG_IsTmpObj(res2)) {
34805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34806 } else {
34807 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34809 }
34810 if (SWIG_IsTmpObj(res3)) {
34811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34812 } else {
34813 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34815 }
34816 return resultobj;
34817 fail:
34818 return NULL;
34819 }
34820
34821
34822 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34823 PyObject *resultobj = 0;
34824 wxWindow *arg1 = (wxWindow *) 0 ;
34825 wxRect result;
34826 void *argp1 = 0 ;
34827 int res1 = 0 ;
34828 PyObject *swig_obj[1] ;
34829
34830 if (!args) SWIG_fail;
34831 swig_obj[0] = args;
34832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34833 if (!SWIG_IsOK(res1)) {
34834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34835 }
34836 arg1 = reinterpret_cast< wxWindow * >(argp1);
34837 {
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = ((wxWindow const *)arg1)->GetScreenRect();
34840 wxPyEndAllowThreads(__tstate);
34841 if (PyErr_Occurred()) SWIG_fail;
34842 }
34843 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 wxSize result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 PyObject *swig_obj[1] ;
34857
34858 if (!args) SWIG_fail;
34859 swig_obj[0] = args;
34860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = ((wxWindow const *)arg1)->GetSize();
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34872 return resultobj;
34873 fail:
34874 return NULL;
34875 }
34876
34877
34878 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34879 PyObject *resultobj = 0;
34880 wxWindow *arg1 = (wxWindow *) 0 ;
34881 int *arg2 = (int *) 0 ;
34882 int *arg3 = (int *) 0 ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 int temp2 ;
34886 int res2 = SWIG_TMPOBJ ;
34887 int temp3 ;
34888 int res3 = SWIG_TMPOBJ ;
34889 PyObject *swig_obj[1] ;
34890
34891 arg2 = &temp2;
34892 arg3 = &temp3;
34893 if (!args) SWIG_fail;
34894 swig_obj[0] = args;
34895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34898 }
34899 arg1 = reinterpret_cast< wxWindow * >(argp1);
34900 {
34901 PyThreadState* __tstate = wxPyBeginAllowThreads();
34902 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34903 wxPyEndAllowThreads(__tstate);
34904 if (PyErr_Occurred()) SWIG_fail;
34905 }
34906 resultobj = SWIG_Py_Void();
34907 if (SWIG_IsTmpObj(res2)) {
34908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34909 } else {
34910 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34912 }
34913 if (SWIG_IsTmpObj(res3)) {
34914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34915 } else {
34916 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34918 }
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34926 PyObject *resultobj = 0;
34927 wxWindow *arg1 = (wxWindow *) 0 ;
34928 wxRect result;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 PyObject *swig_obj[1] ;
34932
34933 if (!args) SWIG_fail;
34934 swig_obj[0] = args;
34935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34936 if (!SWIG_IsOK(res1)) {
34937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34938 }
34939 arg1 = reinterpret_cast< wxWindow * >(argp1);
34940 {
34941 PyThreadState* __tstate = wxPyBeginAllowThreads();
34942 result = ((wxWindow const *)arg1)->GetRect();
34943 wxPyEndAllowThreads(__tstate);
34944 if (PyErr_Occurred()) SWIG_fail;
34945 }
34946 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34947 return resultobj;
34948 fail:
34949 return NULL;
34950 }
34951
34952
34953 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34954 PyObject *resultobj = 0;
34955 wxWindow *arg1 = (wxWindow *) 0 ;
34956 wxSize result;
34957 void *argp1 = 0 ;
34958 int res1 = 0 ;
34959 PyObject *swig_obj[1] ;
34960
34961 if (!args) SWIG_fail;
34962 swig_obj[0] = args;
34963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34964 if (!SWIG_IsOK(res1)) {
34965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34966 }
34967 arg1 = reinterpret_cast< wxWindow * >(argp1);
34968 {
34969 PyThreadState* __tstate = wxPyBeginAllowThreads();
34970 result = ((wxWindow const *)arg1)->GetClientSize();
34971 wxPyEndAllowThreads(__tstate);
34972 if (PyErr_Occurred()) SWIG_fail;
34973 }
34974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34975 return resultobj;
34976 fail:
34977 return NULL;
34978 }
34979
34980
34981 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34982 PyObject *resultobj = 0;
34983 wxWindow *arg1 = (wxWindow *) 0 ;
34984 int *arg2 = (int *) 0 ;
34985 int *arg3 = (int *) 0 ;
34986 void *argp1 = 0 ;
34987 int res1 = 0 ;
34988 int temp2 ;
34989 int res2 = SWIG_TMPOBJ ;
34990 int temp3 ;
34991 int res3 = SWIG_TMPOBJ ;
34992 PyObject *swig_obj[1] ;
34993
34994 arg2 = &temp2;
34995 arg3 = &temp3;
34996 if (!args) SWIG_fail;
34997 swig_obj[0] = args;
34998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34999 if (!SWIG_IsOK(res1)) {
35000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35001 }
35002 arg1 = reinterpret_cast< wxWindow * >(argp1);
35003 {
35004 PyThreadState* __tstate = wxPyBeginAllowThreads();
35005 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
35006 wxPyEndAllowThreads(__tstate);
35007 if (PyErr_Occurred()) SWIG_fail;
35008 }
35009 resultobj = SWIG_Py_Void();
35010 if (SWIG_IsTmpObj(res2)) {
35011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35012 } else {
35013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35015 }
35016 if (SWIG_IsTmpObj(res3)) {
35017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35018 } else {
35019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35021 }
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxPoint result;
35032 void *argp1 = 0 ;
35033 int res1 = 0 ;
35034 PyObject *swig_obj[1] ;
35035
35036 if (!args) SWIG_fail;
35037 swig_obj[0] = args;
35038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35039 if (!SWIG_IsOK(res1)) {
35040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
35041 }
35042 arg1 = reinterpret_cast< wxWindow * >(argp1);
35043 {
35044 PyThreadState* __tstate = wxPyBeginAllowThreads();
35045 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
35046 wxPyEndAllowThreads(__tstate);
35047 if (PyErr_Occurred()) SWIG_fail;
35048 }
35049 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35057 PyObject *resultobj = 0;
35058 wxWindow *arg1 = (wxWindow *) 0 ;
35059 wxRect result;
35060 void *argp1 = 0 ;
35061 int res1 = 0 ;
35062 PyObject *swig_obj[1] ;
35063
35064 if (!args) SWIG_fail;
35065 swig_obj[0] = args;
35066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35067 if (!SWIG_IsOK(res1)) {
35068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35069 }
35070 arg1 = reinterpret_cast< wxWindow * >(argp1);
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 result = ((wxWindow const *)arg1)->GetClientRect();
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35085 PyObject *resultobj = 0;
35086 wxWindow *arg1 = (wxWindow *) 0 ;
35087 wxSize result;
35088 void *argp1 = 0 ;
35089 int res1 = 0 ;
35090 PyObject *swig_obj[1] ;
35091
35092 if (!args) SWIG_fail;
35093 swig_obj[0] = args;
35094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35095 if (!SWIG_IsOK(res1)) {
35096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35097 }
35098 arg1 = reinterpret_cast< wxWindow * >(argp1);
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = ((wxWindow const *)arg1)->GetBestSize();
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35113 PyObject *resultobj = 0;
35114 wxWindow *arg1 = (wxWindow *) 0 ;
35115 int *arg2 = (int *) 0 ;
35116 int *arg3 = (int *) 0 ;
35117 void *argp1 = 0 ;
35118 int res1 = 0 ;
35119 int temp2 ;
35120 int res2 = SWIG_TMPOBJ ;
35121 int temp3 ;
35122 int res3 = SWIG_TMPOBJ ;
35123 PyObject *swig_obj[1] ;
35124
35125 arg2 = &temp2;
35126 arg3 = &temp3;
35127 if (!args) SWIG_fail;
35128 swig_obj[0] = args;
35129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_Py_Void();
35141 if (SWIG_IsTmpObj(res2)) {
35142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35143 } else {
35144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35146 }
35147 if (SWIG_IsTmpObj(res3)) {
35148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35149 } else {
35150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35152 }
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 void *argp1 = 0 ;
35163 int res1 = 0 ;
35164 PyObject *swig_obj[1] ;
35165
35166 if (!args) SWIG_fail;
35167 swig_obj[0] = args;
35168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35169 if (!SWIG_IsOK(res1)) {
35170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35171 }
35172 arg1 = reinterpret_cast< wxWindow * >(argp1);
35173 {
35174 PyThreadState* __tstate = wxPyBeginAllowThreads();
35175 (arg1)->InvalidateBestSize();
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_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35187 PyObject *resultobj = 0;
35188 wxWindow *arg1 = (wxWindow *) 0 ;
35189 wxSize *arg2 = 0 ;
35190 void *argp1 = 0 ;
35191 int res1 = 0 ;
35192 wxSize temp2 ;
35193 PyObject * obj0 = 0 ;
35194 PyObject * obj1 = 0 ;
35195 char * kwnames[] = {
35196 (char *) "self",(char *) "size", NULL
35197 };
35198
35199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
35200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35201 if (!SWIG_IsOK(res1)) {
35202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35203 }
35204 arg1 = reinterpret_cast< wxWindow * >(argp1);
35205 {
35206 arg2 = &temp2;
35207 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35208 }
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
35212 wxPyEndAllowThreads(__tstate);
35213 if (PyErr_Occurred()) SWIG_fail;
35214 }
35215 resultobj = SWIG_Py_Void();
35216 return resultobj;
35217 fail:
35218 return NULL;
35219 }
35220
35221
35222 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35223 PyObject *resultobj = 0;
35224 wxWindow *arg1 = (wxWindow *) 0 ;
35225 wxSize result;
35226 void *argp1 = 0 ;
35227 int res1 = 0 ;
35228 PyObject *swig_obj[1] ;
35229
35230 if (!args) SWIG_fail;
35231 swig_obj[0] = args;
35232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35233 if (!SWIG_IsOK(res1)) {
35234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35235 }
35236 arg1 = reinterpret_cast< wxWindow * >(argp1);
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35251 PyObject *resultobj = 0;
35252 wxWindow *arg1 = (wxWindow *) 0 ;
35253 int arg2 = (int) wxBOTH ;
35254 void *argp1 = 0 ;
35255 int res1 = 0 ;
35256 int val2 ;
35257 int ecode2 = 0 ;
35258 PyObject * obj0 = 0 ;
35259 PyObject * obj1 = 0 ;
35260 char * kwnames[] = {
35261 (char *) "self",(char *) "direction", NULL
35262 };
35263
35264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
35265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35266 if (!SWIG_IsOK(res1)) {
35267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
35268 }
35269 arg1 = reinterpret_cast< wxWindow * >(argp1);
35270 if (obj1) {
35271 ecode2 = SWIG_AsVal_int(obj1, &val2);
35272 if (!SWIG_IsOK(ecode2)) {
35273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
35274 }
35275 arg2 = static_cast< int >(val2);
35276 }
35277 {
35278 PyThreadState* __tstate = wxPyBeginAllowThreads();
35279 (arg1)->Center(arg2);
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 resultobj = SWIG_Py_Void();
35284 return resultobj;
35285 fail:
35286 return NULL;
35287 }
35288
35289
35290 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35291 PyObject *resultobj = 0;
35292 wxWindow *arg1 = (wxWindow *) 0 ;
35293 int arg2 = (int) wxBOTH ;
35294 void *argp1 = 0 ;
35295 int res1 = 0 ;
35296 int val2 ;
35297 int ecode2 = 0 ;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char * kwnames[] = {
35301 (char *) "self",(char *) "dir", NULL
35302 };
35303
35304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
35305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
35308 }
35309 arg1 = reinterpret_cast< wxWindow * >(argp1);
35310 if (obj1) {
35311 ecode2 = SWIG_AsVal_int(obj1, &val2);
35312 if (!SWIG_IsOK(ecode2)) {
35313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
35314 }
35315 arg2 = static_cast< int >(val2);
35316 }
35317 {
35318 PyThreadState* __tstate = wxPyBeginAllowThreads();
35319 (arg1)->CenterOnParent(arg2);
35320 wxPyEndAllowThreads(__tstate);
35321 if (PyErr_Occurred()) SWIG_fail;
35322 }
35323 resultobj = SWIG_Py_Void();
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35331 PyObject *resultobj = 0;
35332 wxWindow *arg1 = (wxWindow *) 0 ;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 PyObject *swig_obj[1] ;
35336
35337 if (!args) SWIG_fail;
35338 swig_obj[0] = args;
35339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35340 if (!SWIG_IsOK(res1)) {
35341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
35342 }
35343 arg1 = reinterpret_cast< wxWindow * >(argp1);
35344 {
35345 PyThreadState* __tstate = wxPyBeginAllowThreads();
35346 (arg1)->Fit();
35347 wxPyEndAllowThreads(__tstate);
35348 if (PyErr_Occurred()) SWIG_fail;
35349 }
35350 resultobj = SWIG_Py_Void();
35351 return resultobj;
35352 fail:
35353 return NULL;
35354 }
35355
35356
35357 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35358 PyObject *resultobj = 0;
35359 wxWindow *arg1 = (wxWindow *) 0 ;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 (arg1)->FitInside();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_Py_Void();
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 int arg2 ;
35388 int arg3 ;
35389 int arg4 = (int) -1 ;
35390 int arg5 = (int) -1 ;
35391 int arg6 = (int) -1 ;
35392 int arg7 = (int) -1 ;
35393 void *argp1 = 0 ;
35394 int res1 = 0 ;
35395 int val2 ;
35396 int ecode2 = 0 ;
35397 int val3 ;
35398 int ecode3 = 0 ;
35399 int val4 ;
35400 int ecode4 = 0 ;
35401 int val5 ;
35402 int ecode5 = 0 ;
35403 int val6 ;
35404 int ecode6 = 0 ;
35405 int val7 ;
35406 int ecode7 = 0 ;
35407 PyObject * obj0 = 0 ;
35408 PyObject * obj1 = 0 ;
35409 PyObject * obj2 = 0 ;
35410 PyObject * obj3 = 0 ;
35411 PyObject * obj4 = 0 ;
35412 PyObject * obj5 = 0 ;
35413 PyObject * obj6 = 0 ;
35414 char * kwnames[] = {
35415 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
35416 };
35417
35418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
35419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35420 if (!SWIG_IsOK(res1)) {
35421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35422 }
35423 arg1 = reinterpret_cast< wxWindow * >(argp1);
35424 ecode2 = SWIG_AsVal_int(obj1, &val2);
35425 if (!SWIG_IsOK(ecode2)) {
35426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
35427 }
35428 arg2 = static_cast< int >(val2);
35429 ecode3 = SWIG_AsVal_int(obj2, &val3);
35430 if (!SWIG_IsOK(ecode3)) {
35431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
35432 }
35433 arg3 = static_cast< int >(val3);
35434 if (obj3) {
35435 ecode4 = SWIG_AsVal_int(obj3, &val4);
35436 if (!SWIG_IsOK(ecode4)) {
35437 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
35438 }
35439 arg4 = static_cast< int >(val4);
35440 }
35441 if (obj4) {
35442 ecode5 = SWIG_AsVal_int(obj4, &val5);
35443 if (!SWIG_IsOK(ecode5)) {
35444 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
35445 }
35446 arg5 = static_cast< int >(val5);
35447 }
35448 if (obj5) {
35449 ecode6 = SWIG_AsVal_int(obj5, &val6);
35450 if (!SWIG_IsOK(ecode6)) {
35451 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35452 }
35453 arg6 = static_cast< int >(val6);
35454 }
35455 if (obj6) {
35456 ecode7 = SWIG_AsVal_int(obj6, &val7);
35457 if (!SWIG_IsOK(ecode7)) {
35458 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35459 }
35460 arg7 = static_cast< int >(val7);
35461 }
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 resultobj = SWIG_Py_Void();
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj = 0;
35477 wxWindow *arg1 = (wxWindow *) 0 ;
35478 wxSize *arg2 = 0 ;
35479 wxSize const &arg3_defvalue = wxDefaultSize ;
35480 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35481 wxSize const &arg4_defvalue = wxDefaultSize ;
35482 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35483 void *argp1 = 0 ;
35484 int res1 = 0 ;
35485 wxSize temp2 ;
35486 wxSize temp3 ;
35487 wxSize temp4 ;
35488 PyObject * obj0 = 0 ;
35489 PyObject * obj1 = 0 ;
35490 PyObject * obj2 = 0 ;
35491 PyObject * obj3 = 0 ;
35492 char * kwnames[] = {
35493 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35494 };
35495
35496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35498 if (!SWIG_IsOK(res1)) {
35499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35500 }
35501 arg1 = reinterpret_cast< wxWindow * >(argp1);
35502 {
35503 arg2 = &temp2;
35504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35505 }
35506 if (obj2) {
35507 {
35508 arg3 = &temp3;
35509 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35510 }
35511 }
35512 if (obj3) {
35513 {
35514 arg4 = &temp4;
35515 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35516 }
35517 }
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 resultobj = SWIG_Py_Void();
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj = 0;
35533 wxWindow *arg1 = (wxWindow *) 0 ;
35534 int arg2 ;
35535 int arg3 ;
35536 int arg4 = (int) -1 ;
35537 int arg5 = (int) -1 ;
35538 void *argp1 = 0 ;
35539 int res1 = 0 ;
35540 int val2 ;
35541 int ecode2 = 0 ;
35542 int val3 ;
35543 int ecode3 = 0 ;
35544 int val4 ;
35545 int ecode4 = 0 ;
35546 int val5 ;
35547 int ecode5 = 0 ;
35548 PyObject * obj0 = 0 ;
35549 PyObject * obj1 = 0 ;
35550 PyObject * obj2 = 0 ;
35551 PyObject * obj3 = 0 ;
35552 PyObject * obj4 = 0 ;
35553 char * kwnames[] = {
35554 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35555 };
35556
35557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35559 if (!SWIG_IsOK(res1)) {
35560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35561 }
35562 arg1 = reinterpret_cast< wxWindow * >(argp1);
35563 ecode2 = SWIG_AsVal_int(obj1, &val2);
35564 if (!SWIG_IsOK(ecode2)) {
35565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35566 }
35567 arg2 = static_cast< int >(val2);
35568 ecode3 = SWIG_AsVal_int(obj2, &val3);
35569 if (!SWIG_IsOK(ecode3)) {
35570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35571 }
35572 arg3 = static_cast< int >(val3);
35573 if (obj3) {
35574 ecode4 = SWIG_AsVal_int(obj3, &val4);
35575 if (!SWIG_IsOK(ecode4)) {
35576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35577 }
35578 arg4 = static_cast< int >(val4);
35579 }
35580 if (obj4) {
35581 ecode5 = SWIG_AsVal_int(obj4, &val5);
35582 if (!SWIG_IsOK(ecode5)) {
35583 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35584 }
35585 arg5 = static_cast< int >(val5);
35586 }
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35590 wxPyEndAllowThreads(__tstate);
35591 if (PyErr_Occurred()) SWIG_fail;
35592 }
35593 resultobj = SWIG_Py_Void();
35594 return resultobj;
35595 fail:
35596 return NULL;
35597 }
35598
35599
35600 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35601 PyObject *resultobj = 0;
35602 wxWindow *arg1 = (wxWindow *) 0 ;
35603 wxSize *arg2 = 0 ;
35604 wxSize const &arg3_defvalue = wxDefaultSize ;
35605 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35606 void *argp1 = 0 ;
35607 int res1 = 0 ;
35608 wxSize temp2 ;
35609 wxSize temp3 ;
35610 PyObject * obj0 = 0 ;
35611 PyObject * obj1 = 0 ;
35612 PyObject * obj2 = 0 ;
35613 char * kwnames[] = {
35614 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35615 };
35616
35617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35621 }
35622 arg1 = reinterpret_cast< wxWindow * >(argp1);
35623 {
35624 arg2 = &temp2;
35625 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35626 }
35627 if (obj2) {
35628 {
35629 arg3 = &temp3;
35630 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35631 }
35632 }
35633 {
35634 PyThreadState* __tstate = wxPyBeginAllowThreads();
35635 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35636 wxPyEndAllowThreads(__tstate);
35637 if (PyErr_Occurred()) SWIG_fail;
35638 }
35639 resultobj = SWIG_Py_Void();
35640 return resultobj;
35641 fail:
35642 return NULL;
35643 }
35644
35645
35646 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35647 PyObject *resultobj = 0;
35648 wxWindow *arg1 = (wxWindow *) 0 ;
35649 wxSize result;
35650 void *argp1 = 0 ;
35651 int res1 = 0 ;
35652 PyObject *swig_obj[1] ;
35653
35654 if (!args) SWIG_fail;
35655 swig_obj[0] = args;
35656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 {
35662 PyThreadState* __tstate = wxPyBeginAllowThreads();
35663 result = ((wxWindow const *)arg1)->GetMaxSize();
35664 wxPyEndAllowThreads(__tstate);
35665 if (PyErr_Occurred()) SWIG_fail;
35666 }
35667 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35668 return resultobj;
35669 fail:
35670 return NULL;
35671 }
35672
35673
35674 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35675 PyObject *resultobj = 0;
35676 wxWindow *arg1 = (wxWindow *) 0 ;
35677 wxSize result;
35678 void *argp1 = 0 ;
35679 int res1 = 0 ;
35680 PyObject *swig_obj[1] ;
35681
35682 if (!args) SWIG_fail;
35683 swig_obj[0] = args;
35684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 result = ((wxWindow const *)arg1)->GetMinSize();
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35696 return resultobj;
35697 fail:
35698 return NULL;
35699 }
35700
35701
35702 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35703 PyObject *resultobj = 0;
35704 wxWindow *arg1 = (wxWindow *) 0 ;
35705 wxSize *arg2 = 0 ;
35706 void *argp1 = 0 ;
35707 int res1 = 0 ;
35708 wxSize temp2 ;
35709 PyObject * obj0 = 0 ;
35710 PyObject * obj1 = 0 ;
35711 char * kwnames[] = {
35712 (char *) "self",(char *) "minSize", NULL
35713 };
35714
35715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35717 if (!SWIG_IsOK(res1)) {
35718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35719 }
35720 arg1 = reinterpret_cast< wxWindow * >(argp1);
35721 {
35722 arg2 = &temp2;
35723 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35724 }
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 (arg1)->SetMinSize((wxSize const &)*arg2);
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 resultobj = SWIG_Py_Void();
35732 return resultobj;
35733 fail:
35734 return NULL;
35735 }
35736
35737
35738 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35739 PyObject *resultobj = 0;
35740 wxWindow *arg1 = (wxWindow *) 0 ;
35741 wxSize *arg2 = 0 ;
35742 void *argp1 = 0 ;
35743 int res1 = 0 ;
35744 wxSize temp2 ;
35745 PyObject * obj0 = 0 ;
35746 PyObject * obj1 = 0 ;
35747 char * kwnames[] = {
35748 (char *) "self",(char *) "maxSize", NULL
35749 };
35750
35751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35755 }
35756 arg1 = reinterpret_cast< wxWindow * >(argp1);
35757 {
35758 arg2 = &temp2;
35759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35760 }
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 (arg1)->SetMaxSize((wxSize const &)*arg2);
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 resultobj = SWIG_Py_Void();
35768 return resultobj;
35769 fail:
35770 return NULL;
35771 }
35772
35773
35774 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35775 PyObject *resultobj = 0;
35776 wxWindow *arg1 = (wxWindow *) 0 ;
35777 int result;
35778 void *argp1 = 0 ;
35779 int res1 = 0 ;
35780 PyObject *swig_obj[1] ;
35781
35782 if (!args) SWIG_fail;
35783 swig_obj[0] = args;
35784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35787 }
35788 arg1 = reinterpret_cast< wxWindow * >(argp1);
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35792 wxPyEndAllowThreads(__tstate);
35793 if (PyErr_Occurred()) SWIG_fail;
35794 }
35795 resultobj = SWIG_From_int(static_cast< int >(result));
35796 return resultobj;
35797 fail:
35798 return NULL;
35799 }
35800
35801
35802 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35803 PyObject *resultobj = 0;
35804 wxWindow *arg1 = (wxWindow *) 0 ;
35805 int result;
35806 void *argp1 = 0 ;
35807 int res1 = 0 ;
35808 PyObject *swig_obj[1] ;
35809
35810 if (!args) SWIG_fail;
35811 swig_obj[0] = args;
35812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35813 if (!SWIG_IsOK(res1)) {
35814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35815 }
35816 arg1 = reinterpret_cast< wxWindow * >(argp1);
35817 {
35818 PyThreadState* __tstate = wxPyBeginAllowThreads();
35819 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35820 wxPyEndAllowThreads(__tstate);
35821 if (PyErr_Occurred()) SWIG_fail;
35822 }
35823 resultobj = SWIG_From_int(static_cast< int >(result));
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 PyObject *resultobj = 0;
35832 wxWindow *arg1 = (wxWindow *) 0 ;
35833 int result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 PyObject *swig_obj[1] ;
35837
35838 if (!args) SWIG_fail;
35839 swig_obj[0] = args;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 resultobj = SWIG_From_int(static_cast< int >(result));
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35859 PyObject *resultobj = 0;
35860 wxWindow *arg1 = (wxWindow *) 0 ;
35861 int result;
35862 void *argp1 = 0 ;
35863 int res1 = 0 ;
35864 PyObject *swig_obj[1] ;
35865
35866 if (!args) SWIG_fail;
35867 swig_obj[0] = args;
35868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35869 if (!SWIG_IsOK(res1)) {
35870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35871 }
35872 arg1 = reinterpret_cast< wxWindow * >(argp1);
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 resultobj = SWIG_From_int(static_cast< int >(result));
35880 return resultobj;
35881 fail:
35882 return NULL;
35883 }
35884
35885
35886 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35887 PyObject *resultobj = 0;
35888 wxWindow *arg1 = (wxWindow *) 0 ;
35889 wxSize *arg2 = 0 ;
35890 void *argp1 = 0 ;
35891 int res1 = 0 ;
35892 wxSize temp2 ;
35893 PyObject * obj0 = 0 ;
35894 PyObject * obj1 = 0 ;
35895 char * kwnames[] = {
35896 (char *) "self",(char *) "size", NULL
35897 };
35898
35899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35901 if (!SWIG_IsOK(res1)) {
35902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35903 }
35904 arg1 = reinterpret_cast< wxWindow * >(argp1);
35905 {
35906 arg2 = &temp2;
35907 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35908 }
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35912 wxPyEndAllowThreads(__tstate);
35913 if (PyErr_Occurred()) SWIG_fail;
35914 }
35915 resultobj = SWIG_Py_Void();
35916 return resultobj;
35917 fail:
35918 return NULL;
35919 }
35920
35921
35922 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35923 PyObject *resultobj = 0;
35924 wxWindow *arg1 = (wxWindow *) 0 ;
35925 int arg2 ;
35926 int arg3 ;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 int val2 ;
35930 int ecode2 = 0 ;
35931 int val3 ;
35932 int ecode3 = 0 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 PyObject * obj2 = 0 ;
35936 char * kwnames[] = {
35937 (char *) "self",(char *) "w",(char *) "h", NULL
35938 };
35939
35940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35942 if (!SWIG_IsOK(res1)) {
35943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35944 }
35945 arg1 = reinterpret_cast< wxWindow * >(argp1);
35946 ecode2 = SWIG_AsVal_int(obj1, &val2);
35947 if (!SWIG_IsOK(ecode2)) {
35948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35949 }
35950 arg2 = static_cast< int >(val2);
35951 ecode3 = SWIG_AsVal_int(obj2, &val3);
35952 if (!SWIG_IsOK(ecode3)) {
35953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35954 }
35955 arg3 = static_cast< int >(val3);
35956 {
35957 PyThreadState* __tstate = wxPyBeginAllowThreads();
35958 (arg1)->SetVirtualSize(arg2,arg3);
35959 wxPyEndAllowThreads(__tstate);
35960 if (PyErr_Occurred()) SWIG_fail;
35961 }
35962 resultobj = SWIG_Py_Void();
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35970 PyObject *resultobj = 0;
35971 wxWindow *arg1 = (wxWindow *) 0 ;
35972 wxSize result;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975 PyObject *swig_obj[1] ;
35976
35977 if (!args) SWIG_fail;
35978 swig_obj[0] = args;
35979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35980 if (!SWIG_IsOK(res1)) {
35981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35982 }
35983 arg1 = reinterpret_cast< wxWindow * >(argp1);
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 result = ((wxWindow const *)arg1)->GetVirtualSize();
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35998 PyObject *resultobj = 0;
35999 wxWindow *arg1 = (wxWindow *) 0 ;
36000 int *arg2 = (int *) 0 ;
36001 int *arg3 = (int *) 0 ;
36002 void *argp1 = 0 ;
36003 int res1 = 0 ;
36004 int temp2 ;
36005 int res2 = SWIG_TMPOBJ ;
36006 int temp3 ;
36007 int res3 = SWIG_TMPOBJ ;
36008 PyObject *swig_obj[1] ;
36009
36010 arg2 = &temp2;
36011 arg3 = &temp3;
36012 if (!args) SWIG_fail;
36013 swig_obj[0] = args;
36014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36015 if (!SWIG_IsOK(res1)) {
36016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
36017 }
36018 arg1 = reinterpret_cast< wxWindow * >(argp1);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 resultobj = SWIG_Py_Void();
36026 if (SWIG_IsTmpObj(res2)) {
36027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36028 } else {
36029 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36031 }
36032 if (SWIG_IsTmpObj(res3)) {
36033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36034 } else {
36035 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36037 }
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36045 PyObject *resultobj = 0;
36046 wxWindow *arg1 = (wxWindow *) 0 ;
36047 wxSize result;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 PyObject *swig_obj[1] ;
36051
36052 if (!args) SWIG_fail;
36053 swig_obj[0] = args;
36054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36055 if (!SWIG_IsOK(res1)) {
36056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36057 }
36058 arg1 = reinterpret_cast< wxWindow * >(argp1);
36059 {
36060 PyThreadState* __tstate = wxPyBeginAllowThreads();
36061 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
36062 wxPyEndAllowThreads(__tstate);
36063 if (PyErr_Occurred()) SWIG_fail;
36064 }
36065 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36066 return resultobj;
36067 fail:
36068 return NULL;
36069 }
36070
36071
36072 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36073 PyObject *resultobj = 0;
36074 wxWindow *arg1 = (wxWindow *) 0 ;
36075 wxSize result;
36076 void *argp1 = 0 ;
36077 int res1 = 0 ;
36078 PyObject *swig_obj[1] ;
36079
36080 if (!args) SWIG_fail;
36081 swig_obj[0] = args;
36082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36083 if (!SWIG_IsOK(res1)) {
36084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36085 }
36086 arg1 = reinterpret_cast< wxWindow * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36101 PyObject *resultobj = 0;
36102 wxWindow *arg1 = (wxWindow *) 0 ;
36103 bool arg2 = (bool) true ;
36104 bool result;
36105 void *argp1 = 0 ;
36106 int res1 = 0 ;
36107 bool val2 ;
36108 int ecode2 = 0 ;
36109 PyObject * obj0 = 0 ;
36110 PyObject * obj1 = 0 ;
36111 char * kwnames[] = {
36112 (char *) "self",(char *) "show", NULL
36113 };
36114
36115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
36116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36117 if (!SWIG_IsOK(res1)) {
36118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
36119 }
36120 arg1 = reinterpret_cast< wxWindow * >(argp1);
36121 if (obj1) {
36122 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36123 if (!SWIG_IsOK(ecode2)) {
36124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
36125 }
36126 arg2 = static_cast< bool >(val2);
36127 }
36128 {
36129 PyThreadState* __tstate = wxPyBeginAllowThreads();
36130 result = (bool)(arg1)->Show(arg2);
36131 wxPyEndAllowThreads(__tstate);
36132 if (PyErr_Occurred()) SWIG_fail;
36133 }
36134 {
36135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36136 }
36137 return resultobj;
36138 fail:
36139 return NULL;
36140 }
36141
36142
36143 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36144 PyObject *resultobj = 0;
36145 wxWindow *arg1 = (wxWindow *) 0 ;
36146 bool result;
36147 void *argp1 = 0 ;
36148 int res1 = 0 ;
36149 PyObject *swig_obj[1] ;
36150
36151 if (!args) SWIG_fail;
36152 swig_obj[0] = args;
36153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36154 if (!SWIG_IsOK(res1)) {
36155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
36156 }
36157 arg1 = reinterpret_cast< wxWindow * >(argp1);
36158 {
36159 PyThreadState* __tstate = wxPyBeginAllowThreads();
36160 result = (bool)(arg1)->Hide();
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 {
36165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36166 }
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj = 0;
36175 wxWindow *arg1 = (wxWindow *) 0 ;
36176 bool arg2 = (bool) true ;
36177 bool result;
36178 void *argp1 = 0 ;
36179 int res1 = 0 ;
36180 bool val2 ;
36181 int ecode2 = 0 ;
36182 PyObject * obj0 = 0 ;
36183 PyObject * obj1 = 0 ;
36184 char * kwnames[] = {
36185 (char *) "self",(char *) "enable", NULL
36186 };
36187
36188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
36189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36190 if (!SWIG_IsOK(res1)) {
36191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
36192 }
36193 arg1 = reinterpret_cast< wxWindow * >(argp1);
36194 if (obj1) {
36195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36196 if (!SWIG_IsOK(ecode2)) {
36197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
36198 }
36199 arg2 = static_cast< bool >(val2);
36200 }
36201 {
36202 PyThreadState* __tstate = wxPyBeginAllowThreads();
36203 result = (bool)(arg1)->Enable(arg2);
36204 wxPyEndAllowThreads(__tstate);
36205 if (PyErr_Occurred()) SWIG_fail;
36206 }
36207 {
36208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36209 }
36210 return resultobj;
36211 fail:
36212 return NULL;
36213 }
36214
36215
36216 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36217 PyObject *resultobj = 0;
36218 wxWindow *arg1 = (wxWindow *) 0 ;
36219 bool result;
36220 void *argp1 = 0 ;
36221 int res1 = 0 ;
36222 PyObject *swig_obj[1] ;
36223
36224 if (!args) SWIG_fail;
36225 swig_obj[0] = args;
36226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36227 if (!SWIG_IsOK(res1)) {
36228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
36229 }
36230 arg1 = reinterpret_cast< wxWindow * >(argp1);
36231 {
36232 PyThreadState* __tstate = wxPyBeginAllowThreads();
36233 result = (bool)(arg1)->Disable();
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 {
36238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36239 }
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36247 PyObject *resultobj = 0;
36248 wxWindow *arg1 = (wxWindow *) 0 ;
36249 bool result;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 PyObject *swig_obj[1] ;
36253
36254 if (!args) SWIG_fail;
36255 swig_obj[0] = args;
36256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (bool)((wxWindow const *)arg1)->IsShown();
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 {
36268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36269 }
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 wxWindow *arg1 = (wxWindow *) 0 ;
36279 bool result;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 PyObject *swig_obj[1] ;
36283
36284 if (!args) SWIG_fail;
36285 swig_obj[0] = args;
36286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36289 }
36290 arg1 = reinterpret_cast< wxWindow * >(argp1);
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 result = (bool)((wxWindow const *)arg1)->IsEnabled();
36294 wxPyEndAllowThreads(__tstate);
36295 if (PyErr_Occurred()) SWIG_fail;
36296 }
36297 {
36298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36299 }
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxWindow *arg1 = (wxWindow *) 0 ;
36309 bool result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 PyObject *swig_obj[1] ;
36313
36314 if (!args) SWIG_fail;
36315 swig_obj[0] = args;
36316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36317 if (!SWIG_IsOK(res1)) {
36318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36319 }
36320 arg1 = reinterpret_cast< wxWindow * >(argp1);
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 {
36328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36329 }
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36337 PyObject *resultobj = 0;
36338 wxWindow *arg1 = (wxWindow *) 0 ;
36339 bool result;
36340 void *argp1 = 0 ;
36341 int res1 = 0 ;
36342 PyObject *swig_obj[1] ;
36343
36344 if (!args) SWIG_fail;
36345 swig_obj[0] = args;
36346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36347 if (!SWIG_IsOK(res1)) {
36348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36349 }
36350 arg1 = reinterpret_cast< wxWindow * >(argp1);
36351 {
36352 PyThreadState* __tstate = wxPyBeginAllowThreads();
36353 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
36354 wxPyEndAllowThreads(__tstate);
36355 if (PyErr_Occurred()) SWIG_fail;
36356 }
36357 {
36358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36359 }
36360 return resultobj;
36361 fail:
36362 return NULL;
36363 }
36364
36365
36366 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36367 PyObject *resultobj = 0;
36368 wxWindow *arg1 = (wxWindow *) 0 ;
36369 long arg2 ;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 long val2 ;
36373 int ecode2 = 0 ;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 char * kwnames[] = {
36377 (char *) "self",(char *) "style", NULL
36378 };
36379
36380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36382 if (!SWIG_IsOK(res1)) {
36383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
36384 }
36385 arg1 = reinterpret_cast< wxWindow * >(argp1);
36386 ecode2 = SWIG_AsVal_long(obj1, &val2);
36387 if (!SWIG_IsOK(ecode2)) {
36388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
36389 }
36390 arg2 = static_cast< long >(val2);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 (arg1)->SetWindowStyleFlag(arg2);
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 resultobj = SWIG_Py_Void();
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 long result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 PyObject *swig_obj[1] ;
36411
36412 if (!args) SWIG_fail;
36413 swig_obj[0] = args;
36414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36415 if (!SWIG_IsOK(res1)) {
36416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36417 }
36418 arg1 = reinterpret_cast< wxWindow * >(argp1);
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_From_long(static_cast< long >(result));
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 int arg2 ;
36436 bool result;
36437 void *argp1 = 0 ;
36438 int res1 = 0 ;
36439 int val2 ;
36440 int ecode2 = 0 ;
36441 PyObject * obj0 = 0 ;
36442 PyObject * obj1 = 0 ;
36443 char * kwnames[] = {
36444 (char *) "self",(char *) "flag", NULL
36445 };
36446
36447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36449 if (!SWIG_IsOK(res1)) {
36450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36451 }
36452 arg1 = reinterpret_cast< wxWindow * >(argp1);
36453 ecode2 = SWIG_AsVal_int(obj1, &val2);
36454 if (!SWIG_IsOK(ecode2)) {
36455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36456 }
36457 arg2 = static_cast< int >(val2);
36458 {
36459 PyThreadState* __tstate = wxPyBeginAllowThreads();
36460 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36461 wxPyEndAllowThreads(__tstate);
36462 if (PyErr_Occurred()) SWIG_fail;
36463 }
36464 {
36465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36466 }
36467 return resultobj;
36468 fail:
36469 return NULL;
36470 }
36471
36472
36473 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36474 PyObject *resultobj = 0;
36475 wxWindow *arg1 = (wxWindow *) 0 ;
36476 bool result;
36477 void *argp1 = 0 ;
36478 int res1 = 0 ;
36479 PyObject *swig_obj[1] ;
36480
36481 if (!args) SWIG_fail;
36482 swig_obj[0] = args;
36483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36486 }
36487 arg1 = reinterpret_cast< wxWindow * >(argp1);
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 result = (bool)((wxWindow const *)arg1)->IsRetained();
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 {
36495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36496 }
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36504 PyObject *resultobj = 0;
36505 wxWindow *arg1 = (wxWindow *) 0 ;
36506 int arg2 ;
36507 bool result;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 int val2 ;
36511 int ecode2 = 0 ;
36512 PyObject * obj0 = 0 ;
36513 PyObject * obj1 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "self",(char *) "flag", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 ecode2 = SWIG_AsVal_int(obj1, &val2);
36525 if (!SWIG_IsOK(ecode2)) {
36526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36527 }
36528 arg2 = static_cast< int >(val2);
36529 {
36530 PyThreadState* __tstate = wxPyBeginAllowThreads();
36531 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36532 wxPyEndAllowThreads(__tstate);
36533 if (PyErr_Occurred()) SWIG_fail;
36534 }
36535 {
36536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36537 }
36538 return resultobj;
36539 fail:
36540 return NULL;
36541 }
36542
36543
36544 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36545 PyObject *resultobj = 0;
36546 wxWindow *arg1 = (wxWindow *) 0 ;
36547 long arg2 ;
36548 void *argp1 = 0 ;
36549 int res1 = 0 ;
36550 long val2 ;
36551 int ecode2 = 0 ;
36552 PyObject * obj0 = 0 ;
36553 PyObject * obj1 = 0 ;
36554 char * kwnames[] = {
36555 (char *) "self",(char *) "exStyle", NULL
36556 };
36557
36558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 ecode2 = SWIG_AsVal_long(obj1, &val2);
36565 if (!SWIG_IsOK(ecode2)) {
36566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36567 }
36568 arg2 = static_cast< long >(val2);
36569 {
36570 PyThreadState* __tstate = wxPyBeginAllowThreads();
36571 (arg1)->SetExtraStyle(arg2);
36572 wxPyEndAllowThreads(__tstate);
36573 if (PyErr_Occurred()) SWIG_fail;
36574 }
36575 resultobj = SWIG_Py_Void();
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 long result;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 PyObject *swig_obj[1] ;
36589
36590 if (!args) SWIG_fail;
36591 swig_obj[0] = args;
36592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36593 if (!SWIG_IsOK(res1)) {
36594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36595 }
36596 arg1 = reinterpret_cast< wxWindow * >(argp1);
36597 {
36598 PyThreadState* __tstate = wxPyBeginAllowThreads();
36599 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36600 wxPyEndAllowThreads(__tstate);
36601 if (PyErr_Occurred()) SWIG_fail;
36602 }
36603 resultobj = SWIG_From_long(static_cast< long >(result));
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 bool arg2 = (bool) true ;
36614 void *argp1 = 0 ;
36615 int res1 = 0 ;
36616 bool val2 ;
36617 int ecode2 = 0 ;
36618 PyObject * obj0 = 0 ;
36619 PyObject * obj1 = 0 ;
36620 char * kwnames[] = {
36621 (char *) "self",(char *) "modal", NULL
36622 };
36623
36624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36626 if (!SWIG_IsOK(res1)) {
36627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36628 }
36629 arg1 = reinterpret_cast< wxWindow * >(argp1);
36630 if (obj1) {
36631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36632 if (!SWIG_IsOK(ecode2)) {
36633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36634 }
36635 arg2 = static_cast< bool >(val2);
36636 }
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 (arg1)->MakeModal(arg2);
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 resultobj = SWIG_Py_Void();
36644 return resultobj;
36645 fail:
36646 return NULL;
36647 }
36648
36649
36650 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36651 PyObject *resultobj = 0;
36652 wxWindow *arg1 = (wxWindow *) 0 ;
36653 bool arg2 ;
36654 void *argp1 = 0 ;
36655 int res1 = 0 ;
36656 bool val2 ;
36657 int ecode2 = 0 ;
36658 PyObject * obj0 = 0 ;
36659 PyObject * obj1 = 0 ;
36660 char * kwnames[] = {
36661 (char *) "self",(char *) "enableTheme", NULL
36662 };
36663
36664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36666 if (!SWIG_IsOK(res1)) {
36667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36668 }
36669 arg1 = reinterpret_cast< wxWindow * >(argp1);
36670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36671 if (!SWIG_IsOK(ecode2)) {
36672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36673 }
36674 arg2 = static_cast< bool >(val2);
36675 {
36676 PyThreadState* __tstate = wxPyBeginAllowThreads();
36677 (arg1)->SetThemeEnabled(arg2);
36678 wxPyEndAllowThreads(__tstate);
36679 if (PyErr_Occurred()) SWIG_fail;
36680 }
36681 resultobj = SWIG_Py_Void();
36682 return resultobj;
36683 fail:
36684 return NULL;
36685 }
36686
36687
36688 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36689 PyObject *resultobj = 0;
36690 wxWindow *arg1 = (wxWindow *) 0 ;
36691 bool result;
36692 void *argp1 = 0 ;
36693 int res1 = 0 ;
36694 PyObject *swig_obj[1] ;
36695
36696 if (!args) SWIG_fail;
36697 swig_obj[0] = args;
36698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36699 if (!SWIG_IsOK(res1)) {
36700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36701 }
36702 arg1 = reinterpret_cast< wxWindow * >(argp1);
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 {
36710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36711 }
36712 return resultobj;
36713 fail:
36714 return NULL;
36715 }
36716
36717
36718 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36719 PyObject *resultobj = 0;
36720 wxWindow *arg1 = (wxWindow *) 0 ;
36721 void *argp1 = 0 ;
36722 int res1 = 0 ;
36723 PyObject *swig_obj[1] ;
36724
36725 if (!args) SWIG_fail;
36726 swig_obj[0] = args;
36727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36728 if (!SWIG_IsOK(res1)) {
36729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36730 }
36731 arg1 = reinterpret_cast< wxWindow * >(argp1);
36732 {
36733 PyThreadState* __tstate = wxPyBeginAllowThreads();
36734 (arg1)->SetFocus();
36735 wxPyEndAllowThreads(__tstate);
36736 if (PyErr_Occurred()) SWIG_fail;
36737 }
36738 resultobj = SWIG_Py_Void();
36739 return resultobj;
36740 fail:
36741 return NULL;
36742 }
36743
36744
36745 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 void *argp1 = 0 ;
36749 int res1 = 0 ;
36750 PyObject *swig_obj[1] ;
36751
36752 if (!args) SWIG_fail;
36753 swig_obj[0] = args;
36754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36755 if (!SWIG_IsOK(res1)) {
36756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36757 }
36758 arg1 = reinterpret_cast< wxWindow * >(argp1);
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 (arg1)->SetFocusFromKbd();
36762 wxPyEndAllowThreads(__tstate);
36763 if (PyErr_Occurred()) SWIG_fail;
36764 }
36765 resultobj = SWIG_Py_Void();
36766 return resultobj;
36767 fail:
36768 return NULL;
36769 }
36770
36771
36772 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36773 PyObject *resultobj = 0;
36774 wxWindow *result = 0 ;
36775
36776 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36777 {
36778 if (!wxPyCheckForApp()) SWIG_fail;
36779 PyThreadState* __tstate = wxPyBeginAllowThreads();
36780 result = (wxWindow *)wxWindow::FindFocus();
36781 wxPyEndAllowThreads(__tstate);
36782 if (PyErr_Occurred()) SWIG_fail;
36783 }
36784 {
36785 resultobj = wxPyMake_wxObject(result, 0);
36786 }
36787 return resultobj;
36788 fail:
36789 return NULL;
36790 }
36791
36792
36793 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36794 PyObject *resultobj = 0;
36795 wxWindow *arg1 = (wxWindow *) 0 ;
36796 bool result;
36797 void *argp1 = 0 ;
36798 int res1 = 0 ;
36799 PyObject *swig_obj[1] ;
36800
36801 if (!args) SWIG_fail;
36802 swig_obj[0] = args;
36803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36804 if (!SWIG_IsOK(res1)) {
36805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36806 }
36807 arg1 = reinterpret_cast< wxWindow * >(argp1);
36808 {
36809 PyThreadState* __tstate = wxPyBeginAllowThreads();
36810 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 {
36815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36816 }
36817 return resultobj;
36818 fail:
36819 return NULL;
36820 }
36821
36822
36823 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36824 PyObject *resultobj = 0;
36825 wxWindow *arg1 = (wxWindow *) 0 ;
36826 bool result;
36827 void *argp1 = 0 ;
36828 int res1 = 0 ;
36829 PyObject *swig_obj[1] ;
36830
36831 if (!args) SWIG_fail;
36832 swig_obj[0] = args;
36833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36834 if (!SWIG_IsOK(res1)) {
36835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36836 }
36837 arg1 = reinterpret_cast< wxWindow * >(argp1);
36838 {
36839 PyThreadState* __tstate = wxPyBeginAllowThreads();
36840 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36841 wxPyEndAllowThreads(__tstate);
36842 if (PyErr_Occurred()) SWIG_fail;
36843 }
36844 {
36845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36846 }
36847 return resultobj;
36848 fail:
36849 return NULL;
36850 }
36851
36852
36853 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36854 PyObject *resultobj = 0;
36855 wxWindow *arg1 = (wxWindow *) 0 ;
36856 bool result;
36857 void *argp1 = 0 ;
36858 int res1 = 0 ;
36859 PyObject *swig_obj[1] ;
36860
36861 if (!args) SWIG_fail;
36862 swig_obj[0] = args;
36863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36864 if (!SWIG_IsOK(res1)) {
36865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36866 }
36867 arg1 = reinterpret_cast< wxWindow * >(argp1);
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 {
36875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36876 }
36877 return resultobj;
36878 fail:
36879 return NULL;
36880 }
36881
36882
36883 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36884 PyObject *resultobj = 0;
36885 wxWindow *arg1 = (wxWindow *) 0 ;
36886 bool result;
36887 void *argp1 = 0 ;
36888 int res1 = 0 ;
36889 PyObject *swig_obj[1] ;
36890
36891 if (!args) SWIG_fail;
36892 swig_obj[0] = args;
36893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 {
36905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36906 }
36907 return resultobj;
36908 fail:
36909 return NULL;
36910 }
36911
36912
36913 SWIGINTERN PyObject *_wrap_Window_SetCanFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36914 PyObject *resultobj = 0;
36915 wxWindow *arg1 = (wxWindow *) 0 ;
36916 bool arg2 ;
36917 void *argp1 = 0 ;
36918 int res1 = 0 ;
36919 bool val2 ;
36920 int ecode2 = 0 ;
36921 PyObject * obj0 = 0 ;
36922 PyObject * obj1 = 0 ;
36923 char * kwnames[] = {
36924 (char *) "self",(char *) "canFocus", NULL
36925 };
36926
36927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCanFocus",kwnames,&obj0,&obj1)) SWIG_fail;
36928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36929 if (!SWIG_IsOK(res1)) {
36930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCanFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36931 }
36932 arg1 = reinterpret_cast< wxWindow * >(argp1);
36933 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36934 if (!SWIG_IsOK(ecode2)) {
36935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetCanFocus" "', expected argument " "2"" of type '" "bool""'");
36936 }
36937 arg2 = static_cast< bool >(val2);
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 (arg1)->SetCanFocus(arg2);
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 resultobj = SWIG_Py_Void();
36945 return resultobj;
36946 fail:
36947 return NULL;
36948 }
36949
36950
36951 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36952 PyObject *resultobj = 0;
36953 wxWindow *arg1 = (wxWindow *) 0 ;
36954 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36955 bool result;
36956 void *argp1 = 0 ;
36957 int res1 = 0 ;
36958 int val2 ;
36959 int ecode2 = 0 ;
36960 PyObject * obj0 = 0 ;
36961 PyObject * obj1 = 0 ;
36962 char * kwnames[] = {
36963 (char *) "self",(char *) "flags", NULL
36964 };
36965
36966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36968 if (!SWIG_IsOK(res1)) {
36969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36970 }
36971 arg1 = reinterpret_cast< wxWindow * >(argp1);
36972 if (obj1) {
36973 ecode2 = SWIG_AsVal_int(obj1, &val2);
36974 if (!SWIG_IsOK(ecode2)) {
36975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36976 }
36977 arg2 = static_cast< int >(val2);
36978 }
36979 {
36980 PyThreadState* __tstate = wxPyBeginAllowThreads();
36981 result = (bool)(arg1)->NavigateIn(arg2);
36982 wxPyEndAllowThreads(__tstate);
36983 if (PyErr_Occurred()) SWIG_fail;
36984 }
36985 {
36986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36987 }
36988 return resultobj;
36989 fail:
36990 return NULL;
36991 }
36992
36993
36994 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36995 PyObject *resultobj = 0;
36996 wxWindow *arg1 = (wxWindow *) 0 ;
36997 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36998 bool result;
36999 void *argp1 = 0 ;
37000 int res1 = 0 ;
37001 int val2 ;
37002 int ecode2 = 0 ;
37003 PyObject * obj0 = 0 ;
37004 PyObject * obj1 = 0 ;
37005 char * kwnames[] = {
37006 (char *) "self",(char *) "flags", NULL
37007 };
37008
37009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
37010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37011 if (!SWIG_IsOK(res1)) {
37012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
37013 }
37014 arg1 = reinterpret_cast< wxWindow * >(argp1);
37015 if (obj1) {
37016 ecode2 = SWIG_AsVal_int(obj1, &val2);
37017 if (!SWIG_IsOK(ecode2)) {
37018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
37019 }
37020 arg2 = static_cast< int >(val2);
37021 }
37022 {
37023 PyThreadState* __tstate = wxPyBeginAllowThreads();
37024 result = (bool)(arg1)->Navigate(arg2);
37025 wxPyEndAllowThreads(__tstate);
37026 if (PyErr_Occurred()) SWIG_fail;
37027 }
37028 {
37029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37030 }
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37038 PyObject *resultobj = 0;
37039 wxWindow *arg1 = (wxWindow *) 0 ;
37040 wxWindow *arg2 = (wxWindow *) 0 ;
37041 void *argp1 = 0 ;
37042 int res1 = 0 ;
37043 void *argp2 = 0 ;
37044 int res2 = 0 ;
37045 PyObject * obj0 = 0 ;
37046 PyObject * obj1 = 0 ;
37047 char * kwnames[] = {
37048 (char *) "self",(char *) "win", NULL
37049 };
37050
37051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37053 if (!SWIG_IsOK(res1)) {
37054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37055 }
37056 arg1 = reinterpret_cast< wxWindow * >(argp1);
37057 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37058 if (!SWIG_IsOK(res2)) {
37059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37060 }
37061 arg2 = reinterpret_cast< wxWindow * >(argp2);
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 (arg1)->MoveAfterInTabOrder(arg2);
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 resultobj = SWIG_Py_Void();
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37076 PyObject *resultobj = 0;
37077 wxWindow *arg1 = (wxWindow *) 0 ;
37078 wxWindow *arg2 = (wxWindow *) 0 ;
37079 void *argp1 = 0 ;
37080 int res1 = 0 ;
37081 void *argp2 = 0 ;
37082 int res2 = 0 ;
37083 PyObject * obj0 = 0 ;
37084 PyObject * obj1 = 0 ;
37085 char * kwnames[] = {
37086 (char *) "self",(char *) "win", NULL
37087 };
37088
37089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37091 if (!SWIG_IsOK(res1)) {
37092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37093 }
37094 arg1 = reinterpret_cast< wxWindow * >(argp1);
37095 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37096 if (!SWIG_IsOK(res2)) {
37097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37098 }
37099 arg2 = reinterpret_cast< wxWindow * >(argp2);
37100 {
37101 PyThreadState* __tstate = wxPyBeginAllowThreads();
37102 (arg1)->MoveBeforeInTabOrder(arg2);
37103 wxPyEndAllowThreads(__tstate);
37104 if (PyErr_Occurred()) SWIG_fail;
37105 }
37106 resultobj = SWIG_Py_Void();
37107 return resultobj;
37108 fail:
37109 return NULL;
37110 }
37111
37112
37113 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37114 PyObject *resultobj = 0;
37115 wxWindow *arg1 = (wxWindow *) 0 ;
37116 PyObject *result = 0 ;
37117 void *argp1 = 0 ;
37118 int res1 = 0 ;
37119 PyObject *swig_obj[1] ;
37120
37121 if (!args) SWIG_fail;
37122 swig_obj[0] = args;
37123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37124 if (!SWIG_IsOK(res1)) {
37125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
37126 }
37127 arg1 = reinterpret_cast< wxWindow * >(argp1);
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 result = (PyObject *)wxWindow_GetChildren(arg1);
37131 wxPyEndAllowThreads(__tstate);
37132 if (PyErr_Occurred()) SWIG_fail;
37133 }
37134 resultobj = result;
37135 return resultobj;
37136 fail:
37137 return NULL;
37138 }
37139
37140
37141 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37142 PyObject *resultobj = 0;
37143 wxWindow *arg1 = (wxWindow *) 0 ;
37144 wxWindow *result = 0 ;
37145 void *argp1 = 0 ;
37146 int res1 = 0 ;
37147 PyObject *swig_obj[1] ;
37148
37149 if (!args) SWIG_fail;
37150 swig_obj[0] = args;
37151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37152 if (!SWIG_IsOK(res1)) {
37153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37154 }
37155 arg1 = reinterpret_cast< wxWindow * >(argp1);
37156 {
37157 PyThreadState* __tstate = wxPyBeginAllowThreads();
37158 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 {
37163 resultobj = wxPyMake_wxObject(result, 0);
37164 }
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 wxWindow *result = 0 ;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 PyObject *swig_obj[1] ;
37178
37179 if (!args) SWIG_fail;
37180 swig_obj[0] = args;
37181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 {
37193 resultobj = wxPyMake_wxObject(result, 0);
37194 }
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 wxWindow *result = 0 ;
37205 void *argp1 = 0 ;
37206 int res1 = 0 ;
37207 PyObject *swig_obj[1] ;
37208
37209 if (!args) SWIG_fail;
37210 swig_obj[0] = args;
37211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37212 if (!SWIG_IsOK(res1)) {
37213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
37214 }
37215 arg1 = reinterpret_cast< wxWindow * >(argp1);
37216 {
37217 PyThreadState* __tstate = wxPyBeginAllowThreads();
37218 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 {
37223 resultobj = wxPyMake_wxObject(result, 0);
37224 }
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37232 PyObject *resultobj = 0;
37233 wxWindow *arg1 = (wxWindow *) 0 ;
37234 bool result;
37235 void *argp1 = 0 ;
37236 int res1 = 0 ;
37237 PyObject *swig_obj[1] ;
37238
37239 if (!args) SWIG_fail;
37240 swig_obj[0] = args;
37241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37242 if (!SWIG_IsOK(res1)) {
37243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
37244 }
37245 arg1 = reinterpret_cast< wxWindow * >(argp1);
37246 {
37247 PyThreadState* __tstate = wxPyBeginAllowThreads();
37248 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
37249 wxPyEndAllowThreads(__tstate);
37250 if (PyErr_Occurred()) SWIG_fail;
37251 }
37252 {
37253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37254 }
37255 return resultobj;
37256 fail:
37257 return NULL;
37258 }
37259
37260
37261 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37262 PyObject *resultobj = 0;
37263 wxWindow *arg1 = (wxWindow *) 0 ;
37264 wxWindow *arg2 = (wxWindow *) 0 ;
37265 bool result;
37266 void *argp1 = 0 ;
37267 int res1 = 0 ;
37268 void *argp2 = 0 ;
37269 int res2 = 0 ;
37270 PyObject * obj0 = 0 ;
37271 PyObject * obj1 = 0 ;
37272 char * kwnames[] = {
37273 (char *) "self",(char *) "newParent", NULL
37274 };
37275
37276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
37277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37278 if (!SWIG_IsOK(res1)) {
37279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37280 }
37281 arg1 = reinterpret_cast< wxWindow * >(argp1);
37282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37283 if (!SWIG_IsOK(res2)) {
37284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
37285 }
37286 arg2 = reinterpret_cast< wxWindow * >(argp2);
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 result = (bool)(arg1)->Reparent(arg2);
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 {
37294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37295 }
37296 return resultobj;
37297 fail:
37298 return NULL;
37299 }
37300
37301
37302 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37303 PyObject *resultobj = 0;
37304 wxWindow *arg1 = (wxWindow *) 0 ;
37305 wxWindow *arg2 = (wxWindow *) 0 ;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 void *argp2 = 0 ;
37309 int res2 = 0 ;
37310 PyObject * obj0 = 0 ;
37311 PyObject * obj1 = 0 ;
37312 char * kwnames[] = {
37313 (char *) "self",(char *) "child", NULL
37314 };
37315
37316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
37317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37318 if (!SWIG_IsOK(res1)) {
37319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37320 }
37321 arg1 = reinterpret_cast< wxWindow * >(argp1);
37322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37323 if (!SWIG_IsOK(res2)) {
37324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37325 }
37326 arg2 = reinterpret_cast< wxWindow * >(argp2);
37327 {
37328 PyThreadState* __tstate = wxPyBeginAllowThreads();
37329 (arg1)->AddChild(arg2);
37330 wxPyEndAllowThreads(__tstate);
37331 if (PyErr_Occurred()) SWIG_fail;
37332 }
37333 resultobj = SWIG_Py_Void();
37334 return resultobj;
37335 fail:
37336 return NULL;
37337 }
37338
37339
37340 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37341 PyObject *resultobj = 0;
37342 wxWindow *arg1 = (wxWindow *) 0 ;
37343 wxWindow *arg2 = (wxWindow *) 0 ;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 void *argp2 = 0 ;
37347 int res2 = 0 ;
37348 PyObject * obj0 = 0 ;
37349 PyObject * obj1 = 0 ;
37350 char * kwnames[] = {
37351 (char *) "self",(char *) "child", NULL
37352 };
37353
37354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
37355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37356 if (!SWIG_IsOK(res1)) {
37357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37358 }
37359 arg1 = reinterpret_cast< wxWindow * >(argp1);
37360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37361 if (!SWIG_IsOK(res2)) {
37362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37363 }
37364 arg2 = reinterpret_cast< wxWindow * >(argp2);
37365 {
37366 PyThreadState* __tstate = wxPyBeginAllowThreads();
37367 (arg1)->RemoveChild(arg2);
37368 wxPyEndAllowThreads(__tstate);
37369 if (PyErr_Occurred()) SWIG_fail;
37370 }
37371 resultobj = SWIG_Py_Void();
37372 return resultobj;
37373 fail:
37374 return NULL;
37375 }
37376
37377
37378 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37379 PyObject *resultobj = 0;
37380 wxWindow *arg1 = (wxWindow *) 0 ;
37381 bool arg2 ;
37382 void *argp1 = 0 ;
37383 int res1 = 0 ;
37384 bool val2 ;
37385 int ecode2 = 0 ;
37386 PyObject * obj0 = 0 ;
37387 PyObject * obj1 = 0 ;
37388 char * kwnames[] = {
37389 (char *) "self",(char *) "on", NULL
37390 };
37391
37392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
37393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37394 if (!SWIG_IsOK(res1)) {
37395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
37396 }
37397 arg1 = reinterpret_cast< wxWindow * >(argp1);
37398 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37399 if (!SWIG_IsOK(ecode2)) {
37400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
37401 }
37402 arg2 = static_cast< bool >(val2);
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 wxWindow_SetDoubleBuffered(arg1,arg2);
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 resultobj = SWIG_Py_Void();
37410 return resultobj;
37411 fail:
37412 return NULL;
37413 }
37414
37415
37416 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37417 PyObject *resultobj = 0;
37418 wxWindow *arg1 = (wxWindow *) 0 ;
37419 long arg2 ;
37420 wxWindow *result = 0 ;
37421 void *argp1 = 0 ;
37422 int res1 = 0 ;
37423 long val2 ;
37424 int ecode2 = 0 ;
37425 PyObject * obj0 = 0 ;
37426 PyObject * obj1 = 0 ;
37427 char * kwnames[] = {
37428 (char *) "self",(char *) "winid", NULL
37429 };
37430
37431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37433 if (!SWIG_IsOK(res1)) {
37434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
37435 }
37436 arg1 = reinterpret_cast< wxWindow * >(argp1);
37437 ecode2 = SWIG_AsVal_long(obj1, &val2);
37438 if (!SWIG_IsOK(ecode2)) {
37439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
37440 }
37441 arg2 = static_cast< long >(val2);
37442 {
37443 PyThreadState* __tstate = wxPyBeginAllowThreads();
37444 result = (wxWindow *)(arg1)->FindWindow(arg2);
37445 wxPyEndAllowThreads(__tstate);
37446 if (PyErr_Occurred()) SWIG_fail;
37447 }
37448 {
37449 resultobj = wxPyMake_wxObject(result, 0);
37450 }
37451 return resultobj;
37452 fail:
37453 return NULL;
37454 }
37455
37456
37457 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37458 PyObject *resultobj = 0;
37459 wxWindow *arg1 = (wxWindow *) 0 ;
37460 wxString *arg2 = 0 ;
37461 wxWindow *result = 0 ;
37462 void *argp1 = 0 ;
37463 int res1 = 0 ;
37464 bool temp2 = false ;
37465 PyObject * obj0 = 0 ;
37466 PyObject * obj1 = 0 ;
37467 char * kwnames[] = {
37468 (char *) "self",(char *) "name", NULL
37469 };
37470
37471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37473 if (!SWIG_IsOK(res1)) {
37474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
37475 }
37476 arg1 = reinterpret_cast< wxWindow * >(argp1);
37477 {
37478 arg2 = wxString_in_helper(obj1);
37479 if (arg2 == NULL) SWIG_fail;
37480 temp2 = true;
37481 }
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37485 wxPyEndAllowThreads(__tstate);
37486 if (PyErr_Occurred()) SWIG_fail;
37487 }
37488 {
37489 resultobj = wxPyMake_wxObject(result, 0);
37490 }
37491 {
37492 if (temp2)
37493 delete arg2;
37494 }
37495 return resultobj;
37496 fail:
37497 {
37498 if (temp2)
37499 delete arg2;
37500 }
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37506 PyObject *resultobj = 0;
37507 wxWindow *arg1 = (wxWindow *) 0 ;
37508 wxEvtHandler *result = 0 ;
37509 void *argp1 = 0 ;
37510 int res1 = 0 ;
37511 PyObject *swig_obj[1] ;
37512
37513 if (!args) SWIG_fail;
37514 swig_obj[0] = args;
37515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37516 if (!SWIG_IsOK(res1)) {
37517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37518 }
37519 arg1 = reinterpret_cast< wxWindow * >(argp1);
37520 {
37521 PyThreadState* __tstate = wxPyBeginAllowThreads();
37522 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37523 wxPyEndAllowThreads(__tstate);
37524 if (PyErr_Occurred()) SWIG_fail;
37525 }
37526 {
37527 resultobj = wxPyMake_wxObject(result, 0);
37528 }
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37536 PyObject *resultobj = 0;
37537 wxWindow *arg1 = (wxWindow *) 0 ;
37538 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37539 void *argp1 = 0 ;
37540 int res1 = 0 ;
37541 void *argp2 = 0 ;
37542 int res2 = 0 ;
37543 PyObject * obj0 = 0 ;
37544 PyObject * obj1 = 0 ;
37545 char * kwnames[] = {
37546 (char *) "self",(char *) "handler", NULL
37547 };
37548
37549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37551 if (!SWIG_IsOK(res1)) {
37552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37553 }
37554 arg1 = reinterpret_cast< wxWindow * >(argp1);
37555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37556 if (!SWIG_IsOK(res2)) {
37557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37558 }
37559 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37560 {
37561 PyThreadState* __tstate = wxPyBeginAllowThreads();
37562 (arg1)->SetEventHandler(arg2);
37563 wxPyEndAllowThreads(__tstate);
37564 if (PyErr_Occurred()) SWIG_fail;
37565 }
37566 resultobj = SWIG_Py_Void();
37567 return resultobj;
37568 fail:
37569 return NULL;
37570 }
37571
37572
37573 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37574 PyObject *resultobj = 0;
37575 wxWindow *arg1 = (wxWindow *) 0 ;
37576 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37577 void *argp1 = 0 ;
37578 int res1 = 0 ;
37579 void *argp2 = 0 ;
37580 int res2 = 0 ;
37581 PyObject * obj0 = 0 ;
37582 PyObject * obj1 = 0 ;
37583 char * kwnames[] = {
37584 (char *) "self",(char *) "handler", NULL
37585 };
37586
37587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37589 if (!SWIG_IsOK(res1)) {
37590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37591 }
37592 arg1 = reinterpret_cast< wxWindow * >(argp1);
37593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37594 if (!SWIG_IsOK(res2)) {
37595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37596 }
37597 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37598 {
37599 PyThreadState* __tstate = wxPyBeginAllowThreads();
37600 (arg1)->PushEventHandler(arg2);
37601 wxPyEndAllowThreads(__tstate);
37602 if (PyErr_Occurred()) SWIG_fail;
37603 }
37604 resultobj = SWIG_Py_Void();
37605 return resultobj;
37606 fail:
37607 return NULL;
37608 }
37609
37610
37611 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37612 PyObject *resultobj = 0;
37613 wxWindow *arg1 = (wxWindow *) 0 ;
37614 bool arg2 = (bool) false ;
37615 wxEvtHandler *result = 0 ;
37616 void *argp1 = 0 ;
37617 int res1 = 0 ;
37618 bool val2 ;
37619 int ecode2 = 0 ;
37620 PyObject * obj0 = 0 ;
37621 PyObject * obj1 = 0 ;
37622 char * kwnames[] = {
37623 (char *) "self",(char *) "deleteHandler", NULL
37624 };
37625
37626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37628 if (!SWIG_IsOK(res1)) {
37629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37630 }
37631 arg1 = reinterpret_cast< wxWindow * >(argp1);
37632 if (obj1) {
37633 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37634 if (!SWIG_IsOK(ecode2)) {
37635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37636 }
37637 arg2 = static_cast< bool >(val2);
37638 }
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 {
37646 resultobj = wxPyMake_wxObject(result, 0);
37647 }
37648 return resultobj;
37649 fail:
37650 return NULL;
37651 }
37652
37653
37654 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37655 PyObject *resultobj = 0;
37656 wxWindow *arg1 = (wxWindow *) 0 ;
37657 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37658 bool result;
37659 void *argp1 = 0 ;
37660 int res1 = 0 ;
37661 void *argp2 = 0 ;
37662 int res2 = 0 ;
37663 PyObject * obj0 = 0 ;
37664 PyObject * obj1 = 0 ;
37665 char * kwnames[] = {
37666 (char *) "self",(char *) "handler", NULL
37667 };
37668
37669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37671 if (!SWIG_IsOK(res1)) {
37672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37673 }
37674 arg1 = reinterpret_cast< wxWindow * >(argp1);
37675 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37676 if (!SWIG_IsOK(res2)) {
37677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37678 }
37679 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37680 {
37681 PyThreadState* __tstate = wxPyBeginAllowThreads();
37682 result = (bool)(arg1)->RemoveEventHandler(arg2);
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 {
37687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37688 }
37689 return resultobj;
37690 fail:
37691 return NULL;
37692 }
37693
37694
37695 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37696 PyObject *resultobj = 0;
37697 wxWindow *arg1 = (wxWindow *) 0 ;
37698 wxValidator *arg2 = 0 ;
37699 void *argp1 = 0 ;
37700 int res1 = 0 ;
37701 void *argp2 = 0 ;
37702 int res2 = 0 ;
37703 PyObject * obj0 = 0 ;
37704 PyObject * obj1 = 0 ;
37705 char * kwnames[] = {
37706 (char *) "self",(char *) "validator", NULL
37707 };
37708
37709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37711 if (!SWIG_IsOK(res1)) {
37712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37713 }
37714 arg1 = reinterpret_cast< wxWindow * >(argp1);
37715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37716 if (!SWIG_IsOK(res2)) {
37717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37718 }
37719 if (!argp2) {
37720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37721 }
37722 arg2 = reinterpret_cast< wxValidator * >(argp2);
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 (arg1)->SetValidator((wxValidator const &)*arg2);
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 resultobj = SWIG_Py_Void();
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37737 PyObject *resultobj = 0;
37738 wxWindow *arg1 = (wxWindow *) 0 ;
37739 wxValidator *result = 0 ;
37740 void *argp1 = 0 ;
37741 int res1 = 0 ;
37742 PyObject *swig_obj[1] ;
37743
37744 if (!args) SWIG_fail;
37745 swig_obj[0] = args;
37746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37747 if (!SWIG_IsOK(res1)) {
37748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37749 }
37750 arg1 = reinterpret_cast< wxWindow * >(argp1);
37751 {
37752 PyThreadState* __tstate = wxPyBeginAllowThreads();
37753 result = (wxValidator *)(arg1)->GetValidator();
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 resultobj = wxPyMake_wxObject(result, (bool)0);
37759 }
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37767 PyObject *resultobj = 0;
37768 wxWindow *arg1 = (wxWindow *) 0 ;
37769 bool result;
37770 void *argp1 = 0 ;
37771 int res1 = 0 ;
37772 PyObject *swig_obj[1] ;
37773
37774 if (!args) SWIG_fail;
37775 swig_obj[0] = args;
37776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37777 if (!SWIG_IsOK(res1)) {
37778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37779 }
37780 arg1 = reinterpret_cast< wxWindow * >(argp1);
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 result = (bool)(arg1)->Validate();
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 {
37788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37789 }
37790 return resultobj;
37791 fail:
37792 return NULL;
37793 }
37794
37795
37796 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37797 PyObject *resultobj = 0;
37798 wxWindow *arg1 = (wxWindow *) 0 ;
37799 bool result;
37800 void *argp1 = 0 ;
37801 int res1 = 0 ;
37802 PyObject *swig_obj[1] ;
37803
37804 if (!args) SWIG_fail;
37805 swig_obj[0] = args;
37806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37807 if (!SWIG_IsOK(res1)) {
37808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37809 }
37810 arg1 = reinterpret_cast< wxWindow * >(argp1);
37811 {
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 result = (bool)(arg1)->TransferDataToWindow();
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 {
37818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37819 }
37820 return resultobj;
37821 fail:
37822 return NULL;
37823 }
37824
37825
37826 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37827 PyObject *resultobj = 0;
37828 wxWindow *arg1 = (wxWindow *) 0 ;
37829 bool result;
37830 void *argp1 = 0 ;
37831 int res1 = 0 ;
37832 PyObject *swig_obj[1] ;
37833
37834 if (!args) SWIG_fail;
37835 swig_obj[0] = args;
37836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37837 if (!SWIG_IsOK(res1)) {
37838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37839 }
37840 arg1 = reinterpret_cast< wxWindow * >(argp1);
37841 {
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 result = (bool)(arg1)->TransferDataFromWindow();
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 {
37848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37849 }
37850 return resultobj;
37851 fail:
37852 return NULL;
37853 }
37854
37855
37856 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37857 PyObject *resultobj = 0;
37858 wxWindow *arg1 = (wxWindow *) 0 ;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 PyObject *swig_obj[1] ;
37862
37863 if (!args) SWIG_fail;
37864 swig_obj[0] = args;
37865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37866 if (!SWIG_IsOK(res1)) {
37867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37868 }
37869 arg1 = reinterpret_cast< wxWindow * >(argp1);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 (arg1)->InitDialog();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 resultobj = SWIG_Py_Void();
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37884 PyObject *resultobj = 0;
37885 wxWindow *arg1 = (wxWindow *) 0 ;
37886 wxAcceleratorTable *arg2 = 0 ;
37887 void *argp1 = 0 ;
37888 int res1 = 0 ;
37889 void *argp2 = 0 ;
37890 int res2 = 0 ;
37891 PyObject * obj0 = 0 ;
37892 PyObject * obj1 = 0 ;
37893 char * kwnames[] = {
37894 (char *) "self",(char *) "accel", NULL
37895 };
37896
37897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37901 }
37902 arg1 = reinterpret_cast< wxWindow * >(argp1);
37903 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37904 if (!SWIG_IsOK(res2)) {
37905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37906 }
37907 if (!argp2) {
37908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37909 }
37910 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37914 wxPyEndAllowThreads(__tstate);
37915 if (PyErr_Occurred()) SWIG_fail;
37916 }
37917 resultobj = SWIG_Py_Void();
37918 return resultobj;
37919 fail:
37920 return NULL;
37921 }
37922
37923
37924 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37925 PyObject *resultobj = 0;
37926 wxWindow *arg1 = (wxWindow *) 0 ;
37927 wxAcceleratorTable *result = 0 ;
37928 void *argp1 = 0 ;
37929 int res1 = 0 ;
37930 PyObject *swig_obj[1] ;
37931
37932 if (!args) SWIG_fail;
37933 swig_obj[0] = args;
37934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res1)) {
37936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37937 }
37938 arg1 = reinterpret_cast< wxWindow * >(argp1);
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37946 return resultobj;
37947 fail:
37948 return NULL;
37949 }
37950
37951
37952 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37953 PyObject *resultobj = 0;
37954 wxWindow *arg1 = (wxWindow *) 0 ;
37955 int arg2 ;
37956 int arg3 ;
37957 int arg4 ;
37958 bool result;
37959 void *argp1 = 0 ;
37960 int res1 = 0 ;
37961 int val2 ;
37962 int ecode2 = 0 ;
37963 int val3 ;
37964 int ecode3 = 0 ;
37965 int val4 ;
37966 int ecode4 = 0 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 PyObject * obj2 = 0 ;
37970 PyObject * obj3 = 0 ;
37971 char * kwnames[] = {
37972 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37973 };
37974
37975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37977 if (!SWIG_IsOK(res1)) {
37978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37979 }
37980 arg1 = reinterpret_cast< wxWindow * >(argp1);
37981 ecode2 = SWIG_AsVal_int(obj1, &val2);
37982 if (!SWIG_IsOK(ecode2)) {
37983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37984 }
37985 arg2 = static_cast< int >(val2);
37986 ecode3 = SWIG_AsVal_int(obj2, &val3);
37987 if (!SWIG_IsOK(ecode3)) {
37988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37989 }
37990 arg3 = static_cast< int >(val3);
37991 ecode4 = SWIG_AsVal_int(obj3, &val4);
37992 if (!SWIG_IsOK(ecode4)) {
37993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37994 }
37995 arg4 = static_cast< int >(val4);
37996 {
37997 PyThreadState* __tstate = wxPyBeginAllowThreads();
37998 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37999 wxPyEndAllowThreads(__tstate);
38000 if (PyErr_Occurred()) SWIG_fail;
38001 }
38002 {
38003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38004 }
38005 return resultobj;
38006 fail:
38007 return NULL;
38008 }
38009
38010
38011 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38012 PyObject *resultobj = 0;
38013 wxWindow *arg1 = (wxWindow *) 0 ;
38014 int arg2 ;
38015 bool result;
38016 void *argp1 = 0 ;
38017 int res1 = 0 ;
38018 int val2 ;
38019 int ecode2 = 0 ;
38020 PyObject * obj0 = 0 ;
38021 PyObject * obj1 = 0 ;
38022 char * kwnames[] = {
38023 (char *) "self",(char *) "hotkeyId", NULL
38024 };
38025
38026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
38027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38028 if (!SWIG_IsOK(res1)) {
38029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38030 }
38031 arg1 = reinterpret_cast< wxWindow * >(argp1);
38032 ecode2 = SWIG_AsVal_int(obj1, &val2);
38033 if (!SWIG_IsOK(ecode2)) {
38034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
38035 }
38036 arg2 = static_cast< int >(val2);
38037 {
38038 PyThreadState* __tstate = wxPyBeginAllowThreads();
38039 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
38040 wxPyEndAllowThreads(__tstate);
38041 if (PyErr_Occurred()) SWIG_fail;
38042 }
38043 {
38044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38045 }
38046 return resultobj;
38047 fail:
38048 return NULL;
38049 }
38050
38051
38052 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38053 PyObject *resultobj = 0;
38054 wxWindow *arg1 = (wxWindow *) 0 ;
38055 wxPoint *arg2 = 0 ;
38056 wxPoint result;
38057 void *argp1 = 0 ;
38058 int res1 = 0 ;
38059 wxPoint temp2 ;
38060 PyObject * obj0 = 0 ;
38061 PyObject * obj1 = 0 ;
38062 char * kwnames[] = {
38063 (char *) "self",(char *) "pt", NULL
38064 };
38065
38066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38068 if (!SWIG_IsOK(res1)) {
38069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38070 }
38071 arg1 = reinterpret_cast< wxWindow * >(argp1);
38072 {
38073 arg2 = &temp2;
38074 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38075 }
38076 {
38077 PyThreadState* __tstate = wxPyBeginAllowThreads();
38078 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38079 wxPyEndAllowThreads(__tstate);
38080 if (PyErr_Occurred()) SWIG_fail;
38081 }
38082 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38083 return resultobj;
38084 fail:
38085 return NULL;
38086 }
38087
38088
38089 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38090 PyObject *resultobj = 0;
38091 wxWindow *arg1 = (wxWindow *) 0 ;
38092 wxSize *arg2 = 0 ;
38093 wxSize result;
38094 void *argp1 = 0 ;
38095 int res1 = 0 ;
38096 wxSize temp2 ;
38097 PyObject * obj0 = 0 ;
38098 PyObject * obj1 = 0 ;
38099 char * kwnames[] = {
38100 (char *) "self",(char *) "sz", NULL
38101 };
38102
38103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38105 if (!SWIG_IsOK(res1)) {
38106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38107 }
38108 arg1 = reinterpret_cast< wxWindow * >(argp1);
38109 {
38110 arg2 = &temp2;
38111 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38112 }
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38127 PyObject *resultobj = 0;
38128 wxWindow *arg1 = (wxWindow *) 0 ;
38129 wxPoint *arg2 = 0 ;
38130 wxPoint result;
38131 void *argp1 = 0 ;
38132 int res1 = 0 ;
38133 wxPoint temp2 ;
38134 PyObject * obj0 = 0 ;
38135 PyObject * obj1 = 0 ;
38136 char * kwnames[] = {
38137 (char *) "self",(char *) "pt", NULL
38138 };
38139
38140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
38141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38142 if (!SWIG_IsOK(res1)) {
38143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
38144 }
38145 arg1 = reinterpret_cast< wxWindow * >(argp1);
38146 {
38147 arg2 = &temp2;
38148 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38149 }
38150 {
38151 PyThreadState* __tstate = wxPyBeginAllowThreads();
38152 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38153 wxPyEndAllowThreads(__tstate);
38154 if (PyErr_Occurred()) SWIG_fail;
38155 }
38156 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38157 return resultobj;
38158 fail:
38159 return NULL;
38160 }
38161
38162
38163 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38164 PyObject *resultobj = 0;
38165 wxWindow *arg1 = (wxWindow *) 0 ;
38166 wxSize *arg2 = 0 ;
38167 wxSize result;
38168 void *argp1 = 0 ;
38169 int res1 = 0 ;
38170 wxSize temp2 ;
38171 PyObject * obj0 = 0 ;
38172 PyObject * obj1 = 0 ;
38173 char * kwnames[] = {
38174 (char *) "self",(char *) "sz", NULL
38175 };
38176
38177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
38178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38179 if (!SWIG_IsOK(res1)) {
38180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
38181 }
38182 arg1 = reinterpret_cast< wxWindow * >(argp1);
38183 {
38184 arg2 = &temp2;
38185 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38186 }
38187 {
38188 PyThreadState* __tstate = wxPyBeginAllowThreads();
38189 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38190 wxPyEndAllowThreads(__tstate);
38191 if (PyErr_Occurred()) SWIG_fail;
38192 }
38193 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38194 return resultobj;
38195 fail:
38196 return NULL;
38197 }
38198
38199
38200 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38201 PyObject *resultobj = 0;
38202 wxWindow *arg1 = (wxWindow *) 0 ;
38203 wxPoint *arg2 = 0 ;
38204 wxPoint result;
38205 void *argp1 = 0 ;
38206 int res1 = 0 ;
38207 wxPoint temp2 ;
38208 PyObject * obj0 = 0 ;
38209 PyObject * obj1 = 0 ;
38210 char * kwnames[] = {
38211 (char *) "self",(char *) "pt", NULL
38212 };
38213
38214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38216 if (!SWIG_IsOK(res1)) {
38217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38218 }
38219 arg1 = reinterpret_cast< wxWindow * >(argp1);
38220 {
38221 arg2 = &temp2;
38222 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38223 }
38224 {
38225 PyThreadState* __tstate = wxPyBeginAllowThreads();
38226 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38231 return resultobj;
38232 fail:
38233 return NULL;
38234 }
38235
38236
38237 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38238 PyObject *resultobj = 0;
38239 wxWindow *arg1 = (wxWindow *) 0 ;
38240 wxSize *arg2 = 0 ;
38241 wxSize result;
38242 void *argp1 = 0 ;
38243 int res1 = 0 ;
38244 wxSize temp2 ;
38245 PyObject * obj0 = 0 ;
38246 PyObject * obj1 = 0 ;
38247 char * kwnames[] = {
38248 (char *) "self",(char *) "sz", NULL
38249 };
38250
38251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38253 if (!SWIG_IsOK(res1)) {
38254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38255 }
38256 arg1 = reinterpret_cast< wxWindow * >(argp1);
38257 {
38258 arg2 = &temp2;
38259 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38260 }
38261 {
38262 PyThreadState* __tstate = wxPyBeginAllowThreads();
38263 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
38264 wxPyEndAllowThreads(__tstate);
38265 if (PyErr_Occurred()) SWIG_fail;
38266 }
38267 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 int arg2 ;
38278 int arg3 ;
38279 void *argp1 = 0 ;
38280 int res1 = 0 ;
38281 int val2 ;
38282 int ecode2 = 0 ;
38283 int val3 ;
38284 int ecode3 = 0 ;
38285 PyObject * obj0 = 0 ;
38286 PyObject * obj1 = 0 ;
38287 PyObject * obj2 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "self",(char *) "x",(char *) "y", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38294 if (!SWIG_IsOK(res1)) {
38295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
38296 }
38297 arg1 = reinterpret_cast< wxWindow * >(argp1);
38298 ecode2 = SWIG_AsVal_int(obj1, &val2);
38299 if (!SWIG_IsOK(ecode2)) {
38300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
38301 }
38302 arg2 = static_cast< int >(val2);
38303 ecode3 = SWIG_AsVal_int(obj2, &val3);
38304 if (!SWIG_IsOK(ecode3)) {
38305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
38306 }
38307 arg3 = static_cast< int >(val3);
38308 {
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 (arg1)->WarpPointer(arg2,arg3);
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 resultobj = SWIG_Py_Void();
38315 return resultobj;
38316 fail:
38317 return NULL;
38318 }
38319
38320
38321 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38322 PyObject *resultobj = 0;
38323 wxWindow *arg1 = (wxWindow *) 0 ;
38324 void *argp1 = 0 ;
38325 int res1 = 0 ;
38326 PyObject *swig_obj[1] ;
38327
38328 if (!args) SWIG_fail;
38329 swig_obj[0] = args;
38330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38331 if (!SWIG_IsOK(res1)) {
38332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38333 }
38334 arg1 = reinterpret_cast< wxWindow * >(argp1);
38335 {
38336 PyThreadState* __tstate = wxPyBeginAllowThreads();
38337 (arg1)->CaptureMouse();
38338 wxPyEndAllowThreads(__tstate);
38339 if (PyErr_Occurred()) SWIG_fail;
38340 }
38341 resultobj = SWIG_Py_Void();
38342 return resultobj;
38343 fail:
38344 return NULL;
38345 }
38346
38347
38348 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38349 PyObject *resultobj = 0;
38350 wxWindow *arg1 = (wxWindow *) 0 ;
38351 void *argp1 = 0 ;
38352 int res1 = 0 ;
38353 PyObject *swig_obj[1] ;
38354
38355 if (!args) SWIG_fail;
38356 swig_obj[0] = args;
38357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38358 if (!SWIG_IsOK(res1)) {
38359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38360 }
38361 arg1 = reinterpret_cast< wxWindow * >(argp1);
38362 {
38363 PyThreadState* __tstate = wxPyBeginAllowThreads();
38364 (arg1)->ReleaseMouse();
38365 wxPyEndAllowThreads(__tstate);
38366 if (PyErr_Occurred()) SWIG_fail;
38367 }
38368 resultobj = SWIG_Py_Void();
38369 return resultobj;
38370 fail:
38371 return NULL;
38372 }
38373
38374
38375 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38376 PyObject *resultobj = 0;
38377 wxWindow *result = 0 ;
38378
38379 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
38380 {
38381 if (!wxPyCheckForApp()) SWIG_fail;
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (wxWindow *)wxWindow::GetCapture();
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 {
38388 resultobj = wxPyMake_wxObject(result, 0);
38389 }
38390 return resultobj;
38391 fail:
38392 return NULL;
38393 }
38394
38395
38396 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38397 PyObject *resultobj = 0;
38398 wxWindow *arg1 = (wxWindow *) 0 ;
38399 bool result;
38400 void *argp1 = 0 ;
38401 int res1 = 0 ;
38402 PyObject *swig_obj[1] ;
38403
38404 if (!args) SWIG_fail;
38405 swig_obj[0] = args;
38406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38407 if (!SWIG_IsOK(res1)) {
38408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
38409 }
38410 arg1 = reinterpret_cast< wxWindow * >(argp1);
38411 {
38412 PyThreadState* __tstate = wxPyBeginAllowThreads();
38413 result = (bool)((wxWindow const *)arg1)->HasCapture();
38414 wxPyEndAllowThreads(__tstate);
38415 if (PyErr_Occurred()) SWIG_fail;
38416 }
38417 {
38418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38419 }
38420 return resultobj;
38421 fail:
38422 return NULL;
38423 }
38424
38425
38426 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38427 PyObject *resultobj = 0;
38428 wxWindow *arg1 = (wxWindow *) 0 ;
38429 bool arg2 = (bool) true ;
38430 wxRect *arg3 = (wxRect *) NULL ;
38431 void *argp1 = 0 ;
38432 int res1 = 0 ;
38433 bool val2 ;
38434 int ecode2 = 0 ;
38435 void *argp3 = 0 ;
38436 int res3 = 0 ;
38437 PyObject * obj0 = 0 ;
38438 PyObject * obj1 = 0 ;
38439 PyObject * obj2 = 0 ;
38440 char * kwnames[] = {
38441 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
38442 };
38443
38444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38446 if (!SWIG_IsOK(res1)) {
38447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
38448 }
38449 arg1 = reinterpret_cast< wxWindow * >(argp1);
38450 if (obj1) {
38451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38452 if (!SWIG_IsOK(ecode2)) {
38453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
38454 }
38455 arg2 = static_cast< bool >(val2);
38456 }
38457 if (obj2) {
38458 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
38459 if (!SWIG_IsOK(res3)) {
38460 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
38461 }
38462 arg3 = reinterpret_cast< wxRect * >(argp3);
38463 }
38464 {
38465 PyThreadState* __tstate = wxPyBeginAllowThreads();
38466 (arg1)->Refresh(arg2,(wxRect const *)arg3);
38467 wxPyEndAllowThreads(__tstate);
38468 if (PyErr_Occurred()) SWIG_fail;
38469 }
38470 resultobj = SWIG_Py_Void();
38471 return resultobj;
38472 fail:
38473 return NULL;
38474 }
38475
38476
38477 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38478 PyObject *resultobj = 0;
38479 wxWindow *arg1 = (wxWindow *) 0 ;
38480 wxRect *arg2 = 0 ;
38481 bool arg3 = (bool) true ;
38482 void *argp1 = 0 ;
38483 int res1 = 0 ;
38484 wxRect temp2 ;
38485 bool val3 ;
38486 int ecode3 = 0 ;
38487 PyObject * obj0 = 0 ;
38488 PyObject * obj1 = 0 ;
38489 PyObject * obj2 = 0 ;
38490 char * kwnames[] = {
38491 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38492 };
38493
38494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38496 if (!SWIG_IsOK(res1)) {
38497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38498 }
38499 arg1 = reinterpret_cast< wxWindow * >(argp1);
38500 {
38501 arg2 = &temp2;
38502 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38503 }
38504 if (obj2) {
38505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38506 if (!SWIG_IsOK(ecode3)) {
38507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38508 }
38509 arg3 = static_cast< bool >(val3);
38510 }
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38514 wxPyEndAllowThreads(__tstate);
38515 if (PyErr_Occurred()) SWIG_fail;
38516 }
38517 resultobj = SWIG_Py_Void();
38518 return resultobj;
38519 fail:
38520 return NULL;
38521 }
38522
38523
38524 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38525 PyObject *resultobj = 0;
38526 wxWindow *arg1 = (wxWindow *) 0 ;
38527 void *argp1 = 0 ;
38528 int res1 = 0 ;
38529 PyObject *swig_obj[1] ;
38530
38531 if (!args) SWIG_fail;
38532 swig_obj[0] = args;
38533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38536 }
38537 arg1 = reinterpret_cast< wxWindow * >(argp1);
38538 {
38539 PyThreadState* __tstate = wxPyBeginAllowThreads();
38540 (arg1)->Update();
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 resultobj = SWIG_Py_Void();
38545 return resultobj;
38546 fail:
38547 return NULL;
38548 }
38549
38550
38551 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38552 PyObject *resultobj = 0;
38553 wxWindow *arg1 = (wxWindow *) 0 ;
38554 void *argp1 = 0 ;
38555 int res1 = 0 ;
38556 PyObject *swig_obj[1] ;
38557
38558 if (!args) SWIG_fail;
38559 swig_obj[0] = args;
38560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38561 if (!SWIG_IsOK(res1)) {
38562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38563 }
38564 arg1 = reinterpret_cast< wxWindow * >(argp1);
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->ClearBackground();
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 resultobj = SWIG_Py_Void();
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38579 PyObject *resultobj = 0;
38580 wxWindow *arg1 = (wxWindow *) 0 ;
38581 void *argp1 = 0 ;
38582 int res1 = 0 ;
38583 PyObject *swig_obj[1] ;
38584
38585 if (!args) SWIG_fail;
38586 swig_obj[0] = args;
38587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38588 if (!SWIG_IsOK(res1)) {
38589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38590 }
38591 arg1 = reinterpret_cast< wxWindow * >(argp1);
38592 {
38593 PyThreadState* __tstate = wxPyBeginAllowThreads();
38594 (arg1)->Freeze();
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 resultobj = SWIG_Py_Void();
38599 return resultobj;
38600 fail:
38601 return NULL;
38602 }
38603
38604
38605 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38606 PyObject *resultobj = 0;
38607 wxWindow *arg1 = (wxWindow *) 0 ;
38608 bool result;
38609 void *argp1 = 0 ;
38610 int res1 = 0 ;
38611 PyObject *swig_obj[1] ;
38612
38613 if (!args) SWIG_fail;
38614 swig_obj[0] = args;
38615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38616 if (!SWIG_IsOK(res1)) {
38617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38618 }
38619 arg1 = reinterpret_cast< wxWindow * >(argp1);
38620 {
38621 PyThreadState* __tstate = wxPyBeginAllowThreads();
38622 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38623 wxPyEndAllowThreads(__tstate);
38624 if (PyErr_Occurred()) SWIG_fail;
38625 }
38626 {
38627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38628 }
38629 return resultobj;
38630 fail:
38631 return NULL;
38632 }
38633
38634
38635 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38636 PyObject *resultobj = 0;
38637 wxWindow *arg1 = (wxWindow *) 0 ;
38638 void *argp1 = 0 ;
38639 int res1 = 0 ;
38640 PyObject *swig_obj[1] ;
38641
38642 if (!args) SWIG_fail;
38643 swig_obj[0] = args;
38644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38645 if (!SWIG_IsOK(res1)) {
38646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38647 }
38648 arg1 = reinterpret_cast< wxWindow * >(argp1);
38649 {
38650 PyThreadState* __tstate = wxPyBeginAllowThreads();
38651 (arg1)->Thaw();
38652 wxPyEndAllowThreads(__tstate);
38653 if (PyErr_Occurred()) SWIG_fail;
38654 }
38655 resultobj = SWIG_Py_Void();
38656 return resultobj;
38657 fail:
38658 return NULL;
38659 }
38660
38661
38662 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38663 PyObject *resultobj = 0;
38664 wxWindow *arg1 = (wxWindow *) 0 ;
38665 wxDC *arg2 = 0 ;
38666 void *argp1 = 0 ;
38667 int res1 = 0 ;
38668 void *argp2 = 0 ;
38669 int res2 = 0 ;
38670 PyObject * obj0 = 0 ;
38671 PyObject * obj1 = 0 ;
38672 char * kwnames[] = {
38673 (char *) "self",(char *) "dc", NULL
38674 };
38675
38676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38678 if (!SWIG_IsOK(res1)) {
38679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38680 }
38681 arg1 = reinterpret_cast< wxWindow * >(argp1);
38682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38683 if (!SWIG_IsOK(res2)) {
38684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38685 }
38686 if (!argp2) {
38687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38688 }
38689 arg2 = reinterpret_cast< wxDC * >(argp2);
38690 {
38691 PyThreadState* __tstate = wxPyBeginAllowThreads();
38692 (arg1)->PrepareDC(*arg2);
38693 wxPyEndAllowThreads(__tstate);
38694 if (PyErr_Occurred()) SWIG_fail;
38695 }
38696 resultobj = SWIG_Py_Void();
38697 return resultobj;
38698 fail:
38699 return NULL;
38700 }
38701
38702
38703 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38704 PyObject *resultobj = 0;
38705 wxWindow *arg1 = (wxWindow *) 0 ;
38706 bool result;
38707 void *argp1 = 0 ;
38708 int res1 = 0 ;
38709 PyObject *swig_obj[1] ;
38710
38711 if (!args) SWIG_fail;
38712 swig_obj[0] = args;
38713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38714 if (!SWIG_IsOK(res1)) {
38715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38716 }
38717 arg1 = reinterpret_cast< wxWindow * >(argp1);
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 {
38725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38726 }
38727 return resultobj;
38728 fail:
38729 return NULL;
38730 }
38731
38732
38733 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38734 PyObject *resultobj = 0;
38735 wxWindow *arg1 = (wxWindow *) 0 ;
38736 wxRegion *result = 0 ;
38737 void *argp1 = 0 ;
38738 int res1 = 0 ;
38739 PyObject *swig_obj[1] ;
38740
38741 if (!args) SWIG_fail;
38742 swig_obj[0] = args;
38743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38744 if (!SWIG_IsOK(res1)) {
38745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38746 }
38747 arg1 = reinterpret_cast< wxWindow * >(argp1);
38748 {
38749 PyThreadState* __tstate = wxPyBeginAllowThreads();
38750 {
38751 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38752 result = (wxRegion *) &_result_ref;
38753 }
38754 wxPyEndAllowThreads(__tstate);
38755 if (PyErr_Occurred()) SWIG_fail;
38756 }
38757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38765 PyObject *resultobj = 0;
38766 wxWindow *arg1 = (wxWindow *) 0 ;
38767 wxRect result;
38768 void *argp1 = 0 ;
38769 int res1 = 0 ;
38770 PyObject *swig_obj[1] ;
38771
38772 if (!args) SWIG_fail;
38773 swig_obj[0] = args;
38774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38775 if (!SWIG_IsOK(res1)) {
38776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38777 }
38778 arg1 = reinterpret_cast< wxWindow * >(argp1);
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38782 wxPyEndAllowThreads(__tstate);
38783 if (PyErr_Occurred()) SWIG_fail;
38784 }
38785 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38786 return resultobj;
38787 fail:
38788 return NULL;
38789 }
38790
38791
38792 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38793 PyObject *resultobj = 0;
38794 wxWindow *arg1 = (wxWindow *) 0 ;
38795 int arg2 ;
38796 int arg3 ;
38797 int arg4 = (int) 1 ;
38798 int arg5 = (int) 1 ;
38799 bool result;
38800 void *argp1 = 0 ;
38801 int res1 = 0 ;
38802 int val2 ;
38803 int ecode2 = 0 ;
38804 int val3 ;
38805 int ecode3 = 0 ;
38806 int val4 ;
38807 int ecode4 = 0 ;
38808 int val5 ;
38809 int ecode5 = 0 ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 PyObject * obj2 = 0 ;
38813 PyObject * obj3 = 0 ;
38814 PyObject * obj4 = 0 ;
38815 char * kwnames[] = {
38816 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38817 };
38818
38819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38821 if (!SWIG_IsOK(res1)) {
38822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38823 }
38824 arg1 = reinterpret_cast< wxWindow * >(argp1);
38825 ecode2 = SWIG_AsVal_int(obj1, &val2);
38826 if (!SWIG_IsOK(ecode2)) {
38827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38828 }
38829 arg2 = static_cast< int >(val2);
38830 ecode3 = SWIG_AsVal_int(obj2, &val3);
38831 if (!SWIG_IsOK(ecode3)) {
38832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38833 }
38834 arg3 = static_cast< int >(val3);
38835 if (obj3) {
38836 ecode4 = SWIG_AsVal_int(obj3, &val4);
38837 if (!SWIG_IsOK(ecode4)) {
38838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38839 }
38840 arg4 = static_cast< int >(val4);
38841 }
38842 if (obj4) {
38843 ecode5 = SWIG_AsVal_int(obj4, &val5);
38844 if (!SWIG_IsOK(ecode5)) {
38845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38846 }
38847 arg5 = static_cast< int >(val5);
38848 }
38849 {
38850 PyThreadState* __tstate = wxPyBeginAllowThreads();
38851 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38852 wxPyEndAllowThreads(__tstate);
38853 if (PyErr_Occurred()) SWIG_fail;
38854 }
38855 {
38856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38857 }
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj = 0;
38866 wxWindow *arg1 = (wxWindow *) 0 ;
38867 wxPoint *arg2 = 0 ;
38868 bool result;
38869 void *argp1 = 0 ;
38870 int res1 = 0 ;
38871 wxPoint temp2 ;
38872 PyObject * obj0 = 0 ;
38873 PyObject * obj1 = 0 ;
38874 char * kwnames[] = {
38875 (char *) "self",(char *) "pt", NULL
38876 };
38877
38878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38880 if (!SWIG_IsOK(res1)) {
38881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38882 }
38883 arg1 = reinterpret_cast< wxWindow * >(argp1);
38884 {
38885 arg2 = &temp2;
38886 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38887 }
38888 {
38889 PyThreadState* __tstate = wxPyBeginAllowThreads();
38890 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 {
38895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38896 }
38897 return resultobj;
38898 fail:
38899 return NULL;
38900 }
38901
38902
38903 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38904 PyObject *resultobj = 0;
38905 wxWindow *arg1 = (wxWindow *) 0 ;
38906 wxRect *arg2 = 0 ;
38907 bool result;
38908 void *argp1 = 0 ;
38909 int res1 = 0 ;
38910 wxRect temp2 ;
38911 PyObject * obj0 = 0 ;
38912 PyObject * obj1 = 0 ;
38913 char * kwnames[] = {
38914 (char *) "self",(char *) "rect", NULL
38915 };
38916
38917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38919 if (!SWIG_IsOK(res1)) {
38920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38921 }
38922 arg1 = reinterpret_cast< wxWindow * >(argp1);
38923 {
38924 arg2 = &temp2;
38925 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38926 }
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 {
38934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38935 }
38936 return resultobj;
38937 fail:
38938 return NULL;
38939 }
38940
38941
38942 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38943 PyObject *resultobj = 0;
38944 wxWindow *arg1 = (wxWindow *) 0 ;
38945 SwigValueWrapper<wxVisualAttributes > result;
38946 void *argp1 = 0 ;
38947 int res1 = 0 ;
38948 PyObject *swig_obj[1] ;
38949
38950 if (!args) SWIG_fail;
38951 swig_obj[0] = args;
38952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38953 if (!SWIG_IsOK(res1)) {
38954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38955 }
38956 arg1 = reinterpret_cast< wxWindow * >(argp1);
38957 {
38958 PyThreadState* __tstate = wxPyBeginAllowThreads();
38959 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38960 wxPyEndAllowThreads(__tstate);
38961 if (PyErr_Occurred()) SWIG_fail;
38962 }
38963 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38964 return resultobj;
38965 fail:
38966 return NULL;
38967 }
38968
38969
38970 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38971 PyObject *resultobj = 0;
38972 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38973 SwigValueWrapper<wxVisualAttributes > result;
38974 int val1 ;
38975 int ecode1 = 0 ;
38976 PyObject * obj0 = 0 ;
38977 char * kwnames[] = {
38978 (char *) "variant", NULL
38979 };
38980
38981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38982 if (obj0) {
38983 ecode1 = SWIG_AsVal_int(obj0, &val1);
38984 if (!SWIG_IsOK(ecode1)) {
38985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38986 }
38987 arg1 = static_cast< wxWindowVariant >(val1);
38988 }
38989 {
38990 if (!wxPyCheckForApp()) SWIG_fail;
38991 PyThreadState* __tstate = wxPyBeginAllowThreads();
38992 result = wxWindow::GetClassDefaultAttributes(arg1);
38993 wxPyEndAllowThreads(__tstate);
38994 if (PyErr_Occurred()) SWIG_fail;
38995 }
38996 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38997 return resultobj;
38998 fail:
38999 return NULL;
39000 }
39001
39002
39003 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39004 PyObject *resultobj = 0;
39005 wxWindow *arg1 = (wxWindow *) 0 ;
39006 wxColour *arg2 = 0 ;
39007 bool result;
39008 void *argp1 = 0 ;
39009 int res1 = 0 ;
39010 wxColour temp2 ;
39011 PyObject * obj0 = 0 ;
39012 PyObject * obj1 = 0 ;
39013 char * kwnames[] = {
39014 (char *) "self",(char *) "colour", NULL
39015 };
39016
39017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39019 if (!SWIG_IsOK(res1)) {
39020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39021 }
39022 arg1 = reinterpret_cast< wxWindow * >(argp1);
39023 {
39024 arg2 = &temp2;
39025 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39026 }
39027 {
39028 PyThreadState* __tstate = wxPyBeginAllowThreads();
39029 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
39030 wxPyEndAllowThreads(__tstate);
39031 if (PyErr_Occurred()) SWIG_fail;
39032 }
39033 {
39034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39035 }
39036 return resultobj;
39037 fail:
39038 return NULL;
39039 }
39040
39041
39042 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39043 PyObject *resultobj = 0;
39044 wxWindow *arg1 = (wxWindow *) 0 ;
39045 wxColour *arg2 = 0 ;
39046 void *argp1 = 0 ;
39047 int res1 = 0 ;
39048 wxColour temp2 ;
39049 PyObject * obj0 = 0 ;
39050 PyObject * obj1 = 0 ;
39051 char * kwnames[] = {
39052 (char *) "self",(char *) "colour", NULL
39053 };
39054
39055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39057 if (!SWIG_IsOK(res1)) {
39058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39059 }
39060 arg1 = reinterpret_cast< wxWindow * >(argp1);
39061 {
39062 arg2 = &temp2;
39063 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39064 }
39065 {
39066 PyThreadState* __tstate = wxPyBeginAllowThreads();
39067 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
39068 wxPyEndAllowThreads(__tstate);
39069 if (PyErr_Occurred()) SWIG_fail;
39070 }
39071 resultobj = SWIG_Py_Void();
39072 return resultobj;
39073 fail:
39074 return NULL;
39075 }
39076
39077
39078 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj = 0;
39080 wxWindow *arg1 = (wxWindow *) 0 ;
39081 wxColour *arg2 = 0 ;
39082 bool result;
39083 void *argp1 = 0 ;
39084 int res1 = 0 ;
39085 wxColour temp2 ;
39086 PyObject * obj0 = 0 ;
39087 PyObject * obj1 = 0 ;
39088 char * kwnames[] = {
39089 (char *) "self",(char *) "colour", NULL
39090 };
39091
39092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39094 if (!SWIG_IsOK(res1)) {
39095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39096 }
39097 arg1 = reinterpret_cast< wxWindow * >(argp1);
39098 {
39099 arg2 = &temp2;
39100 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39101 }
39102 {
39103 PyThreadState* __tstate = wxPyBeginAllowThreads();
39104 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
39105 wxPyEndAllowThreads(__tstate);
39106 if (PyErr_Occurred()) SWIG_fail;
39107 }
39108 {
39109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39110 }
39111 return resultobj;
39112 fail:
39113 return NULL;
39114 }
39115
39116
39117 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39118 PyObject *resultobj = 0;
39119 wxWindow *arg1 = (wxWindow *) 0 ;
39120 wxColour *arg2 = 0 ;
39121 void *argp1 = 0 ;
39122 int res1 = 0 ;
39123 wxColour temp2 ;
39124 PyObject * obj0 = 0 ;
39125 PyObject * obj1 = 0 ;
39126 char * kwnames[] = {
39127 (char *) "self",(char *) "colour", NULL
39128 };
39129
39130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39132 if (!SWIG_IsOK(res1)) {
39133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39134 }
39135 arg1 = reinterpret_cast< wxWindow * >(argp1);
39136 {
39137 arg2 = &temp2;
39138 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39139 }
39140 {
39141 PyThreadState* __tstate = wxPyBeginAllowThreads();
39142 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
39143 wxPyEndAllowThreads(__tstate);
39144 if (PyErr_Occurred()) SWIG_fail;
39145 }
39146 resultobj = SWIG_Py_Void();
39147 return resultobj;
39148 fail:
39149 return NULL;
39150 }
39151
39152
39153 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39154 PyObject *resultobj = 0;
39155 wxWindow *arg1 = (wxWindow *) 0 ;
39156 wxColour result;
39157 void *argp1 = 0 ;
39158 int res1 = 0 ;
39159 PyObject *swig_obj[1] ;
39160
39161 if (!args) SWIG_fail;
39162 swig_obj[0] = args;
39163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39164 if (!SWIG_IsOK(res1)) {
39165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39166 }
39167 arg1 = reinterpret_cast< wxWindow * >(argp1);
39168 {
39169 PyThreadState* __tstate = wxPyBeginAllowThreads();
39170 result = ((wxWindow const *)arg1)->GetBackgroundColour();
39171 wxPyEndAllowThreads(__tstate);
39172 if (PyErr_Occurred()) SWIG_fail;
39173 }
39174 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39175 return resultobj;
39176 fail:
39177 return NULL;
39178 }
39179
39180
39181 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39182 PyObject *resultobj = 0;
39183 wxWindow *arg1 = (wxWindow *) 0 ;
39184 wxColour result;
39185 void *argp1 = 0 ;
39186 int res1 = 0 ;
39187 PyObject *swig_obj[1] ;
39188
39189 if (!args) SWIG_fail;
39190 swig_obj[0] = args;
39191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39192 if (!SWIG_IsOK(res1)) {
39193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39194 }
39195 arg1 = reinterpret_cast< wxWindow * >(argp1);
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 result = ((wxWindow const *)arg1)->GetForegroundColour();
39199 wxPyEndAllowThreads(__tstate);
39200 if (PyErr_Occurred()) SWIG_fail;
39201 }
39202 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39203 return resultobj;
39204 fail:
39205 return NULL;
39206 }
39207
39208
39209 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39210 PyObject *resultobj = 0;
39211 wxWindow *arg1 = (wxWindow *) 0 ;
39212 bool result;
39213 void *argp1 = 0 ;
39214 int res1 = 0 ;
39215 PyObject *swig_obj[1] ;
39216
39217 if (!args) SWIG_fail;
39218 swig_obj[0] = args;
39219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39220 if (!SWIG_IsOK(res1)) {
39221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39222 }
39223 arg1 = reinterpret_cast< wxWindow * >(argp1);
39224 {
39225 PyThreadState* __tstate = wxPyBeginAllowThreads();
39226 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 {
39231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39232 }
39233 return resultobj;
39234 fail:
39235 return NULL;
39236 }
39237
39238
39239 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39240 PyObject *resultobj = 0;
39241 wxWindow *arg1 = (wxWindow *) 0 ;
39242 bool result;
39243 void *argp1 = 0 ;
39244 int res1 = 0 ;
39245 PyObject *swig_obj[1] ;
39246
39247 if (!args) SWIG_fail;
39248 swig_obj[0] = args;
39249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39250 if (!SWIG_IsOK(res1)) {
39251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
39252 }
39253 arg1 = reinterpret_cast< wxWindow * >(argp1);
39254 {
39255 PyThreadState* __tstate = wxPyBeginAllowThreads();
39256 result = (bool)((wxWindow const *)arg1)->UseBgCol();
39257 wxPyEndAllowThreads(__tstate);
39258 if (PyErr_Occurred()) SWIG_fail;
39259 }
39260 {
39261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39262 }
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj = 0;
39271 wxWindow *arg1 = (wxWindow *) 0 ;
39272 wxBackgroundStyle arg2 ;
39273 bool result;
39274 void *argp1 = 0 ;
39275 int res1 = 0 ;
39276 int val2 ;
39277 int ecode2 = 0 ;
39278 PyObject * obj0 = 0 ;
39279 PyObject * obj1 = 0 ;
39280 char * kwnames[] = {
39281 (char *) "self",(char *) "style", NULL
39282 };
39283
39284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
39285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39286 if (!SWIG_IsOK(res1)) {
39287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
39288 }
39289 arg1 = reinterpret_cast< wxWindow * >(argp1);
39290 ecode2 = SWIG_AsVal_int(obj1, &val2);
39291 if (!SWIG_IsOK(ecode2)) {
39292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
39293 }
39294 arg2 = static_cast< wxBackgroundStyle >(val2);
39295 {
39296 PyThreadState* __tstate = wxPyBeginAllowThreads();
39297 result = (bool)(arg1)->SetBackgroundStyle(arg2);
39298 wxPyEndAllowThreads(__tstate);
39299 if (PyErr_Occurred()) SWIG_fail;
39300 }
39301 {
39302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39303 }
39304 return resultobj;
39305 fail:
39306 return NULL;
39307 }
39308
39309
39310 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39311 PyObject *resultobj = 0;
39312 wxWindow *arg1 = (wxWindow *) 0 ;
39313 wxBackgroundStyle result;
39314 void *argp1 = 0 ;
39315 int res1 = 0 ;
39316 PyObject *swig_obj[1] ;
39317
39318 if (!args) SWIG_fail;
39319 swig_obj[0] = args;
39320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39321 if (!SWIG_IsOK(res1)) {
39322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
39323 }
39324 arg1 = reinterpret_cast< wxWindow * >(argp1);
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 resultobj = SWIG_From_int(static_cast< int >(result));
39332 return resultobj;
39333 fail:
39334 return NULL;
39335 }
39336
39337
39338 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39339 PyObject *resultobj = 0;
39340 wxWindow *arg1 = (wxWindow *) 0 ;
39341 bool result;
39342 void *argp1 = 0 ;
39343 int res1 = 0 ;
39344 PyObject *swig_obj[1] ;
39345
39346 if (!args) SWIG_fail;
39347 swig_obj[0] = args;
39348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39349 if (!SWIG_IsOK(res1)) {
39350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
39351 }
39352 arg1 = reinterpret_cast< wxWindow * >(argp1);
39353 {
39354 PyThreadState* __tstate = wxPyBeginAllowThreads();
39355 result = (bool)(arg1)->HasTransparentBackground();
39356 wxPyEndAllowThreads(__tstate);
39357 if (PyErr_Occurred()) SWIG_fail;
39358 }
39359 {
39360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39361 }
39362 return resultobj;
39363 fail:
39364 return NULL;
39365 }
39366
39367
39368 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39369 PyObject *resultobj = 0;
39370 wxWindow *arg1 = (wxWindow *) 0 ;
39371 wxCursor *arg2 = 0 ;
39372 bool result;
39373 void *argp1 = 0 ;
39374 int res1 = 0 ;
39375 void *argp2 = 0 ;
39376 int res2 = 0 ;
39377 PyObject * obj0 = 0 ;
39378 PyObject * obj1 = 0 ;
39379 char * kwnames[] = {
39380 (char *) "self",(char *) "cursor", NULL
39381 };
39382
39383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
39384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39385 if (!SWIG_IsOK(res1)) {
39386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39387 }
39388 arg1 = reinterpret_cast< wxWindow * >(argp1);
39389 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
39390 if (!SWIG_IsOK(res2)) {
39391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39392 }
39393 if (!argp2) {
39394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39395 }
39396 arg2 = reinterpret_cast< wxCursor * >(argp2);
39397 {
39398 PyThreadState* __tstate = wxPyBeginAllowThreads();
39399 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
39400 wxPyEndAllowThreads(__tstate);
39401 if (PyErr_Occurred()) SWIG_fail;
39402 }
39403 {
39404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39405 }
39406 return resultobj;
39407 fail:
39408 return NULL;
39409 }
39410
39411
39412 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39413 PyObject *resultobj = 0;
39414 wxWindow *arg1 = (wxWindow *) 0 ;
39415 wxCursor result;
39416 void *argp1 = 0 ;
39417 int res1 = 0 ;
39418 PyObject *swig_obj[1] ;
39419
39420 if (!args) SWIG_fail;
39421 swig_obj[0] = args;
39422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39423 if (!SWIG_IsOK(res1)) {
39424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39425 }
39426 arg1 = reinterpret_cast< wxWindow * >(argp1);
39427 {
39428 PyThreadState* __tstate = wxPyBeginAllowThreads();
39429 result = (arg1)->GetCursor();
39430 wxPyEndAllowThreads(__tstate);
39431 if (PyErr_Occurred()) SWIG_fail;
39432 }
39433 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
39434 return resultobj;
39435 fail:
39436 return NULL;
39437 }
39438
39439
39440 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39441 PyObject *resultobj = 0;
39442 wxWindow *arg1 = (wxWindow *) 0 ;
39443 wxFont *arg2 = 0 ;
39444 bool result;
39445 void *argp1 = 0 ;
39446 int res1 = 0 ;
39447 void *argp2 = 0 ;
39448 int res2 = 0 ;
39449 PyObject * obj0 = 0 ;
39450 PyObject * obj1 = 0 ;
39451 char * kwnames[] = {
39452 (char *) "self",(char *) "font", NULL
39453 };
39454
39455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
39456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39457 if (!SWIG_IsOK(res1)) {
39458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39459 }
39460 arg1 = reinterpret_cast< wxWindow * >(argp1);
39461 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39462 if (!SWIG_IsOK(res2)) {
39463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39464 }
39465 if (!argp2) {
39466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39467 }
39468 arg2 = reinterpret_cast< wxFont * >(argp2);
39469 {
39470 PyThreadState* __tstate = wxPyBeginAllowThreads();
39471 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 {
39476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39477 }
39478 return resultobj;
39479 fail:
39480 return NULL;
39481 }
39482
39483
39484 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39485 PyObject *resultobj = 0;
39486 wxWindow *arg1 = (wxWindow *) 0 ;
39487 wxFont *arg2 = 0 ;
39488 void *argp1 = 0 ;
39489 int res1 = 0 ;
39490 void *argp2 = 0 ;
39491 int res2 = 0 ;
39492 PyObject * obj0 = 0 ;
39493 PyObject * obj1 = 0 ;
39494 char * kwnames[] = {
39495 (char *) "self",(char *) "font", NULL
39496 };
39497
39498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39500 if (!SWIG_IsOK(res1)) {
39501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39502 }
39503 arg1 = reinterpret_cast< wxWindow * >(argp1);
39504 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39505 if (!SWIG_IsOK(res2)) {
39506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39507 }
39508 if (!argp2) {
39509 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39510 }
39511 arg2 = reinterpret_cast< wxFont * >(argp2);
39512 {
39513 PyThreadState* __tstate = wxPyBeginAllowThreads();
39514 (arg1)->SetOwnFont((wxFont const &)*arg2);
39515 wxPyEndAllowThreads(__tstate);
39516 if (PyErr_Occurred()) SWIG_fail;
39517 }
39518 resultobj = SWIG_Py_Void();
39519 return resultobj;
39520 fail:
39521 return NULL;
39522 }
39523
39524
39525 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39526 PyObject *resultobj = 0;
39527 wxWindow *arg1 = (wxWindow *) 0 ;
39528 wxFont result;
39529 void *argp1 = 0 ;
39530 int res1 = 0 ;
39531 PyObject *swig_obj[1] ;
39532
39533 if (!args) SWIG_fail;
39534 swig_obj[0] = args;
39535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39536 if (!SWIG_IsOK(res1)) {
39537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39538 }
39539 arg1 = reinterpret_cast< wxWindow * >(argp1);
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 result = (arg1)->GetFont();
39543 wxPyEndAllowThreads(__tstate);
39544 if (PyErr_Occurred()) SWIG_fail;
39545 }
39546 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39547 return resultobj;
39548 fail:
39549 return NULL;
39550 }
39551
39552
39553 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39554 PyObject *resultobj = 0;
39555 wxWindow *arg1 = (wxWindow *) 0 ;
39556 wxCaret *arg2 = (wxCaret *) 0 ;
39557 void *argp1 = 0 ;
39558 int res1 = 0 ;
39559 int res2 = 0 ;
39560 PyObject * obj0 = 0 ;
39561 PyObject * obj1 = 0 ;
39562 char * kwnames[] = {
39563 (char *) "self",(char *) "caret", NULL
39564 };
39565
39566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39568 if (!SWIG_IsOK(res1)) {
39569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39570 }
39571 arg1 = reinterpret_cast< wxWindow * >(argp1);
39572 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39573 if (!SWIG_IsOK(res2)) {
39574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39575 }
39576 {
39577 PyThreadState* __tstate = wxPyBeginAllowThreads();
39578 (arg1)->SetCaret(arg2);
39579 wxPyEndAllowThreads(__tstate);
39580 if (PyErr_Occurred()) SWIG_fail;
39581 }
39582 resultobj = SWIG_Py_Void();
39583 return resultobj;
39584 fail:
39585 return NULL;
39586 }
39587
39588
39589 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39590 PyObject *resultobj = 0;
39591 wxWindow *arg1 = (wxWindow *) 0 ;
39592 wxCaret *result = 0 ;
39593 void *argp1 = 0 ;
39594 int res1 = 0 ;
39595 PyObject *swig_obj[1] ;
39596
39597 if (!args) SWIG_fail;
39598 swig_obj[0] = args;
39599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39600 if (!SWIG_IsOK(res1)) {
39601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39602 }
39603 arg1 = reinterpret_cast< wxWindow * >(argp1);
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39607 wxPyEndAllowThreads(__tstate);
39608 if (PyErr_Occurred()) SWIG_fail;
39609 }
39610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39618 PyObject *resultobj = 0;
39619 wxWindow *arg1 = (wxWindow *) 0 ;
39620 int result;
39621 void *argp1 = 0 ;
39622 int res1 = 0 ;
39623 PyObject *swig_obj[1] ;
39624
39625 if (!args) SWIG_fail;
39626 swig_obj[0] = args;
39627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39628 if (!SWIG_IsOK(res1)) {
39629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39630 }
39631 arg1 = reinterpret_cast< wxWindow * >(argp1);
39632 {
39633 PyThreadState* __tstate = wxPyBeginAllowThreads();
39634 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39635 wxPyEndAllowThreads(__tstate);
39636 if (PyErr_Occurred()) SWIG_fail;
39637 }
39638 resultobj = SWIG_From_int(static_cast< int >(result));
39639 return resultobj;
39640 fail:
39641 return NULL;
39642 }
39643
39644
39645 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39646 PyObject *resultobj = 0;
39647 wxWindow *arg1 = (wxWindow *) 0 ;
39648 int result;
39649 void *argp1 = 0 ;
39650 int res1 = 0 ;
39651 PyObject *swig_obj[1] ;
39652
39653 if (!args) SWIG_fail;
39654 swig_obj[0] = args;
39655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39656 if (!SWIG_IsOK(res1)) {
39657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39658 }
39659 arg1 = reinterpret_cast< wxWindow * >(argp1);
39660 {
39661 PyThreadState* __tstate = wxPyBeginAllowThreads();
39662 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39663 wxPyEndAllowThreads(__tstate);
39664 if (PyErr_Occurred()) SWIG_fail;
39665 }
39666 resultobj = SWIG_From_int(static_cast< int >(result));
39667 return resultobj;
39668 fail:
39669 return NULL;
39670 }
39671
39672
39673 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39674 PyObject *resultobj = 0;
39675 wxWindow *arg1 = (wxWindow *) 0 ;
39676 wxString *arg2 = 0 ;
39677 int *arg3 = (int *) 0 ;
39678 int *arg4 = (int *) 0 ;
39679 void *argp1 = 0 ;
39680 int res1 = 0 ;
39681 bool temp2 = false ;
39682 int temp3 ;
39683 int res3 = SWIG_TMPOBJ ;
39684 int temp4 ;
39685 int res4 = SWIG_TMPOBJ ;
39686 PyObject * obj0 = 0 ;
39687 PyObject * obj1 = 0 ;
39688 char * kwnames[] = {
39689 (char *) "self",(char *) "string", NULL
39690 };
39691
39692 arg3 = &temp3;
39693 arg4 = &temp4;
39694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39696 if (!SWIG_IsOK(res1)) {
39697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39698 }
39699 arg1 = reinterpret_cast< wxWindow * >(argp1);
39700 {
39701 arg2 = wxString_in_helper(obj1);
39702 if (arg2 == NULL) SWIG_fail;
39703 temp2 = true;
39704 }
39705 {
39706 PyThreadState* __tstate = wxPyBeginAllowThreads();
39707 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39708 wxPyEndAllowThreads(__tstate);
39709 if (PyErr_Occurred()) SWIG_fail;
39710 }
39711 resultobj = SWIG_Py_Void();
39712 if (SWIG_IsTmpObj(res3)) {
39713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39714 } else {
39715 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39717 }
39718 if (SWIG_IsTmpObj(res4)) {
39719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39720 } else {
39721 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39723 }
39724 {
39725 if (temp2)
39726 delete arg2;
39727 }
39728 return resultobj;
39729 fail:
39730 {
39731 if (temp2)
39732 delete arg2;
39733 }
39734 return NULL;
39735 }
39736
39737
39738 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj = 0;
39740 wxWindow *arg1 = (wxWindow *) 0 ;
39741 wxString *arg2 = 0 ;
39742 int *arg3 = (int *) 0 ;
39743 int *arg4 = (int *) 0 ;
39744 int *arg5 = (int *) 0 ;
39745 int *arg6 = (int *) 0 ;
39746 wxFont *arg7 = (wxFont *) NULL ;
39747 void *argp1 = 0 ;
39748 int res1 = 0 ;
39749 bool temp2 = false ;
39750 int temp3 ;
39751 int res3 = SWIG_TMPOBJ ;
39752 int temp4 ;
39753 int res4 = SWIG_TMPOBJ ;
39754 int temp5 ;
39755 int res5 = SWIG_TMPOBJ ;
39756 int temp6 ;
39757 int res6 = SWIG_TMPOBJ ;
39758 void *argp7 = 0 ;
39759 int res7 = 0 ;
39760 PyObject * obj0 = 0 ;
39761 PyObject * obj1 = 0 ;
39762 PyObject * obj2 = 0 ;
39763 char * kwnames[] = {
39764 (char *) "self",(char *) "string",(char *) "font", NULL
39765 };
39766
39767 arg3 = &temp3;
39768 arg4 = &temp4;
39769 arg5 = &temp5;
39770 arg6 = &temp6;
39771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39773 if (!SWIG_IsOK(res1)) {
39774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39775 }
39776 arg1 = reinterpret_cast< wxWindow * >(argp1);
39777 {
39778 arg2 = wxString_in_helper(obj1);
39779 if (arg2 == NULL) SWIG_fail;
39780 temp2 = true;
39781 }
39782 if (obj2) {
39783 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39784 if (!SWIG_IsOK(res7)) {
39785 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39786 }
39787 arg7 = reinterpret_cast< wxFont * >(argp7);
39788 }
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 resultobj = SWIG_Py_Void();
39796 if (SWIG_IsTmpObj(res3)) {
39797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39798 } else {
39799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39801 }
39802 if (SWIG_IsTmpObj(res4)) {
39803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39804 } else {
39805 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39807 }
39808 if (SWIG_IsTmpObj(res5)) {
39809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39810 } else {
39811 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39813 }
39814 if (SWIG_IsTmpObj(res6)) {
39815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39816 } else {
39817 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39819 }
39820 {
39821 if (temp2)
39822 delete arg2;
39823 }
39824 return resultobj;
39825 fail:
39826 {
39827 if (temp2)
39828 delete arg2;
39829 }
39830 return NULL;
39831 }
39832
39833
39834 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39835 PyObject *resultobj = 0;
39836 wxWindow *arg1 = (wxWindow *) 0 ;
39837 int *arg2 = (int *) 0 ;
39838 int *arg3 = (int *) 0 ;
39839 void *argp1 = 0 ;
39840 int res1 = 0 ;
39841 int temp2 ;
39842 int res2 = 0 ;
39843 int temp3 ;
39844 int res3 = 0 ;
39845 PyObject * obj0 = 0 ;
39846 PyObject * obj1 = 0 ;
39847 PyObject * obj2 = 0 ;
39848 char * kwnames[] = {
39849 (char *) "self",(char *) "x",(char *) "y", NULL
39850 };
39851
39852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39854 if (!SWIG_IsOK(res1)) {
39855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39856 }
39857 arg1 = reinterpret_cast< wxWindow * >(argp1);
39858 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39859 int val;
39860 int ecode = SWIG_AsVal_int(obj1, &val);
39861 if (!SWIG_IsOK(ecode)) {
39862 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39863 }
39864 temp2 = static_cast< int >(val);
39865 arg2 = &temp2;
39866 res2 = SWIG_AddTmpMask(ecode);
39867 }
39868 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39869 int val;
39870 int ecode = SWIG_AsVal_int(obj2, &val);
39871 if (!SWIG_IsOK(ecode)) {
39872 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39873 }
39874 temp3 = static_cast< int >(val);
39875 arg3 = &temp3;
39876 res3 = SWIG_AddTmpMask(ecode);
39877 }
39878 {
39879 PyThreadState* __tstate = wxPyBeginAllowThreads();
39880 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39881 wxPyEndAllowThreads(__tstate);
39882 if (PyErr_Occurred()) SWIG_fail;
39883 }
39884 resultobj = SWIG_Py_Void();
39885 if (SWIG_IsTmpObj(res2)) {
39886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39887 } else {
39888 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39890 }
39891 if (SWIG_IsTmpObj(res3)) {
39892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39893 } else {
39894 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39896 }
39897 return resultobj;
39898 fail:
39899 return NULL;
39900 }
39901
39902
39903 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39904 PyObject *resultobj = 0;
39905 wxWindow *arg1 = (wxWindow *) 0 ;
39906 int *arg2 = (int *) 0 ;
39907 int *arg3 = (int *) 0 ;
39908 void *argp1 = 0 ;
39909 int res1 = 0 ;
39910 int temp2 ;
39911 int res2 = 0 ;
39912 int temp3 ;
39913 int res3 = 0 ;
39914 PyObject * obj0 = 0 ;
39915 PyObject * obj1 = 0 ;
39916 PyObject * obj2 = 0 ;
39917 char * kwnames[] = {
39918 (char *) "self",(char *) "x",(char *) "y", NULL
39919 };
39920
39921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39923 if (!SWIG_IsOK(res1)) {
39924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39925 }
39926 arg1 = reinterpret_cast< wxWindow * >(argp1);
39927 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39928 int val;
39929 int ecode = SWIG_AsVal_int(obj1, &val);
39930 if (!SWIG_IsOK(ecode)) {
39931 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39932 }
39933 temp2 = static_cast< int >(val);
39934 arg2 = &temp2;
39935 res2 = SWIG_AddTmpMask(ecode);
39936 }
39937 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39938 int val;
39939 int ecode = SWIG_AsVal_int(obj2, &val);
39940 if (!SWIG_IsOK(ecode)) {
39941 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39942 }
39943 temp3 = static_cast< int >(val);
39944 arg3 = &temp3;
39945 res3 = SWIG_AddTmpMask(ecode);
39946 }
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 resultobj = SWIG_Py_Void();
39954 if (SWIG_IsTmpObj(res2)) {
39955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39956 } else {
39957 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39959 }
39960 if (SWIG_IsTmpObj(res3)) {
39961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39962 } else {
39963 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39965 }
39966 return resultobj;
39967 fail:
39968 return NULL;
39969 }
39970
39971
39972 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39973 PyObject *resultobj = 0;
39974 wxWindow *arg1 = (wxWindow *) 0 ;
39975 wxPoint *arg2 = 0 ;
39976 wxPoint result;
39977 void *argp1 = 0 ;
39978 int res1 = 0 ;
39979 wxPoint temp2 ;
39980 PyObject * obj0 = 0 ;
39981 PyObject * obj1 = 0 ;
39982 char * kwnames[] = {
39983 (char *) "self",(char *) "pt", NULL
39984 };
39985
39986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39988 if (!SWIG_IsOK(res1)) {
39989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39990 }
39991 arg1 = reinterpret_cast< wxWindow * >(argp1);
39992 {
39993 arg2 = &temp2;
39994 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39995 }
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39999 wxPyEndAllowThreads(__tstate);
40000 if (PyErr_Occurred()) SWIG_fail;
40001 }
40002 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40003 return resultobj;
40004 fail:
40005 return NULL;
40006 }
40007
40008
40009 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40010 PyObject *resultobj = 0;
40011 wxWindow *arg1 = (wxWindow *) 0 ;
40012 wxPoint *arg2 = 0 ;
40013 wxPoint result;
40014 void *argp1 = 0 ;
40015 int res1 = 0 ;
40016 wxPoint temp2 ;
40017 PyObject * obj0 = 0 ;
40018 PyObject * obj1 = 0 ;
40019 char * kwnames[] = {
40020 (char *) "self",(char *) "pt", NULL
40021 };
40022
40023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
40024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40025 if (!SWIG_IsOK(res1)) {
40026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
40027 }
40028 arg1 = reinterpret_cast< wxWindow * >(argp1);
40029 {
40030 arg2 = &temp2;
40031 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40032 }
40033 {
40034 PyThreadState* __tstate = wxPyBeginAllowThreads();
40035 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
40036 wxPyEndAllowThreads(__tstate);
40037 if (PyErr_Occurred()) SWIG_fail;
40038 }
40039 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40040 return resultobj;
40041 fail:
40042 return NULL;
40043 }
40044
40045
40046 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40047 PyObject *resultobj = 0;
40048 wxWindow *arg1 = (wxWindow *) 0 ;
40049 int arg2 ;
40050 int arg3 ;
40051 wxHitTest result;
40052 void *argp1 = 0 ;
40053 int res1 = 0 ;
40054 int val2 ;
40055 int ecode2 = 0 ;
40056 int val3 ;
40057 int ecode3 = 0 ;
40058 PyObject * obj0 = 0 ;
40059 PyObject * obj1 = 0 ;
40060 PyObject * obj2 = 0 ;
40061 char * kwnames[] = {
40062 (char *) "self",(char *) "x",(char *) "y", NULL
40063 };
40064
40065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40067 if (!SWIG_IsOK(res1)) {
40068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
40069 }
40070 arg1 = reinterpret_cast< wxWindow * >(argp1);
40071 ecode2 = SWIG_AsVal_int(obj1, &val2);
40072 if (!SWIG_IsOK(ecode2)) {
40073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
40074 }
40075 arg2 = static_cast< int >(val2);
40076 ecode3 = SWIG_AsVal_int(obj2, &val3);
40077 if (!SWIG_IsOK(ecode3)) {
40078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
40079 }
40080 arg3 = static_cast< int >(val3);
40081 {
40082 PyThreadState* __tstate = wxPyBeginAllowThreads();
40083 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
40084 wxPyEndAllowThreads(__tstate);
40085 if (PyErr_Occurred()) SWIG_fail;
40086 }
40087 resultobj = SWIG_From_int(static_cast< int >(result));
40088 return resultobj;
40089 fail:
40090 return NULL;
40091 }
40092
40093
40094 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40095 PyObject *resultobj = 0;
40096 wxWindow *arg1 = (wxWindow *) 0 ;
40097 wxPoint *arg2 = 0 ;
40098 wxHitTest result;
40099 void *argp1 = 0 ;
40100 int res1 = 0 ;
40101 wxPoint temp2 ;
40102 PyObject * obj0 = 0 ;
40103 PyObject * obj1 = 0 ;
40104 char * kwnames[] = {
40105 (char *) "self",(char *) "pt", NULL
40106 };
40107
40108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
40109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40110 if (!SWIG_IsOK(res1)) {
40111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
40112 }
40113 arg1 = reinterpret_cast< wxWindow * >(argp1);
40114 {
40115 arg2 = &temp2;
40116 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40117 }
40118 {
40119 PyThreadState* __tstate = wxPyBeginAllowThreads();
40120 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
40121 wxPyEndAllowThreads(__tstate);
40122 if (PyErr_Occurred()) SWIG_fail;
40123 }
40124 resultobj = SWIG_From_int(static_cast< int >(result));
40125 return resultobj;
40126 fail:
40127 return NULL;
40128 }
40129
40130
40131 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40132 PyObject *resultobj = 0;
40133 wxWindow *arg1 = (wxWindow *) 0 ;
40134 long arg2 ;
40135 wxBorder result;
40136 void *argp1 = 0 ;
40137 int res1 = 0 ;
40138 long val2 ;
40139 int ecode2 = 0 ;
40140
40141 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
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_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40145 }
40146 arg1 = reinterpret_cast< wxWindow * >(argp1);
40147 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
40148 if (!SWIG_IsOK(ecode2)) {
40149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
40150 }
40151 arg2 = static_cast< long >(val2);
40152 {
40153 PyThreadState* __tstate = wxPyBeginAllowThreads();
40154 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
40155 wxPyEndAllowThreads(__tstate);
40156 if (PyErr_Occurred()) SWIG_fail;
40157 }
40158 resultobj = SWIG_From_int(static_cast< int >(result));
40159 return resultobj;
40160 fail:
40161 return NULL;
40162 }
40163
40164
40165 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40166 PyObject *resultobj = 0;
40167 wxWindow *arg1 = (wxWindow *) 0 ;
40168 wxBorder result;
40169 void *argp1 = 0 ;
40170 int res1 = 0 ;
40171
40172 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
40173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40174 if (!SWIG_IsOK(res1)) {
40175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40176 }
40177 arg1 = reinterpret_cast< wxWindow * >(argp1);
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
40181 wxPyEndAllowThreads(__tstate);
40182 if (PyErr_Occurred()) SWIG_fail;
40183 }
40184 resultobj = SWIG_From_int(static_cast< int >(result));
40185 return resultobj;
40186 fail:
40187 return NULL;
40188 }
40189
40190
40191 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
40192 int argc;
40193 PyObject *argv[3];
40194
40195 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
40196 --argc;
40197 if (argc == 1) {
40198 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
40199 }
40200 if (argc == 2) {
40201 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
40202 }
40203
40204 fail:
40205 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
40206 return NULL;
40207 }
40208
40209
40210 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40211 PyObject *resultobj = 0;
40212 wxWindow *arg1 = (wxWindow *) 0 ;
40213 long arg2 = (long) wxUPDATE_UI_NONE ;
40214 void *argp1 = 0 ;
40215 int res1 = 0 ;
40216 long val2 ;
40217 int ecode2 = 0 ;
40218 PyObject * obj0 = 0 ;
40219 PyObject * obj1 = 0 ;
40220 char * kwnames[] = {
40221 (char *) "self",(char *) "flags", NULL
40222 };
40223
40224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
40225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40226 if (!SWIG_IsOK(res1)) {
40227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
40228 }
40229 arg1 = reinterpret_cast< wxWindow * >(argp1);
40230 if (obj1) {
40231 ecode2 = SWIG_AsVal_long(obj1, &val2);
40232 if (!SWIG_IsOK(ecode2)) {
40233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
40234 }
40235 arg2 = static_cast< long >(val2);
40236 }
40237 {
40238 PyThreadState* __tstate = wxPyBeginAllowThreads();
40239 (arg1)->UpdateWindowUI(arg2);
40240 wxPyEndAllowThreads(__tstate);
40241 if (PyErr_Occurred()) SWIG_fail;
40242 }
40243 resultobj = SWIG_Py_Void();
40244 return resultobj;
40245 fail:
40246 return NULL;
40247 }
40248
40249
40250 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40251 PyObject *resultobj = 0;
40252 wxWindow *arg1 = (wxWindow *) 0 ;
40253 wxMenu *arg2 = (wxMenu *) 0 ;
40254 int arg3 = (int) -1 ;
40255 int arg4 = (int) -1 ;
40256 bool result;
40257 void *argp1 = 0 ;
40258 int res1 = 0 ;
40259 void *argp2 = 0 ;
40260 int res2 = 0 ;
40261 int val3 ;
40262 int ecode3 = 0 ;
40263 int val4 ;
40264 int ecode4 = 0 ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 PyObject * obj2 = 0 ;
40268 PyObject * obj3 = 0 ;
40269 char * kwnames[] = {
40270 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
40271 };
40272
40273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40275 if (!SWIG_IsOK(res1)) {
40276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
40277 }
40278 arg1 = reinterpret_cast< wxWindow * >(argp1);
40279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40280 if (!SWIG_IsOK(res2)) {
40281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
40282 }
40283 arg2 = reinterpret_cast< wxMenu * >(argp2);
40284 if (obj2) {
40285 ecode3 = SWIG_AsVal_int(obj2, &val3);
40286 if (!SWIG_IsOK(ecode3)) {
40287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
40288 }
40289 arg3 = static_cast< int >(val3);
40290 }
40291 if (obj3) {
40292 ecode4 = SWIG_AsVal_int(obj3, &val4);
40293 if (!SWIG_IsOK(ecode4)) {
40294 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
40295 }
40296 arg4 = static_cast< int >(val4);
40297 }
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
40301 wxPyEndAllowThreads(__tstate);
40302 if (PyErr_Occurred()) SWIG_fail;
40303 }
40304 {
40305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40306 }
40307 return resultobj;
40308 fail:
40309 return NULL;
40310 }
40311
40312
40313 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40314 PyObject *resultobj = 0;
40315 wxWindow *arg1 = (wxWindow *) 0 ;
40316 wxMenu *arg2 = (wxMenu *) 0 ;
40317 wxPoint const &arg3_defvalue = wxDefaultPosition ;
40318 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
40319 bool result;
40320 void *argp1 = 0 ;
40321 int res1 = 0 ;
40322 void *argp2 = 0 ;
40323 int res2 = 0 ;
40324 wxPoint temp3 ;
40325 PyObject * obj0 = 0 ;
40326 PyObject * obj1 = 0 ;
40327 PyObject * obj2 = 0 ;
40328 char * kwnames[] = {
40329 (char *) "self",(char *) "menu",(char *) "pos", NULL
40330 };
40331
40332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40334 if (!SWIG_IsOK(res1)) {
40335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
40336 }
40337 arg1 = reinterpret_cast< wxWindow * >(argp1);
40338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40339 if (!SWIG_IsOK(res2)) {
40340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40341 }
40342 arg2 = reinterpret_cast< wxMenu * >(argp2);
40343 if (obj2) {
40344 {
40345 arg3 = &temp3;
40346 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
40347 }
40348 }
40349 {
40350 PyThreadState* __tstate = wxPyBeginAllowThreads();
40351 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
40352 wxPyEndAllowThreads(__tstate);
40353 if (PyErr_Occurred()) SWIG_fail;
40354 }
40355 {
40356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40357 }
40358 return resultobj;
40359 fail:
40360 return NULL;
40361 }
40362
40363
40364 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40365 PyObject *resultobj = 0;
40366 wxWindow *arg1 = (wxWindow *) 0 ;
40367 bool result;
40368 void *argp1 = 0 ;
40369 int res1 = 0 ;
40370 PyObject *swig_obj[1] ;
40371
40372 if (!args) SWIG_fail;
40373 swig_obj[0] = args;
40374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40375 if (!SWIG_IsOK(res1)) {
40376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
40377 }
40378 arg1 = reinterpret_cast< wxWindow * >(argp1);
40379 {
40380 PyThreadState* __tstate = wxPyBeginAllowThreads();
40381 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
40382 wxPyEndAllowThreads(__tstate);
40383 if (PyErr_Occurred()) SWIG_fail;
40384 }
40385 {
40386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40387 }
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40395 PyObject *resultobj = 0;
40396 wxWindow *arg1 = (wxWindow *) 0 ;
40397 long result;
40398 void *argp1 = 0 ;
40399 int res1 = 0 ;
40400 PyObject *swig_obj[1] ;
40401
40402 if (!args) SWIG_fail;
40403 swig_obj[0] = args;
40404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40405 if (!SWIG_IsOK(res1)) {
40406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40407 }
40408 arg1 = reinterpret_cast< wxWindow * >(argp1);
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 result = (long)wxWindow_GetHandle(arg1);
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 resultobj = SWIG_From_long(static_cast< long >(result));
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40423 PyObject *resultobj = 0;
40424 wxWindow *arg1 = (wxWindow *) 0 ;
40425 long arg2 ;
40426 void *argp1 = 0 ;
40427 int res1 = 0 ;
40428 long val2 ;
40429 int ecode2 = 0 ;
40430 PyObject * obj0 = 0 ;
40431 PyObject * obj1 = 0 ;
40432 char * kwnames[] = {
40433 (char *) "self",(char *) "handle", NULL
40434 };
40435
40436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
40437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40438 if (!SWIG_IsOK(res1)) {
40439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40440 }
40441 arg1 = reinterpret_cast< wxWindow * >(argp1);
40442 ecode2 = SWIG_AsVal_long(obj1, &val2);
40443 if (!SWIG_IsOK(ecode2)) {
40444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
40445 }
40446 arg2 = static_cast< long >(val2);
40447 {
40448 PyThreadState* __tstate = wxPyBeginAllowThreads();
40449 wxWindow_AssociateHandle(arg1,arg2);
40450 wxPyEndAllowThreads(__tstate);
40451 if (PyErr_Occurred()) SWIG_fail;
40452 }
40453 resultobj = SWIG_Py_Void();
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40461 PyObject *resultobj = 0;
40462 wxWindow *arg1 = (wxWindow *) 0 ;
40463 void *argp1 = 0 ;
40464 int res1 = 0 ;
40465 PyObject *swig_obj[1] ;
40466
40467 if (!args) SWIG_fail;
40468 swig_obj[0] = args;
40469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40470 if (!SWIG_IsOK(res1)) {
40471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40472 }
40473 arg1 = reinterpret_cast< wxWindow * >(argp1);
40474 {
40475 PyThreadState* __tstate = wxPyBeginAllowThreads();
40476 (arg1)->DissociateHandle();
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_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40488 PyObject *resultobj = 0;
40489 wxWindow *arg1 = (wxWindow *) 0 ;
40490 wxPaintEvent *arg2 = 0 ;
40491 void *argp1 = 0 ;
40492 int res1 = 0 ;
40493 void *argp2 = 0 ;
40494 int res2 = 0 ;
40495 PyObject * obj0 = 0 ;
40496 PyObject * obj1 = 0 ;
40497 char * kwnames[] = {
40498 (char *) "self",(char *) "event", NULL
40499 };
40500
40501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
40502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40503 if (!SWIG_IsOK(res1)) {
40504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
40505 }
40506 arg1 = reinterpret_cast< wxWindow * >(argp1);
40507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
40508 if (!SWIG_IsOK(res2)) {
40509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40510 }
40511 if (!argp2) {
40512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40513 }
40514 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
40515 {
40516 PyThreadState* __tstate = wxPyBeginAllowThreads();
40517 (arg1)->OnPaint(*arg2);
40518 wxPyEndAllowThreads(__tstate);
40519 if (PyErr_Occurred()) SWIG_fail;
40520 }
40521 resultobj = SWIG_Py_Void();
40522 return resultobj;
40523 fail:
40524 return NULL;
40525 }
40526
40527
40528 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40529 PyObject *resultobj = 0;
40530 wxWindow *arg1 = (wxWindow *) 0 ;
40531 int arg2 ;
40532 bool result;
40533 void *argp1 = 0 ;
40534 int res1 = 0 ;
40535 int val2 ;
40536 int ecode2 = 0 ;
40537 PyObject * obj0 = 0 ;
40538 PyObject * obj1 = 0 ;
40539 char * kwnames[] = {
40540 (char *) "self",(char *) "orient", NULL
40541 };
40542
40543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40545 if (!SWIG_IsOK(res1)) {
40546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40547 }
40548 arg1 = reinterpret_cast< wxWindow * >(argp1);
40549 ecode2 = SWIG_AsVal_int(obj1, &val2);
40550 if (!SWIG_IsOK(ecode2)) {
40551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40552 }
40553 arg2 = static_cast< int >(val2);
40554 {
40555 PyThreadState* __tstate = wxPyBeginAllowThreads();
40556 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40557 wxPyEndAllowThreads(__tstate);
40558 if (PyErr_Occurred()) SWIG_fail;
40559 }
40560 {
40561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40562 }
40563 return resultobj;
40564 fail:
40565 return NULL;
40566 }
40567
40568
40569 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40570 PyObject *resultobj = 0;
40571 wxWindow *arg1 = (wxWindow *) 0 ;
40572 int arg2 ;
40573 int arg3 ;
40574 int arg4 ;
40575 int arg5 ;
40576 bool arg6 = (bool) true ;
40577 void *argp1 = 0 ;
40578 int res1 = 0 ;
40579 int val2 ;
40580 int ecode2 = 0 ;
40581 int val3 ;
40582 int ecode3 = 0 ;
40583 int val4 ;
40584 int ecode4 = 0 ;
40585 int val5 ;
40586 int ecode5 = 0 ;
40587 bool val6 ;
40588 int ecode6 = 0 ;
40589 PyObject * obj0 = 0 ;
40590 PyObject * obj1 = 0 ;
40591 PyObject * obj2 = 0 ;
40592 PyObject * obj3 = 0 ;
40593 PyObject * obj4 = 0 ;
40594 PyObject * obj5 = 0 ;
40595 char * kwnames[] = {
40596 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40597 };
40598
40599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40601 if (!SWIG_IsOK(res1)) {
40602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40603 }
40604 arg1 = reinterpret_cast< wxWindow * >(argp1);
40605 ecode2 = SWIG_AsVal_int(obj1, &val2);
40606 if (!SWIG_IsOK(ecode2)) {
40607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40608 }
40609 arg2 = static_cast< int >(val2);
40610 ecode3 = SWIG_AsVal_int(obj2, &val3);
40611 if (!SWIG_IsOK(ecode3)) {
40612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40613 }
40614 arg3 = static_cast< int >(val3);
40615 ecode4 = SWIG_AsVal_int(obj3, &val4);
40616 if (!SWIG_IsOK(ecode4)) {
40617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40618 }
40619 arg4 = static_cast< int >(val4);
40620 ecode5 = SWIG_AsVal_int(obj4, &val5);
40621 if (!SWIG_IsOK(ecode5)) {
40622 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40623 }
40624 arg5 = static_cast< int >(val5);
40625 if (obj5) {
40626 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40627 if (!SWIG_IsOK(ecode6)) {
40628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40629 }
40630 arg6 = static_cast< bool >(val6);
40631 }
40632 {
40633 PyThreadState* __tstate = wxPyBeginAllowThreads();
40634 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40635 wxPyEndAllowThreads(__tstate);
40636 if (PyErr_Occurred()) SWIG_fail;
40637 }
40638 resultobj = SWIG_Py_Void();
40639 return resultobj;
40640 fail:
40641 return NULL;
40642 }
40643
40644
40645 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40646 PyObject *resultobj = 0;
40647 wxWindow *arg1 = (wxWindow *) 0 ;
40648 int arg2 ;
40649 int arg3 ;
40650 bool arg4 = (bool) true ;
40651 void *argp1 = 0 ;
40652 int res1 = 0 ;
40653 int val2 ;
40654 int ecode2 = 0 ;
40655 int val3 ;
40656 int ecode3 = 0 ;
40657 bool val4 ;
40658 int ecode4 = 0 ;
40659 PyObject * obj0 = 0 ;
40660 PyObject * obj1 = 0 ;
40661 PyObject * obj2 = 0 ;
40662 PyObject * obj3 = 0 ;
40663 char * kwnames[] = {
40664 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40665 };
40666
40667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40669 if (!SWIG_IsOK(res1)) {
40670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40671 }
40672 arg1 = reinterpret_cast< wxWindow * >(argp1);
40673 ecode2 = SWIG_AsVal_int(obj1, &val2);
40674 if (!SWIG_IsOK(ecode2)) {
40675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40676 }
40677 arg2 = static_cast< int >(val2);
40678 ecode3 = SWIG_AsVal_int(obj2, &val3);
40679 if (!SWIG_IsOK(ecode3)) {
40680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40681 }
40682 arg3 = static_cast< int >(val3);
40683 if (obj3) {
40684 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40685 if (!SWIG_IsOK(ecode4)) {
40686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40687 }
40688 arg4 = static_cast< bool >(val4);
40689 }
40690 {
40691 PyThreadState* __tstate = wxPyBeginAllowThreads();
40692 (arg1)->SetScrollPos(arg2,arg3,arg4);
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 resultobj = SWIG_Py_Void();
40697 return resultobj;
40698 fail:
40699 return NULL;
40700 }
40701
40702
40703 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40704 PyObject *resultobj = 0;
40705 wxWindow *arg1 = (wxWindow *) 0 ;
40706 int arg2 ;
40707 int result;
40708 void *argp1 = 0 ;
40709 int res1 = 0 ;
40710 int val2 ;
40711 int ecode2 = 0 ;
40712 PyObject * obj0 = 0 ;
40713 PyObject * obj1 = 0 ;
40714 char * kwnames[] = {
40715 (char *) "self",(char *) "orientation", NULL
40716 };
40717
40718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40720 if (!SWIG_IsOK(res1)) {
40721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40722 }
40723 arg1 = reinterpret_cast< wxWindow * >(argp1);
40724 ecode2 = SWIG_AsVal_int(obj1, &val2);
40725 if (!SWIG_IsOK(ecode2)) {
40726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40727 }
40728 arg2 = static_cast< int >(val2);
40729 {
40730 PyThreadState* __tstate = wxPyBeginAllowThreads();
40731 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40732 wxPyEndAllowThreads(__tstate);
40733 if (PyErr_Occurred()) SWIG_fail;
40734 }
40735 resultobj = SWIG_From_int(static_cast< int >(result));
40736 return resultobj;
40737 fail:
40738 return NULL;
40739 }
40740
40741
40742 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40743 PyObject *resultobj = 0;
40744 wxWindow *arg1 = (wxWindow *) 0 ;
40745 int arg2 ;
40746 int result;
40747 void *argp1 = 0 ;
40748 int res1 = 0 ;
40749 int val2 ;
40750 int ecode2 = 0 ;
40751 PyObject * obj0 = 0 ;
40752 PyObject * obj1 = 0 ;
40753 char * kwnames[] = {
40754 (char *) "self",(char *) "orientation", NULL
40755 };
40756
40757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40759 if (!SWIG_IsOK(res1)) {
40760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40761 }
40762 arg1 = reinterpret_cast< wxWindow * >(argp1);
40763 ecode2 = SWIG_AsVal_int(obj1, &val2);
40764 if (!SWIG_IsOK(ecode2)) {
40765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40766 }
40767 arg2 = static_cast< int >(val2);
40768 {
40769 PyThreadState* __tstate = wxPyBeginAllowThreads();
40770 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40771 wxPyEndAllowThreads(__tstate);
40772 if (PyErr_Occurred()) SWIG_fail;
40773 }
40774 resultobj = SWIG_From_int(static_cast< int >(result));
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40782 PyObject *resultobj = 0;
40783 wxWindow *arg1 = (wxWindow *) 0 ;
40784 int arg2 ;
40785 int result;
40786 void *argp1 = 0 ;
40787 int res1 = 0 ;
40788 int val2 ;
40789 int ecode2 = 0 ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 char * kwnames[] = {
40793 (char *) "self",(char *) "orientation", NULL
40794 };
40795
40796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40798 if (!SWIG_IsOK(res1)) {
40799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40800 }
40801 arg1 = reinterpret_cast< wxWindow * >(argp1);
40802 ecode2 = SWIG_AsVal_int(obj1, &val2);
40803 if (!SWIG_IsOK(ecode2)) {
40804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40805 }
40806 arg2 = static_cast< int >(val2);
40807 {
40808 PyThreadState* __tstate = wxPyBeginAllowThreads();
40809 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40810 wxPyEndAllowThreads(__tstate);
40811 if (PyErr_Occurred()) SWIG_fail;
40812 }
40813 resultobj = SWIG_From_int(static_cast< int >(result));
40814 return resultobj;
40815 fail:
40816 return NULL;
40817 }
40818
40819
40820 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40821 PyObject *resultobj = 0;
40822 wxWindow *arg1 = (wxWindow *) 0 ;
40823 int arg2 ;
40824 int arg3 ;
40825 wxRect *arg4 = (wxRect *) NULL ;
40826 void *argp1 = 0 ;
40827 int res1 = 0 ;
40828 int val2 ;
40829 int ecode2 = 0 ;
40830 int val3 ;
40831 int ecode3 = 0 ;
40832 void *argp4 = 0 ;
40833 int res4 = 0 ;
40834 PyObject * obj0 = 0 ;
40835 PyObject * obj1 = 0 ;
40836 PyObject * obj2 = 0 ;
40837 PyObject * obj3 = 0 ;
40838 char * kwnames[] = {
40839 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40840 };
40841
40842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40844 if (!SWIG_IsOK(res1)) {
40845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40846 }
40847 arg1 = reinterpret_cast< wxWindow * >(argp1);
40848 ecode2 = SWIG_AsVal_int(obj1, &val2);
40849 if (!SWIG_IsOK(ecode2)) {
40850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40851 }
40852 arg2 = static_cast< int >(val2);
40853 ecode3 = SWIG_AsVal_int(obj2, &val3);
40854 if (!SWIG_IsOK(ecode3)) {
40855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40856 }
40857 arg3 = static_cast< int >(val3);
40858 if (obj3) {
40859 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40860 if (!SWIG_IsOK(res4)) {
40861 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40862 }
40863 arg4 = reinterpret_cast< wxRect * >(argp4);
40864 }
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40868 wxPyEndAllowThreads(__tstate);
40869 if (PyErr_Occurred()) SWIG_fail;
40870 }
40871 resultobj = SWIG_Py_Void();
40872 return resultobj;
40873 fail:
40874 return NULL;
40875 }
40876
40877
40878 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40879 PyObject *resultobj = 0;
40880 wxWindow *arg1 = (wxWindow *) 0 ;
40881 int arg2 ;
40882 bool result;
40883 void *argp1 = 0 ;
40884 int res1 = 0 ;
40885 int val2 ;
40886 int ecode2 = 0 ;
40887 PyObject * obj0 = 0 ;
40888 PyObject * obj1 = 0 ;
40889 char * kwnames[] = {
40890 (char *) "self",(char *) "lines", NULL
40891 };
40892
40893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40895 if (!SWIG_IsOK(res1)) {
40896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40897 }
40898 arg1 = reinterpret_cast< wxWindow * >(argp1);
40899 ecode2 = SWIG_AsVal_int(obj1, &val2);
40900 if (!SWIG_IsOK(ecode2)) {
40901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40902 }
40903 arg2 = static_cast< int >(val2);
40904 {
40905 PyThreadState* __tstate = wxPyBeginAllowThreads();
40906 result = (bool)(arg1)->ScrollLines(arg2);
40907 wxPyEndAllowThreads(__tstate);
40908 if (PyErr_Occurred()) SWIG_fail;
40909 }
40910 {
40911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40912 }
40913 return resultobj;
40914 fail:
40915 return NULL;
40916 }
40917
40918
40919 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40920 PyObject *resultobj = 0;
40921 wxWindow *arg1 = (wxWindow *) 0 ;
40922 int arg2 ;
40923 bool result;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 int val2 ;
40927 int ecode2 = 0 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char * kwnames[] = {
40931 (char *) "self",(char *) "pages", NULL
40932 };
40933
40934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40936 if (!SWIG_IsOK(res1)) {
40937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40938 }
40939 arg1 = reinterpret_cast< wxWindow * >(argp1);
40940 ecode2 = SWIG_AsVal_int(obj1, &val2);
40941 if (!SWIG_IsOK(ecode2)) {
40942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40943 }
40944 arg2 = static_cast< int >(val2);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 result = (bool)(arg1)->ScrollPages(arg2);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 {
40952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40953 }
40954 return resultobj;
40955 fail:
40956 return NULL;
40957 }
40958
40959
40960 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40961 PyObject *resultobj = 0;
40962 wxWindow *arg1 = (wxWindow *) 0 ;
40963 bool result;
40964 void *argp1 = 0 ;
40965 int res1 = 0 ;
40966 PyObject *swig_obj[1] ;
40967
40968 if (!args) SWIG_fail;
40969 swig_obj[0] = args;
40970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40971 if (!SWIG_IsOK(res1)) {
40972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40973 }
40974 arg1 = reinterpret_cast< wxWindow * >(argp1);
40975 {
40976 PyThreadState* __tstate = wxPyBeginAllowThreads();
40977 result = (bool)(arg1)->LineUp();
40978 wxPyEndAllowThreads(__tstate);
40979 if (PyErr_Occurred()) SWIG_fail;
40980 }
40981 {
40982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40983 }
40984 return resultobj;
40985 fail:
40986 return NULL;
40987 }
40988
40989
40990 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40991 PyObject *resultobj = 0;
40992 wxWindow *arg1 = (wxWindow *) 0 ;
40993 bool result;
40994 void *argp1 = 0 ;
40995 int res1 = 0 ;
40996 PyObject *swig_obj[1] ;
40997
40998 if (!args) SWIG_fail;
40999 swig_obj[0] = args;
41000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41001 if (!SWIG_IsOK(res1)) {
41002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41003 }
41004 arg1 = reinterpret_cast< wxWindow * >(argp1);
41005 {
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 result = (bool)(arg1)->LineDown();
41008 wxPyEndAllowThreads(__tstate);
41009 if (PyErr_Occurred()) SWIG_fail;
41010 }
41011 {
41012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41013 }
41014 return resultobj;
41015 fail:
41016 return NULL;
41017 }
41018
41019
41020 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41021 PyObject *resultobj = 0;
41022 wxWindow *arg1 = (wxWindow *) 0 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 PyObject *swig_obj[1] ;
41027
41028 if (!args) SWIG_fail;
41029 swig_obj[0] = args;
41030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41031 if (!SWIG_IsOK(res1)) {
41032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41033 }
41034 arg1 = reinterpret_cast< wxWindow * >(argp1);
41035 {
41036 PyThreadState* __tstate = wxPyBeginAllowThreads();
41037 result = (bool)(arg1)->PageUp();
41038 wxPyEndAllowThreads(__tstate);
41039 if (PyErr_Occurred()) SWIG_fail;
41040 }
41041 {
41042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41043 }
41044 return resultobj;
41045 fail:
41046 return NULL;
41047 }
41048
41049
41050 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41051 PyObject *resultobj = 0;
41052 wxWindow *arg1 = (wxWindow *) 0 ;
41053 bool result;
41054 void *argp1 = 0 ;
41055 int res1 = 0 ;
41056 PyObject *swig_obj[1] ;
41057
41058 if (!args) SWIG_fail;
41059 swig_obj[0] = args;
41060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41061 if (!SWIG_IsOK(res1)) {
41062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41063 }
41064 arg1 = reinterpret_cast< wxWindow * >(argp1);
41065 {
41066 PyThreadState* __tstate = wxPyBeginAllowThreads();
41067 result = (bool)(arg1)->PageDown();
41068 wxPyEndAllowThreads(__tstate);
41069 if (PyErr_Occurred()) SWIG_fail;
41070 }
41071 {
41072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41073 }
41074 return resultobj;
41075 fail:
41076 return NULL;
41077 }
41078
41079
41080 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41081 PyObject *resultobj = 0;
41082 wxWindow *arg1 = (wxWindow *) 0 ;
41083 wxString *arg2 = 0 ;
41084 void *argp1 = 0 ;
41085 int res1 = 0 ;
41086 bool temp2 = false ;
41087 PyObject * obj0 = 0 ;
41088 PyObject * obj1 = 0 ;
41089 char * kwnames[] = {
41090 (char *) "self",(char *) "text", NULL
41091 };
41092
41093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
41094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41095 if (!SWIG_IsOK(res1)) {
41096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
41097 }
41098 arg1 = reinterpret_cast< wxWindow * >(argp1);
41099 {
41100 arg2 = wxString_in_helper(obj1);
41101 if (arg2 == NULL) SWIG_fail;
41102 temp2 = true;
41103 }
41104 {
41105 PyThreadState* __tstate = wxPyBeginAllowThreads();
41106 (arg1)->SetHelpText((wxString const &)*arg2);
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 resultobj = SWIG_Py_Void();
41111 {
41112 if (temp2)
41113 delete arg2;
41114 }
41115 return resultobj;
41116 fail:
41117 {
41118 if (temp2)
41119 delete arg2;
41120 }
41121 return NULL;
41122 }
41123
41124
41125 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41126 PyObject *resultobj = 0;
41127 wxWindow *arg1 = (wxWindow *) 0 ;
41128 wxString *arg2 = 0 ;
41129 void *argp1 = 0 ;
41130 int res1 = 0 ;
41131 bool temp2 = false ;
41132 PyObject * obj0 = 0 ;
41133 PyObject * obj1 = 0 ;
41134 char * kwnames[] = {
41135 (char *) "self",(char *) "text", NULL
41136 };
41137
41138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
41139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41140 if (!SWIG_IsOK(res1)) {
41141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
41142 }
41143 arg1 = reinterpret_cast< wxWindow * >(argp1);
41144 {
41145 arg2 = wxString_in_helper(obj1);
41146 if (arg2 == NULL) SWIG_fail;
41147 temp2 = true;
41148 }
41149 {
41150 PyThreadState* __tstate = wxPyBeginAllowThreads();
41151 (arg1)->SetHelpTextForId((wxString const &)*arg2);
41152 wxPyEndAllowThreads(__tstate);
41153 if (PyErr_Occurred()) SWIG_fail;
41154 }
41155 resultobj = SWIG_Py_Void();
41156 {
41157 if (temp2)
41158 delete arg2;
41159 }
41160 return resultobj;
41161 fail:
41162 {
41163 if (temp2)
41164 delete arg2;
41165 }
41166 return NULL;
41167 }
41168
41169
41170 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41171 PyObject *resultobj = 0;
41172 wxWindow *arg1 = (wxWindow *) 0 ;
41173 wxPoint *arg2 = 0 ;
41174 wxHelpEvent::Origin arg3 ;
41175 wxString result;
41176 void *argp1 = 0 ;
41177 int res1 = 0 ;
41178 wxPoint temp2 ;
41179 void *argp3 ;
41180 int res3 = 0 ;
41181 PyObject * obj0 = 0 ;
41182 PyObject * obj1 = 0 ;
41183 PyObject * obj2 = 0 ;
41184 char * kwnames[] = {
41185 (char *) "self",(char *) "pt",(char *) "origin", NULL
41186 };
41187
41188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41190 if (!SWIG_IsOK(res1)) {
41191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
41192 }
41193 arg1 = reinterpret_cast< wxWindow * >(argp1);
41194 {
41195 arg2 = &temp2;
41196 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
41197 }
41198 {
41199 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
41200 if (!SWIG_IsOK(res3)) {
41201 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41202 }
41203 if (!argp3) {
41204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41205 } else {
41206 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
41207 arg3 = *temp;
41208 if (SWIG_IsNewObj(res3)) delete temp;
41209 }
41210 }
41211 {
41212 PyThreadState* __tstate = wxPyBeginAllowThreads();
41213 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
41214 wxPyEndAllowThreads(__tstate);
41215 if (PyErr_Occurred()) SWIG_fail;
41216 }
41217 {
41218 #if wxUSE_UNICODE
41219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41220 #else
41221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41222 #endif
41223 }
41224 return resultobj;
41225 fail:
41226 return NULL;
41227 }
41228
41229
41230 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41231 PyObject *resultobj = 0;
41232 wxWindow *arg1 = (wxWindow *) 0 ;
41233 wxString result;
41234 void *argp1 = 0 ;
41235 int res1 = 0 ;
41236 PyObject *swig_obj[1] ;
41237
41238 if (!args) SWIG_fail;
41239 swig_obj[0] = args;
41240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41241 if (!SWIG_IsOK(res1)) {
41242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
41243 }
41244 arg1 = reinterpret_cast< wxWindow * >(argp1);
41245 {
41246 PyThreadState* __tstate = wxPyBeginAllowThreads();
41247 result = ((wxWindow const *)arg1)->GetHelpText();
41248 wxPyEndAllowThreads(__tstate);
41249 if (PyErr_Occurred()) SWIG_fail;
41250 }
41251 {
41252 #if wxUSE_UNICODE
41253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41254 #else
41255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41256 #endif
41257 }
41258 return resultobj;
41259 fail:
41260 return NULL;
41261 }
41262
41263
41264 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj = 0;
41266 wxWindow *arg1 = (wxWindow *) 0 ;
41267 wxString *arg2 = 0 ;
41268 void *argp1 = 0 ;
41269 int res1 = 0 ;
41270 bool temp2 = false ;
41271 PyObject * obj0 = 0 ;
41272 PyObject * obj1 = 0 ;
41273 char * kwnames[] = {
41274 (char *) "self",(char *) "tip", NULL
41275 };
41276
41277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
41278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41279 if (!SWIG_IsOK(res1)) {
41280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
41281 }
41282 arg1 = reinterpret_cast< wxWindow * >(argp1);
41283 {
41284 arg2 = wxString_in_helper(obj1);
41285 if (arg2 == NULL) SWIG_fail;
41286 temp2 = true;
41287 }
41288 {
41289 PyThreadState* __tstate = wxPyBeginAllowThreads();
41290 (arg1)->SetToolTip((wxString const &)*arg2);
41291 wxPyEndAllowThreads(__tstate);
41292 if (PyErr_Occurred()) SWIG_fail;
41293 }
41294 resultobj = SWIG_Py_Void();
41295 {
41296 if (temp2)
41297 delete arg2;
41298 }
41299 return resultobj;
41300 fail:
41301 {
41302 if (temp2)
41303 delete arg2;
41304 }
41305 return NULL;
41306 }
41307
41308
41309 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41310 PyObject *resultobj = 0;
41311 wxWindow *arg1 = (wxWindow *) 0 ;
41312 wxToolTip *arg2 = (wxToolTip *) 0 ;
41313 void *argp1 = 0 ;
41314 int res1 = 0 ;
41315 int res2 = 0 ;
41316 PyObject * obj0 = 0 ;
41317 PyObject * obj1 = 0 ;
41318 char * kwnames[] = {
41319 (char *) "self",(char *) "tip", NULL
41320 };
41321
41322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
41323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41324 if (!SWIG_IsOK(res1)) {
41325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
41326 }
41327 arg1 = reinterpret_cast< wxWindow * >(argp1);
41328 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
41329 if (!SWIG_IsOK(res2)) {
41330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
41331 }
41332 {
41333 PyThreadState* __tstate = wxPyBeginAllowThreads();
41334 (arg1)->SetToolTip(arg2);
41335 wxPyEndAllowThreads(__tstate);
41336 if (PyErr_Occurred()) SWIG_fail;
41337 }
41338 resultobj = SWIG_Py_Void();
41339 return resultobj;
41340 fail:
41341 return NULL;
41342 }
41343
41344
41345 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41346 PyObject *resultobj = 0;
41347 wxWindow *arg1 = (wxWindow *) 0 ;
41348 wxToolTip *result = 0 ;
41349 void *argp1 = 0 ;
41350 int res1 = 0 ;
41351 PyObject *swig_obj[1] ;
41352
41353 if (!args) SWIG_fail;
41354 swig_obj[0] = args;
41355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41356 if (!SWIG_IsOK(res1)) {
41357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
41358 }
41359 arg1 = reinterpret_cast< wxWindow * >(argp1);
41360 {
41361 PyThreadState* __tstate = wxPyBeginAllowThreads();
41362 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
41363 wxPyEndAllowThreads(__tstate);
41364 if (PyErr_Occurred()) SWIG_fail;
41365 }
41366 {
41367 resultobj = wxPyMake_wxObject(result, (bool)0);
41368 }
41369 return resultobj;
41370 fail:
41371 return NULL;
41372 }
41373
41374
41375 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41376 PyObject *resultobj = 0;
41377 wxWindow *arg1 = (wxWindow *) 0 ;
41378 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
41379 void *argp1 = 0 ;
41380 int res1 = 0 ;
41381 int res2 = 0 ;
41382 PyObject * obj0 = 0 ;
41383 PyObject * obj1 = 0 ;
41384 char * kwnames[] = {
41385 (char *) "self",(char *) "dropTarget", NULL
41386 };
41387
41388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
41389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41390 if (!SWIG_IsOK(res1)) {
41391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
41392 }
41393 arg1 = reinterpret_cast< wxWindow * >(argp1);
41394 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
41395 if (!SWIG_IsOK(res2)) {
41396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
41397 }
41398 {
41399 PyThreadState* __tstate = wxPyBeginAllowThreads();
41400 (arg1)->SetDropTarget(arg2);
41401 wxPyEndAllowThreads(__tstate);
41402 if (PyErr_Occurred()) SWIG_fail;
41403 }
41404 resultobj = SWIG_Py_Void();
41405 return resultobj;
41406 fail:
41407 return NULL;
41408 }
41409
41410
41411 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41412 PyObject *resultobj = 0;
41413 wxWindow *arg1 = (wxWindow *) 0 ;
41414 wxPyDropTarget *result = 0 ;
41415 void *argp1 = 0 ;
41416 int res1 = 0 ;
41417 PyObject *swig_obj[1] ;
41418
41419 if (!args) SWIG_fail;
41420 swig_obj[0] = args;
41421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41422 if (!SWIG_IsOK(res1)) {
41423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
41424 }
41425 arg1 = reinterpret_cast< wxWindow * >(argp1);
41426 {
41427 PyThreadState* __tstate = wxPyBeginAllowThreads();
41428 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
41433 return resultobj;
41434 fail:
41435 return NULL;
41436 }
41437
41438
41439 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41440 PyObject *resultobj = 0;
41441 wxWindow *arg1 = (wxWindow *) 0 ;
41442 bool arg2 ;
41443 void *argp1 = 0 ;
41444 int res1 = 0 ;
41445 bool val2 ;
41446 int ecode2 = 0 ;
41447 PyObject * obj0 = 0 ;
41448 PyObject * obj1 = 0 ;
41449 char * kwnames[] = {
41450 (char *) "self",(char *) "accept", NULL
41451 };
41452
41453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
41454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41455 if (!SWIG_IsOK(res1)) {
41456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
41457 }
41458 arg1 = reinterpret_cast< wxWindow * >(argp1);
41459 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41460 if (!SWIG_IsOK(ecode2)) {
41461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
41462 }
41463 arg2 = static_cast< bool >(val2);
41464 {
41465 PyThreadState* __tstate = wxPyBeginAllowThreads();
41466 (arg1)->DragAcceptFiles(arg2);
41467 wxPyEndAllowThreads(__tstate);
41468 if (PyErr_Occurred()) SWIG_fail;
41469 }
41470 resultobj = SWIG_Py_Void();
41471 return resultobj;
41472 fail:
41473 return NULL;
41474 }
41475
41476
41477 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41478 PyObject *resultobj = 0;
41479 wxWindow *arg1 = (wxWindow *) 0 ;
41480 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
41481 void *argp1 = 0 ;
41482 int res1 = 0 ;
41483 int res2 = 0 ;
41484 PyObject * obj0 = 0 ;
41485 PyObject * obj1 = 0 ;
41486 char * kwnames[] = {
41487 (char *) "self",(char *) "constraints", NULL
41488 };
41489
41490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
41491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41492 if (!SWIG_IsOK(res1)) {
41493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
41494 }
41495 arg1 = reinterpret_cast< wxWindow * >(argp1);
41496 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
41497 if (!SWIG_IsOK(res2)) {
41498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
41499 }
41500 {
41501 PyThreadState* __tstate = wxPyBeginAllowThreads();
41502 (arg1)->SetConstraints(arg2);
41503 wxPyEndAllowThreads(__tstate);
41504 if (PyErr_Occurred()) SWIG_fail;
41505 }
41506 resultobj = SWIG_Py_Void();
41507 return resultobj;
41508 fail:
41509 return NULL;
41510 }
41511
41512
41513 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41514 PyObject *resultobj = 0;
41515 wxWindow *arg1 = (wxWindow *) 0 ;
41516 wxLayoutConstraints *result = 0 ;
41517 void *argp1 = 0 ;
41518 int res1 = 0 ;
41519 PyObject *swig_obj[1] ;
41520
41521 if (!args) SWIG_fail;
41522 swig_obj[0] = args;
41523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41524 if (!SWIG_IsOK(res1)) {
41525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41526 }
41527 arg1 = reinterpret_cast< wxWindow * >(argp1);
41528 {
41529 PyThreadState* __tstate = wxPyBeginAllowThreads();
41530 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41531 wxPyEndAllowThreads(__tstate);
41532 if (PyErr_Occurred()) SWIG_fail;
41533 }
41534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41535 return resultobj;
41536 fail:
41537 return NULL;
41538 }
41539
41540
41541 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41542 PyObject *resultobj = 0;
41543 wxWindow *arg1 = (wxWindow *) 0 ;
41544 bool arg2 ;
41545 void *argp1 = 0 ;
41546 int res1 = 0 ;
41547 bool val2 ;
41548 int ecode2 = 0 ;
41549 PyObject * obj0 = 0 ;
41550 PyObject * obj1 = 0 ;
41551 char * kwnames[] = {
41552 (char *) "self",(char *) "autoLayout", NULL
41553 };
41554
41555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41557 if (!SWIG_IsOK(res1)) {
41558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41559 }
41560 arg1 = reinterpret_cast< wxWindow * >(argp1);
41561 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41562 if (!SWIG_IsOK(ecode2)) {
41563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41564 }
41565 arg2 = static_cast< bool >(val2);
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 (arg1)->SetAutoLayout(arg2);
41569 wxPyEndAllowThreads(__tstate);
41570 if (PyErr_Occurred()) SWIG_fail;
41571 }
41572 resultobj = SWIG_Py_Void();
41573 return resultobj;
41574 fail:
41575 return NULL;
41576 }
41577
41578
41579 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41580 PyObject *resultobj = 0;
41581 wxWindow *arg1 = (wxWindow *) 0 ;
41582 bool result;
41583 void *argp1 = 0 ;
41584 int res1 = 0 ;
41585 PyObject *swig_obj[1] ;
41586
41587 if (!args) SWIG_fail;
41588 swig_obj[0] = args;
41589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41590 if (!SWIG_IsOK(res1)) {
41591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41592 }
41593 arg1 = reinterpret_cast< wxWindow * >(argp1);
41594 {
41595 PyThreadState* __tstate = wxPyBeginAllowThreads();
41596 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41597 wxPyEndAllowThreads(__tstate);
41598 if (PyErr_Occurred()) SWIG_fail;
41599 }
41600 {
41601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41602 }
41603 return resultobj;
41604 fail:
41605 return NULL;
41606 }
41607
41608
41609 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41610 PyObject *resultobj = 0;
41611 wxWindow *arg1 = (wxWindow *) 0 ;
41612 bool result;
41613 void *argp1 = 0 ;
41614 int res1 = 0 ;
41615 PyObject *swig_obj[1] ;
41616
41617 if (!args) SWIG_fail;
41618 swig_obj[0] = args;
41619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41620 if (!SWIG_IsOK(res1)) {
41621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41622 }
41623 arg1 = reinterpret_cast< wxWindow * >(argp1);
41624 {
41625 PyThreadState* __tstate = wxPyBeginAllowThreads();
41626 result = (bool)(arg1)->Layout();
41627 wxPyEndAllowThreads(__tstate);
41628 if (PyErr_Occurred()) SWIG_fail;
41629 }
41630 {
41631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41632 }
41633 return resultobj;
41634 fail:
41635 return NULL;
41636 }
41637
41638
41639 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41640 PyObject *resultobj = 0;
41641 wxWindow *arg1 = (wxWindow *) 0 ;
41642 wxSizer *arg2 = (wxSizer *) 0 ;
41643 bool arg3 = (bool) true ;
41644 void *argp1 = 0 ;
41645 int res1 = 0 ;
41646 int res2 = 0 ;
41647 bool val3 ;
41648 int ecode3 = 0 ;
41649 PyObject * obj0 = 0 ;
41650 PyObject * obj1 = 0 ;
41651 PyObject * obj2 = 0 ;
41652 char * kwnames[] = {
41653 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41654 };
41655
41656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41658 if (!SWIG_IsOK(res1)) {
41659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41660 }
41661 arg1 = reinterpret_cast< wxWindow * >(argp1);
41662 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41663 if (!SWIG_IsOK(res2)) {
41664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41665 }
41666 if (obj2) {
41667 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41668 if (!SWIG_IsOK(ecode3)) {
41669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41670 }
41671 arg3 = static_cast< bool >(val3);
41672 }
41673 {
41674 PyThreadState* __tstate = wxPyBeginAllowThreads();
41675 (arg1)->SetSizer(arg2,arg3);
41676 wxPyEndAllowThreads(__tstate);
41677 if (PyErr_Occurred()) SWIG_fail;
41678 }
41679 resultobj = SWIG_Py_Void();
41680 return resultobj;
41681 fail:
41682 return NULL;
41683 }
41684
41685
41686 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41687 PyObject *resultobj = 0;
41688 wxWindow *arg1 = (wxWindow *) 0 ;
41689 wxSizer *arg2 = (wxSizer *) 0 ;
41690 bool arg3 = (bool) true ;
41691 void *argp1 = 0 ;
41692 int res1 = 0 ;
41693 int res2 = 0 ;
41694 bool val3 ;
41695 int ecode3 = 0 ;
41696 PyObject * obj0 = 0 ;
41697 PyObject * obj1 = 0 ;
41698 PyObject * obj2 = 0 ;
41699 char * kwnames[] = {
41700 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41701 };
41702
41703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41705 if (!SWIG_IsOK(res1)) {
41706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41707 }
41708 arg1 = reinterpret_cast< wxWindow * >(argp1);
41709 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41710 if (!SWIG_IsOK(res2)) {
41711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41712 }
41713 if (obj2) {
41714 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41715 if (!SWIG_IsOK(ecode3)) {
41716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41717 }
41718 arg3 = static_cast< bool >(val3);
41719 }
41720 {
41721 PyThreadState* __tstate = wxPyBeginAllowThreads();
41722 (arg1)->SetSizerAndFit(arg2,arg3);
41723 wxPyEndAllowThreads(__tstate);
41724 if (PyErr_Occurred()) SWIG_fail;
41725 }
41726 resultobj = SWIG_Py_Void();
41727 return resultobj;
41728 fail:
41729 return NULL;
41730 }
41731
41732
41733 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41734 PyObject *resultobj = 0;
41735 wxWindow *arg1 = (wxWindow *) 0 ;
41736 wxSizer *result = 0 ;
41737 void *argp1 = 0 ;
41738 int res1 = 0 ;
41739 PyObject *swig_obj[1] ;
41740
41741 if (!args) SWIG_fail;
41742 swig_obj[0] = args;
41743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41744 if (!SWIG_IsOK(res1)) {
41745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41746 }
41747 arg1 = reinterpret_cast< wxWindow * >(argp1);
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 {
41755 resultobj = wxPyMake_wxObject(result, (bool)0);
41756 }
41757 return resultobj;
41758 fail:
41759 return NULL;
41760 }
41761
41762
41763 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41764 PyObject *resultobj = 0;
41765 wxWindow *arg1 = (wxWindow *) 0 ;
41766 wxSizer *arg2 = (wxSizer *) 0 ;
41767 void *argp1 = 0 ;
41768 int res1 = 0 ;
41769 void *argp2 = 0 ;
41770 int res2 = 0 ;
41771 PyObject * obj0 = 0 ;
41772 PyObject * obj1 = 0 ;
41773 char * kwnames[] = {
41774 (char *) "self",(char *) "sizer", NULL
41775 };
41776
41777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41779 if (!SWIG_IsOK(res1)) {
41780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41781 }
41782 arg1 = reinterpret_cast< wxWindow * >(argp1);
41783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41784 if (!SWIG_IsOK(res2)) {
41785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41786 }
41787 arg2 = reinterpret_cast< wxSizer * >(argp2);
41788 {
41789 PyThreadState* __tstate = wxPyBeginAllowThreads();
41790 (arg1)->SetContainingSizer(arg2);
41791 wxPyEndAllowThreads(__tstate);
41792 if (PyErr_Occurred()) SWIG_fail;
41793 }
41794 resultobj = SWIG_Py_Void();
41795 return resultobj;
41796 fail:
41797 return NULL;
41798 }
41799
41800
41801 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41802 PyObject *resultobj = 0;
41803 wxWindow *arg1 = (wxWindow *) 0 ;
41804 wxSizer *result = 0 ;
41805 void *argp1 = 0 ;
41806 int res1 = 0 ;
41807 PyObject *swig_obj[1] ;
41808
41809 if (!args) SWIG_fail;
41810 swig_obj[0] = args;
41811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41812 if (!SWIG_IsOK(res1)) {
41813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41814 }
41815 arg1 = reinterpret_cast< wxWindow * >(argp1);
41816 {
41817 PyThreadState* __tstate = wxPyBeginAllowThreads();
41818 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41819 wxPyEndAllowThreads(__tstate);
41820 if (PyErr_Occurred()) SWIG_fail;
41821 }
41822 {
41823 resultobj = wxPyMake_wxObject(result, (bool)0);
41824 }
41825 return resultobj;
41826 fail:
41827 return NULL;
41828 }
41829
41830
41831 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41832 PyObject *resultobj = 0;
41833 wxWindow *arg1 = (wxWindow *) 0 ;
41834 void *argp1 = 0 ;
41835 int res1 = 0 ;
41836 PyObject *swig_obj[1] ;
41837
41838 if (!args) SWIG_fail;
41839 swig_obj[0] = args;
41840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41841 if (!SWIG_IsOK(res1)) {
41842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41843 }
41844 arg1 = reinterpret_cast< wxWindow * >(argp1);
41845 {
41846 PyThreadState* __tstate = wxPyBeginAllowThreads();
41847 (arg1)->InheritAttributes();
41848 wxPyEndAllowThreads(__tstate);
41849 if (PyErr_Occurred()) SWIG_fail;
41850 }
41851 resultobj = SWIG_Py_Void();
41852 return resultobj;
41853 fail:
41854 return NULL;
41855 }
41856
41857
41858 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41859 PyObject *resultobj = 0;
41860 wxWindow *arg1 = (wxWindow *) 0 ;
41861 bool result;
41862 void *argp1 = 0 ;
41863 int res1 = 0 ;
41864 PyObject *swig_obj[1] ;
41865
41866 if (!args) SWIG_fail;
41867 swig_obj[0] = args;
41868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41869 if (!SWIG_IsOK(res1)) {
41870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41871 }
41872 arg1 = reinterpret_cast< wxWindow * >(argp1);
41873 {
41874 PyThreadState* __tstate = wxPyBeginAllowThreads();
41875 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41876 wxPyEndAllowThreads(__tstate);
41877 if (PyErr_Occurred()) SWIG_fail;
41878 }
41879 {
41880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41881 }
41882 return resultobj;
41883 fail:
41884 return NULL;
41885 }
41886
41887
41888 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41889 PyObject *resultobj = 0;
41890 wxWindow *arg1 = (wxWindow *) 0 ;
41891 bool result;
41892 void *argp1 = 0 ;
41893 int res1 = 0 ;
41894 PyObject *swig_obj[1] ;
41895
41896 if (!args) SWIG_fail;
41897 swig_obj[0] = args;
41898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41899 if (!SWIG_IsOK(res1)) {
41900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41901 }
41902 arg1 = reinterpret_cast< wxWindow * >(argp1);
41903 {
41904 PyThreadState* __tstate = wxPyBeginAllowThreads();
41905 result = (bool)(arg1)->CanSetTransparent();
41906 wxPyEndAllowThreads(__tstate);
41907 if (PyErr_Occurred()) SWIG_fail;
41908 }
41909 {
41910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41911 }
41912 return resultobj;
41913 fail:
41914 return NULL;
41915 }
41916
41917
41918 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41919 PyObject *resultobj = 0;
41920 wxWindow *arg1 = (wxWindow *) 0 ;
41921 byte arg2 ;
41922 bool result;
41923 void *argp1 = 0 ;
41924 int res1 = 0 ;
41925 unsigned char val2 ;
41926 int ecode2 = 0 ;
41927 PyObject * obj0 = 0 ;
41928 PyObject * obj1 = 0 ;
41929 char * kwnames[] = {
41930 (char *) "self",(char *) "alpha", NULL
41931 };
41932
41933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41935 if (!SWIG_IsOK(res1)) {
41936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41937 }
41938 arg1 = reinterpret_cast< wxWindow * >(argp1);
41939 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41940 if (!SWIG_IsOK(ecode2)) {
41941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41942 }
41943 arg2 = static_cast< byte >(val2);
41944 {
41945 PyThreadState* __tstate = wxPyBeginAllowThreads();
41946 result = (bool)(arg1)->SetTransparent(arg2);
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 {
41951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41952 }
41953 return resultobj;
41954 fail:
41955 return NULL;
41956 }
41957
41958
41959 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41960 PyObject *obj;
41961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41962 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41963 return SWIG_Py_Void();
41964 }
41965
41966 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41967 return SWIG_Python_InitShadowInstance(args);
41968 }
41969
41970 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41971 PyObject *resultobj = 0;
41972 long arg1 ;
41973 wxWindow *arg2 = (wxWindow *) NULL ;
41974 wxWindow *result = 0 ;
41975 long val1 ;
41976 int ecode1 = 0 ;
41977 void *argp2 = 0 ;
41978 int res2 = 0 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 char * kwnames[] = {
41982 (char *) "id",(char *) "parent", NULL
41983 };
41984
41985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41986 ecode1 = SWIG_AsVal_long(obj0, &val1);
41987 if (!SWIG_IsOK(ecode1)) {
41988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41989 }
41990 arg1 = static_cast< long >(val1);
41991 if (obj1) {
41992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41993 if (!SWIG_IsOK(res2)) {
41994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41995 }
41996 arg2 = reinterpret_cast< wxWindow * >(argp2);
41997 }
41998 {
41999 if (!wxPyCheckForApp()) SWIG_fail;
42000 PyThreadState* __tstate = wxPyBeginAllowThreads();
42001 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
42002 wxPyEndAllowThreads(__tstate);
42003 if (PyErr_Occurred()) SWIG_fail;
42004 }
42005 {
42006 resultobj = wxPyMake_wxObject(result, 0);
42007 }
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj = 0;
42016 wxString *arg1 = 0 ;
42017 wxWindow *arg2 = (wxWindow *) NULL ;
42018 wxWindow *result = 0 ;
42019 bool temp1 = false ;
42020 void *argp2 = 0 ;
42021 int res2 = 0 ;
42022 PyObject * obj0 = 0 ;
42023 PyObject * obj1 = 0 ;
42024 char * kwnames[] = {
42025 (char *) "name",(char *) "parent", NULL
42026 };
42027
42028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
42029 {
42030 arg1 = wxString_in_helper(obj0);
42031 if (arg1 == NULL) SWIG_fail;
42032 temp1 = true;
42033 }
42034 if (obj1) {
42035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42036 if (!SWIG_IsOK(res2)) {
42037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
42038 }
42039 arg2 = reinterpret_cast< wxWindow * >(argp2);
42040 }
42041 {
42042 if (!wxPyCheckForApp()) SWIG_fail;
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
42045 wxPyEndAllowThreads(__tstate);
42046 if (PyErr_Occurred()) SWIG_fail;
42047 }
42048 {
42049 resultobj = wxPyMake_wxObject(result, 0);
42050 }
42051 {
42052 if (temp1)
42053 delete arg1;
42054 }
42055 return resultobj;
42056 fail:
42057 {
42058 if (temp1)
42059 delete arg1;
42060 }
42061 return NULL;
42062 }
42063
42064
42065 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42066 PyObject *resultobj = 0;
42067 wxString *arg1 = 0 ;
42068 wxWindow *arg2 = (wxWindow *) NULL ;
42069 wxWindow *result = 0 ;
42070 bool temp1 = false ;
42071 void *argp2 = 0 ;
42072 int res2 = 0 ;
42073 PyObject * obj0 = 0 ;
42074 PyObject * obj1 = 0 ;
42075 char * kwnames[] = {
42076 (char *) "label",(char *) "parent", NULL
42077 };
42078
42079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42080 {
42081 arg1 = wxString_in_helper(obj0);
42082 if (arg1 == NULL) SWIG_fail;
42083 temp1 = true;
42084 }
42085 if (obj1) {
42086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42087 if (!SWIG_IsOK(res2)) {
42088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
42089 }
42090 arg2 = reinterpret_cast< wxWindow * >(argp2);
42091 }
42092 {
42093 if (!wxPyCheckForApp()) SWIG_fail;
42094 PyThreadState* __tstate = wxPyBeginAllowThreads();
42095 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
42096 wxPyEndAllowThreads(__tstate);
42097 if (PyErr_Occurred()) SWIG_fail;
42098 }
42099 {
42100 resultobj = wxPyMake_wxObject(result, 0);
42101 }
42102 {
42103 if (temp1)
42104 delete arg1;
42105 }
42106 return resultobj;
42107 fail:
42108 {
42109 if (temp1)
42110 delete arg1;
42111 }
42112 return NULL;
42113 }
42114
42115
42116 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42117 PyObject *resultobj = 0;
42118 wxWindow *arg1 = (wxWindow *) 0 ;
42119 unsigned long arg2 ;
42120 wxWindow *result = 0 ;
42121 void *argp1 = 0 ;
42122 int res1 = 0 ;
42123 unsigned long val2 ;
42124 int ecode2 = 0 ;
42125 PyObject * obj0 = 0 ;
42126 PyObject * obj1 = 0 ;
42127 char * kwnames[] = {
42128 (char *) "parent",(char *) "_hWnd", NULL
42129 };
42130
42131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
42132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
42133 if (!SWIG_IsOK(res1)) {
42134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
42135 }
42136 arg1 = reinterpret_cast< wxWindow * >(argp1);
42137 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
42138 if (!SWIG_IsOK(ecode2)) {
42139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
42140 }
42141 arg2 = static_cast< unsigned long >(val2);
42142 {
42143 if (!wxPyCheckForApp()) SWIG_fail;
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
42146 wxPyEndAllowThreads(__tstate);
42147 if (PyErr_Occurred()) SWIG_fail;
42148 }
42149 {
42150 resultobj = wxPyMake_wxObject(result, 0);
42151 }
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42159 PyObject *resultobj = 0;
42160 PyObject *result = 0 ;
42161
42162 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
42163 {
42164 PyThreadState* __tstate = wxPyBeginAllowThreads();
42165 result = (PyObject *)GetTopLevelWindows();
42166 wxPyEndAllowThreads(__tstate);
42167 if (PyErr_Occurred()) SWIG_fail;
42168 }
42169 resultobj = result;
42170 return resultobj;
42171 fail:
42172 return NULL;
42173 }
42174
42175
42176 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42177 PyObject *resultobj = 0;
42178 wxValidator *result = 0 ;
42179
42180 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
42181 {
42182 PyThreadState* __tstate = wxPyBeginAllowThreads();
42183 result = (wxValidator *)new wxValidator();
42184 wxPyEndAllowThreads(__tstate);
42185 if (PyErr_Occurred()) SWIG_fail;
42186 }
42187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
42188 return resultobj;
42189 fail:
42190 return NULL;
42191 }
42192
42193
42194 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42195 PyObject *resultobj = 0;
42196 wxValidator *arg1 = (wxValidator *) 0 ;
42197 wxValidator *result = 0 ;
42198 void *argp1 = 0 ;
42199 int res1 = 0 ;
42200 PyObject *swig_obj[1] ;
42201
42202 if (!args) SWIG_fail;
42203 swig_obj[0] = args;
42204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42205 if (!SWIG_IsOK(res1)) {
42206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
42207 }
42208 arg1 = reinterpret_cast< wxValidator * >(argp1);
42209 {
42210 PyThreadState* __tstate = wxPyBeginAllowThreads();
42211 result = (wxValidator *)(arg1)->Clone();
42212 wxPyEndAllowThreads(__tstate);
42213 if (PyErr_Occurred()) SWIG_fail;
42214 }
42215 {
42216 resultobj = wxPyMake_wxObject(result, 0);
42217 }
42218 return resultobj;
42219 fail:
42220 return NULL;
42221 }
42222
42223
42224 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42225 PyObject *resultobj = 0;
42226 wxValidator *arg1 = (wxValidator *) 0 ;
42227 wxWindow *arg2 = (wxWindow *) 0 ;
42228 bool result;
42229 void *argp1 = 0 ;
42230 int res1 = 0 ;
42231 void *argp2 = 0 ;
42232 int res2 = 0 ;
42233 PyObject * obj0 = 0 ;
42234 PyObject * obj1 = 0 ;
42235 char * kwnames[] = {
42236 (char *) "self",(char *) "parent", NULL
42237 };
42238
42239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
42240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42241 if (!SWIG_IsOK(res1)) {
42242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
42243 }
42244 arg1 = reinterpret_cast< wxValidator * >(argp1);
42245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42246 if (!SWIG_IsOK(res2)) {
42247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
42248 }
42249 arg2 = reinterpret_cast< wxWindow * >(argp2);
42250 {
42251 PyThreadState* __tstate = wxPyBeginAllowThreads();
42252 result = (bool)(arg1)->Validate(arg2);
42253 wxPyEndAllowThreads(__tstate);
42254 if (PyErr_Occurred()) SWIG_fail;
42255 }
42256 {
42257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42258 }
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42266 PyObject *resultobj = 0;
42267 wxValidator *arg1 = (wxValidator *) 0 ;
42268 bool result;
42269 void *argp1 = 0 ;
42270 int res1 = 0 ;
42271 PyObject *swig_obj[1] ;
42272
42273 if (!args) SWIG_fail;
42274 swig_obj[0] = args;
42275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42276 if (!SWIG_IsOK(res1)) {
42277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42278 }
42279 arg1 = reinterpret_cast< wxValidator * >(argp1);
42280 {
42281 PyThreadState* __tstate = wxPyBeginAllowThreads();
42282 result = (bool)(arg1)->TransferToWindow();
42283 wxPyEndAllowThreads(__tstate);
42284 if (PyErr_Occurred()) SWIG_fail;
42285 }
42286 {
42287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42288 }
42289 return resultobj;
42290 fail:
42291 return NULL;
42292 }
42293
42294
42295 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42296 PyObject *resultobj = 0;
42297 wxValidator *arg1 = (wxValidator *) 0 ;
42298 bool result;
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_wxValidator, 0 | 0 );
42306 if (!SWIG_IsOK(res1)) {
42307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42308 }
42309 arg1 = reinterpret_cast< wxValidator * >(argp1);
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 result = (bool)(arg1)->TransferFromWindow();
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 {
42317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42318 }
42319 return resultobj;
42320 fail:
42321 return NULL;
42322 }
42323
42324
42325 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42326 PyObject *resultobj = 0;
42327 wxValidator *arg1 = (wxValidator *) 0 ;
42328 wxWindow *result = 0 ;
42329 void *argp1 = 0 ;
42330 int res1 = 0 ;
42331 PyObject *swig_obj[1] ;
42332
42333 if (!args) SWIG_fail;
42334 swig_obj[0] = args;
42335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42336 if (!SWIG_IsOK(res1)) {
42337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42338 }
42339 arg1 = reinterpret_cast< wxValidator * >(argp1);
42340 {
42341 PyThreadState* __tstate = wxPyBeginAllowThreads();
42342 result = (wxWindow *)(arg1)->GetWindow();
42343 wxPyEndAllowThreads(__tstate);
42344 if (PyErr_Occurred()) SWIG_fail;
42345 }
42346 {
42347 resultobj = wxPyMake_wxObject(result, 0);
42348 }
42349 return resultobj;
42350 fail:
42351 return NULL;
42352 }
42353
42354
42355 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42356 PyObject *resultobj = 0;
42357 wxValidator *arg1 = (wxValidator *) 0 ;
42358 wxWindow *arg2 = (wxWindow *) 0 ;
42359 void *argp1 = 0 ;
42360 int res1 = 0 ;
42361 void *argp2 = 0 ;
42362 int res2 = 0 ;
42363 PyObject * obj0 = 0 ;
42364 PyObject * obj1 = 0 ;
42365 char * kwnames[] = {
42366 (char *) "self",(char *) "window", NULL
42367 };
42368
42369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
42370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42371 if (!SWIG_IsOK(res1)) {
42372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42373 }
42374 arg1 = reinterpret_cast< wxValidator * >(argp1);
42375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42376 if (!SWIG_IsOK(res2)) {
42377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
42378 }
42379 arg2 = reinterpret_cast< wxWindow * >(argp2);
42380 {
42381 PyThreadState* __tstate = wxPyBeginAllowThreads();
42382 (arg1)->SetWindow(arg2);
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 resultobj = SWIG_Py_Void();
42387 return resultobj;
42388 fail:
42389 return NULL;
42390 }
42391
42392
42393 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42394 PyObject *resultobj = 0;
42395 bool result;
42396
42397 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
42398 {
42399 PyThreadState* __tstate = wxPyBeginAllowThreads();
42400 result = (bool)wxValidator::IsSilent();
42401 wxPyEndAllowThreads(__tstate);
42402 if (PyErr_Occurred()) SWIG_fail;
42403 }
42404 {
42405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42406 }
42407 return resultobj;
42408 fail:
42409 return NULL;
42410 }
42411
42412
42413 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42414 PyObject *resultobj = 0;
42415 int arg1 = (int) true ;
42416 int val1 ;
42417 int ecode1 = 0 ;
42418 PyObject * obj0 = 0 ;
42419 char * kwnames[] = {
42420 (char *) "doIt", NULL
42421 };
42422
42423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
42424 if (obj0) {
42425 ecode1 = SWIG_AsVal_int(obj0, &val1);
42426 if (!SWIG_IsOK(ecode1)) {
42427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
42428 }
42429 arg1 = static_cast< int >(val1);
42430 }
42431 {
42432 PyThreadState* __tstate = wxPyBeginAllowThreads();
42433 wxValidator::SetBellOnError(arg1);
42434 wxPyEndAllowThreads(__tstate);
42435 if (PyErr_Occurred()) SWIG_fail;
42436 }
42437 resultobj = SWIG_Py_Void();
42438 return resultobj;
42439 fail:
42440 return NULL;
42441 }
42442
42443
42444 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42445 PyObject *obj;
42446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42447 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
42448 return SWIG_Py_Void();
42449 }
42450
42451 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42452 return SWIG_Python_InitShadowInstance(args);
42453 }
42454
42455 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42456 PyObject *resultobj = 0;
42457 wxPyValidator *result = 0 ;
42458
42459 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
42460 {
42461 PyThreadState* __tstate = wxPyBeginAllowThreads();
42462 result = (wxPyValidator *)new wxPyValidator();
42463 wxPyEndAllowThreads(__tstate);
42464 if (PyErr_Occurred()) SWIG_fail;
42465 }
42466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
42467 return resultobj;
42468 fail:
42469 return NULL;
42470 }
42471
42472
42473 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42474 PyObject *resultobj = 0;
42475 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
42476 PyObject *arg2 = (PyObject *) 0 ;
42477 PyObject *arg3 = (PyObject *) 0 ;
42478 int arg4 = (int) 1 ;
42479 void *argp1 = 0 ;
42480 int res1 = 0 ;
42481 int val4 ;
42482 int ecode4 = 0 ;
42483 PyObject * obj0 = 0 ;
42484 PyObject * obj1 = 0 ;
42485 PyObject * obj2 = 0 ;
42486 PyObject * obj3 = 0 ;
42487 char * kwnames[] = {
42488 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
42489 };
42490
42491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
42493 if (!SWIG_IsOK(res1)) {
42494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
42495 }
42496 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
42497 arg2 = obj1;
42498 arg3 = obj2;
42499 if (obj3) {
42500 ecode4 = SWIG_AsVal_int(obj3, &val4);
42501 if (!SWIG_IsOK(ecode4)) {
42502 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42503 }
42504 arg4 = static_cast< int >(val4);
42505 }
42506 {
42507 PyThreadState* __tstate = wxPyBeginAllowThreads();
42508 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42509 wxPyEndAllowThreads(__tstate);
42510 if (PyErr_Occurred()) SWIG_fail;
42511 }
42512 resultobj = SWIG_Py_Void();
42513 return resultobj;
42514 fail:
42515 return NULL;
42516 }
42517
42518
42519 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42520 PyObject *obj;
42521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42522 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42523 return SWIG_Py_Void();
42524 }
42525
42526 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42527 return SWIG_Python_InitShadowInstance(args);
42528 }
42529
42530 SWIGINTERN int DefaultValidator_set(PyObject *) {
42531 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42532 return 1;
42533 }
42534
42535
42536 SWIGINTERN PyObject *DefaultValidator_get(void) {
42537 PyObject *pyobj = 0;
42538
42539 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42540 return pyobj;
42541 }
42542
42543
42544 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42545 PyObject *resultobj = 0;
42546 wxString const &arg1_defvalue = wxPyEmptyString ;
42547 wxString *arg1 = (wxString *) &arg1_defvalue ;
42548 long arg2 = (long) 0 ;
42549 wxMenu *result = 0 ;
42550 bool temp1 = false ;
42551 long val2 ;
42552 int ecode2 = 0 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 char * kwnames[] = {
42556 (char *) "title",(char *) "style", NULL
42557 };
42558
42559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42560 if (obj0) {
42561 {
42562 arg1 = wxString_in_helper(obj0);
42563 if (arg1 == NULL) SWIG_fail;
42564 temp1 = true;
42565 }
42566 }
42567 if (obj1) {
42568 ecode2 = SWIG_AsVal_long(obj1, &val2);
42569 if (!SWIG_IsOK(ecode2)) {
42570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42571 }
42572 arg2 = static_cast< long >(val2);
42573 }
42574 {
42575 if (!wxPyCheckForApp()) SWIG_fail;
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42582 {
42583 if (temp1)
42584 delete arg1;
42585 }
42586 return resultobj;
42587 fail:
42588 {
42589 if (temp1)
42590 delete arg1;
42591 }
42592 return NULL;
42593 }
42594
42595
42596 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42597 PyObject *resultobj = 0;
42598 wxMenu *arg1 = (wxMenu *) 0 ;
42599 int arg2 ;
42600 wxString const &arg3_defvalue = wxPyEmptyString ;
42601 wxString *arg3 = (wxString *) &arg3_defvalue ;
42602 wxString const &arg4_defvalue = wxPyEmptyString ;
42603 wxString *arg4 = (wxString *) &arg4_defvalue ;
42604 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42605 wxMenuItem *result = 0 ;
42606 void *argp1 = 0 ;
42607 int res1 = 0 ;
42608 int val2 ;
42609 int ecode2 = 0 ;
42610 bool temp3 = false ;
42611 bool temp4 = false ;
42612 int val5 ;
42613 int ecode5 = 0 ;
42614 PyObject * obj0 = 0 ;
42615 PyObject * obj1 = 0 ;
42616 PyObject * obj2 = 0 ;
42617 PyObject * obj3 = 0 ;
42618 PyObject * obj4 = 0 ;
42619 char * kwnames[] = {
42620 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42621 };
42622
42623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42625 if (!SWIG_IsOK(res1)) {
42626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42627 }
42628 arg1 = reinterpret_cast< wxMenu * >(argp1);
42629 ecode2 = SWIG_AsVal_int(obj1, &val2);
42630 if (!SWIG_IsOK(ecode2)) {
42631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42632 }
42633 arg2 = static_cast< int >(val2);
42634 if (obj2) {
42635 {
42636 arg3 = wxString_in_helper(obj2);
42637 if (arg3 == NULL) SWIG_fail;
42638 temp3 = true;
42639 }
42640 }
42641 if (obj3) {
42642 {
42643 arg4 = wxString_in_helper(obj3);
42644 if (arg4 == NULL) SWIG_fail;
42645 temp4 = true;
42646 }
42647 }
42648 if (obj4) {
42649 ecode5 = SWIG_AsVal_int(obj4, &val5);
42650 if (!SWIG_IsOK(ecode5)) {
42651 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42652 }
42653 arg5 = static_cast< wxItemKind >(val5);
42654 }
42655 {
42656 PyThreadState* __tstate = wxPyBeginAllowThreads();
42657 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42658 wxPyEndAllowThreads(__tstate);
42659 if (PyErr_Occurred()) SWIG_fail;
42660 }
42661 {
42662 resultobj = wxPyMake_wxObject(result, (bool)0);
42663 }
42664 {
42665 if (temp3)
42666 delete arg3;
42667 }
42668 {
42669 if (temp4)
42670 delete arg4;
42671 }
42672 return resultobj;
42673 fail:
42674 {
42675 if (temp3)
42676 delete arg3;
42677 }
42678 {
42679 if (temp4)
42680 delete arg4;
42681 }
42682 return NULL;
42683 }
42684
42685
42686 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42687 PyObject *resultobj = 0;
42688 wxMenu *arg1 = (wxMenu *) 0 ;
42689 wxMenuItem *result = 0 ;
42690 void *argp1 = 0 ;
42691 int res1 = 0 ;
42692 PyObject *swig_obj[1] ;
42693
42694 if (!args) SWIG_fail;
42695 swig_obj[0] = args;
42696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42697 if (!SWIG_IsOK(res1)) {
42698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42699 }
42700 arg1 = reinterpret_cast< wxMenu * >(argp1);
42701 {
42702 PyThreadState* __tstate = wxPyBeginAllowThreads();
42703 result = (wxMenuItem *)(arg1)->AppendSeparator();
42704 wxPyEndAllowThreads(__tstate);
42705 if (PyErr_Occurred()) SWIG_fail;
42706 }
42707 {
42708 resultobj = wxPyMake_wxObject(result, (bool)0);
42709 }
42710 return resultobj;
42711 fail:
42712 return NULL;
42713 }
42714
42715
42716 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42717 PyObject *resultobj = 0;
42718 wxMenu *arg1 = (wxMenu *) 0 ;
42719 int arg2 ;
42720 wxString *arg3 = 0 ;
42721 wxString const &arg4_defvalue = wxPyEmptyString ;
42722 wxString *arg4 = (wxString *) &arg4_defvalue ;
42723 wxMenuItem *result = 0 ;
42724 void *argp1 = 0 ;
42725 int res1 = 0 ;
42726 int val2 ;
42727 int ecode2 = 0 ;
42728 bool temp3 = false ;
42729 bool temp4 = false ;
42730 PyObject * obj0 = 0 ;
42731 PyObject * obj1 = 0 ;
42732 PyObject * obj2 = 0 ;
42733 PyObject * obj3 = 0 ;
42734 char * kwnames[] = {
42735 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42736 };
42737
42738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42740 if (!SWIG_IsOK(res1)) {
42741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42742 }
42743 arg1 = reinterpret_cast< wxMenu * >(argp1);
42744 ecode2 = SWIG_AsVal_int(obj1, &val2);
42745 if (!SWIG_IsOK(ecode2)) {
42746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42747 }
42748 arg2 = static_cast< int >(val2);
42749 {
42750 arg3 = wxString_in_helper(obj2);
42751 if (arg3 == NULL) SWIG_fail;
42752 temp3 = true;
42753 }
42754 if (obj3) {
42755 {
42756 arg4 = wxString_in_helper(obj3);
42757 if (arg4 == NULL) SWIG_fail;
42758 temp4 = true;
42759 }
42760 }
42761 {
42762 PyThreadState* __tstate = wxPyBeginAllowThreads();
42763 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42764 wxPyEndAllowThreads(__tstate);
42765 if (PyErr_Occurred()) SWIG_fail;
42766 }
42767 {
42768 resultobj = wxPyMake_wxObject(result, (bool)0);
42769 }
42770 {
42771 if (temp3)
42772 delete arg3;
42773 }
42774 {
42775 if (temp4)
42776 delete arg4;
42777 }
42778 return resultobj;
42779 fail:
42780 {
42781 if (temp3)
42782 delete arg3;
42783 }
42784 {
42785 if (temp4)
42786 delete arg4;
42787 }
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42793 PyObject *resultobj = 0;
42794 wxMenu *arg1 = (wxMenu *) 0 ;
42795 int arg2 ;
42796 wxString *arg3 = 0 ;
42797 wxString const &arg4_defvalue = wxPyEmptyString ;
42798 wxString *arg4 = (wxString *) &arg4_defvalue ;
42799 wxMenuItem *result = 0 ;
42800 void *argp1 = 0 ;
42801 int res1 = 0 ;
42802 int val2 ;
42803 int ecode2 = 0 ;
42804 bool temp3 = false ;
42805 bool temp4 = false ;
42806 PyObject * obj0 = 0 ;
42807 PyObject * obj1 = 0 ;
42808 PyObject * obj2 = 0 ;
42809 PyObject * obj3 = 0 ;
42810 char * kwnames[] = {
42811 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42812 };
42813
42814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42816 if (!SWIG_IsOK(res1)) {
42817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42818 }
42819 arg1 = reinterpret_cast< wxMenu * >(argp1);
42820 ecode2 = SWIG_AsVal_int(obj1, &val2);
42821 if (!SWIG_IsOK(ecode2)) {
42822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42823 }
42824 arg2 = static_cast< int >(val2);
42825 {
42826 arg3 = wxString_in_helper(obj2);
42827 if (arg3 == NULL) SWIG_fail;
42828 temp3 = true;
42829 }
42830 if (obj3) {
42831 {
42832 arg4 = wxString_in_helper(obj3);
42833 if (arg4 == NULL) SWIG_fail;
42834 temp4 = true;
42835 }
42836 }
42837 {
42838 PyThreadState* __tstate = wxPyBeginAllowThreads();
42839 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42840 wxPyEndAllowThreads(__tstate);
42841 if (PyErr_Occurred()) SWIG_fail;
42842 }
42843 {
42844 resultobj = wxPyMake_wxObject(result, (bool)0);
42845 }
42846 {
42847 if (temp3)
42848 delete arg3;
42849 }
42850 {
42851 if (temp4)
42852 delete arg4;
42853 }
42854 return resultobj;
42855 fail:
42856 {
42857 if (temp3)
42858 delete arg3;
42859 }
42860 {
42861 if (temp4)
42862 delete arg4;
42863 }
42864 return NULL;
42865 }
42866
42867
42868 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42869 PyObject *resultobj = 0;
42870 wxMenu *arg1 = (wxMenu *) 0 ;
42871 int arg2 ;
42872 wxString *arg3 = 0 ;
42873 wxMenu *arg4 = (wxMenu *) 0 ;
42874 wxString const &arg5_defvalue = wxPyEmptyString ;
42875 wxString *arg5 = (wxString *) &arg5_defvalue ;
42876 wxMenuItem *result = 0 ;
42877 void *argp1 = 0 ;
42878 int res1 = 0 ;
42879 int val2 ;
42880 int ecode2 = 0 ;
42881 bool temp3 = false ;
42882 void *argp4 = 0 ;
42883 int res4 = 0 ;
42884 bool temp5 = false ;
42885 PyObject * obj0 = 0 ;
42886 PyObject * obj1 = 0 ;
42887 PyObject * obj2 = 0 ;
42888 PyObject * obj3 = 0 ;
42889 PyObject * obj4 = 0 ;
42890 char * kwnames[] = {
42891 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42892 };
42893
42894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42896 if (!SWIG_IsOK(res1)) {
42897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42898 }
42899 arg1 = reinterpret_cast< wxMenu * >(argp1);
42900 ecode2 = SWIG_AsVal_int(obj1, &val2);
42901 if (!SWIG_IsOK(ecode2)) {
42902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42903 }
42904 arg2 = static_cast< int >(val2);
42905 {
42906 arg3 = wxString_in_helper(obj2);
42907 if (arg3 == NULL) SWIG_fail;
42908 temp3 = true;
42909 }
42910 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42911 if (!SWIG_IsOK(res4)) {
42912 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42913 }
42914 arg4 = reinterpret_cast< wxMenu * >(argp4);
42915 if (obj4) {
42916 {
42917 arg5 = wxString_in_helper(obj4);
42918 if (arg5 == NULL) SWIG_fail;
42919 temp5 = true;
42920 }
42921 }
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42925 wxPyEndAllowThreads(__tstate);
42926 if (PyErr_Occurred()) SWIG_fail;
42927 }
42928 {
42929 resultobj = wxPyMake_wxObject(result, (bool)0);
42930 }
42931 {
42932 if (temp3)
42933 delete arg3;
42934 }
42935 {
42936 if (temp5)
42937 delete arg5;
42938 }
42939 return resultobj;
42940 fail:
42941 {
42942 if (temp3)
42943 delete arg3;
42944 }
42945 {
42946 if (temp5)
42947 delete arg5;
42948 }
42949 return NULL;
42950 }
42951
42952
42953 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42954 PyObject *resultobj = 0;
42955 wxMenu *arg1 = (wxMenu *) 0 ;
42956 wxMenu *arg2 = (wxMenu *) 0 ;
42957 wxString *arg3 = 0 ;
42958 wxString const &arg4_defvalue = wxPyEmptyString ;
42959 wxString *arg4 = (wxString *) &arg4_defvalue ;
42960 wxMenuItem *result = 0 ;
42961 void *argp1 = 0 ;
42962 int res1 = 0 ;
42963 void *argp2 = 0 ;
42964 int res2 = 0 ;
42965 bool temp3 = false ;
42966 bool temp4 = false ;
42967 PyObject * obj0 = 0 ;
42968 PyObject * obj1 = 0 ;
42969 PyObject * obj2 = 0 ;
42970 PyObject * obj3 = 0 ;
42971 char * kwnames[] = {
42972 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42973 };
42974
42975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42977 if (!SWIG_IsOK(res1)) {
42978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42979 }
42980 arg1 = reinterpret_cast< wxMenu * >(argp1);
42981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42982 if (!SWIG_IsOK(res2)) {
42983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42984 }
42985 arg2 = reinterpret_cast< wxMenu * >(argp2);
42986 {
42987 arg3 = wxString_in_helper(obj2);
42988 if (arg3 == NULL) SWIG_fail;
42989 temp3 = true;
42990 }
42991 if (obj3) {
42992 {
42993 arg4 = wxString_in_helper(obj3);
42994 if (arg4 == NULL) SWIG_fail;
42995 temp4 = true;
42996 }
42997 }
42998 {
42999 PyThreadState* __tstate = wxPyBeginAllowThreads();
43000 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43001 wxPyEndAllowThreads(__tstate);
43002 if (PyErr_Occurred()) SWIG_fail;
43003 }
43004 {
43005 resultobj = wxPyMake_wxObject(result, (bool)0);
43006 }
43007 {
43008 if (temp3)
43009 delete arg3;
43010 }
43011 {
43012 if (temp4)
43013 delete arg4;
43014 }
43015 return resultobj;
43016 fail:
43017 {
43018 if (temp3)
43019 delete arg3;
43020 }
43021 {
43022 if (temp4)
43023 delete arg4;
43024 }
43025 return NULL;
43026 }
43027
43028
43029 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43030 PyObject *resultobj = 0;
43031 wxMenu *arg1 = (wxMenu *) 0 ;
43032 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43033 wxMenuItem *result = 0 ;
43034 void *argp1 = 0 ;
43035 int res1 = 0 ;
43036 int res2 = 0 ;
43037 PyObject * obj0 = 0 ;
43038 PyObject * obj1 = 0 ;
43039 char * kwnames[] = {
43040 (char *) "self",(char *) "item", NULL
43041 };
43042
43043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
43044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43045 if (!SWIG_IsOK(res1)) {
43046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43047 }
43048 arg1 = reinterpret_cast< wxMenu * >(argp1);
43049 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43050 if (!SWIG_IsOK(res2)) {
43051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43052 }
43053 {
43054 PyThreadState* __tstate = wxPyBeginAllowThreads();
43055 result = (wxMenuItem *)(arg1)->Append(arg2);
43056 wxPyEndAllowThreads(__tstate);
43057 if (PyErr_Occurred()) SWIG_fail;
43058 }
43059 {
43060 resultobj = wxPyMake_wxObject(result, (bool)0);
43061 }
43062 return resultobj;
43063 fail:
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43069 PyObject *resultobj = 0;
43070 wxMenu *arg1 = (wxMenu *) 0 ;
43071 size_t arg2 ;
43072 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
43073 wxMenuItem *result = 0 ;
43074 void *argp1 = 0 ;
43075 int res1 = 0 ;
43076 size_t val2 ;
43077 int ecode2 = 0 ;
43078 int res3 = 0 ;
43079 PyObject * obj0 = 0 ;
43080 PyObject * obj1 = 0 ;
43081 PyObject * obj2 = 0 ;
43082 char * kwnames[] = {
43083 (char *) "self",(char *) "pos",(char *) "item", NULL
43084 };
43085
43086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43088 if (!SWIG_IsOK(res1)) {
43089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43090 }
43091 arg1 = reinterpret_cast< wxMenu * >(argp1);
43092 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43093 if (!SWIG_IsOK(ecode2)) {
43094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
43095 }
43096 arg2 = static_cast< size_t >(val2);
43097 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43098 if (!SWIG_IsOK(res3)) {
43099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
43100 }
43101 {
43102 PyThreadState* __tstate = wxPyBeginAllowThreads();
43103 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
43104 wxPyEndAllowThreads(__tstate);
43105 if (PyErr_Occurred()) SWIG_fail;
43106 }
43107 {
43108 resultobj = wxPyMake_wxObject(result, (bool)0);
43109 }
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43117 PyObject *resultobj = 0;
43118 wxMenu *arg1 = (wxMenu *) 0 ;
43119 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43120 wxMenuItem *result = 0 ;
43121 void *argp1 = 0 ;
43122 int res1 = 0 ;
43123 int res2 = 0 ;
43124 PyObject * obj0 = 0 ;
43125 PyObject * obj1 = 0 ;
43126 char * kwnames[] = {
43127 (char *) "self",(char *) "item", NULL
43128 };
43129
43130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
43131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43132 if (!SWIG_IsOK(res1)) {
43133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43134 }
43135 arg1 = reinterpret_cast< wxMenu * >(argp1);
43136 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43137 if (!SWIG_IsOK(res2)) {
43138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43139 }
43140 {
43141 PyThreadState* __tstate = wxPyBeginAllowThreads();
43142 result = (wxMenuItem *)(arg1)->Prepend(arg2);
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 {
43147 resultobj = wxPyMake_wxObject(result, (bool)0);
43148 }
43149 return resultobj;
43150 fail:
43151 return NULL;
43152 }
43153
43154
43155 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43156 PyObject *resultobj = 0;
43157 wxMenu *arg1 = (wxMenu *) 0 ;
43158 void *argp1 = 0 ;
43159 int res1 = 0 ;
43160 PyObject *swig_obj[1] ;
43161
43162 if (!args) SWIG_fail;
43163 swig_obj[0] = args;
43164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43165 if (!SWIG_IsOK(res1)) {
43166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
43167 }
43168 arg1 = reinterpret_cast< wxMenu * >(argp1);
43169 {
43170 PyThreadState* __tstate = wxPyBeginAllowThreads();
43171 (arg1)->Break();
43172 wxPyEndAllowThreads(__tstate);
43173 if (PyErr_Occurred()) SWIG_fail;
43174 }
43175 resultobj = SWIG_Py_Void();
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43183 PyObject *resultobj = 0;
43184 wxMenu *arg1 = (wxMenu *) 0 ;
43185 size_t arg2 ;
43186 int arg3 ;
43187 wxString const &arg4_defvalue = wxPyEmptyString ;
43188 wxString *arg4 = (wxString *) &arg4_defvalue ;
43189 wxString const &arg5_defvalue = wxPyEmptyString ;
43190 wxString *arg5 = (wxString *) &arg5_defvalue ;
43191 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
43192 wxMenuItem *result = 0 ;
43193 void *argp1 = 0 ;
43194 int res1 = 0 ;
43195 size_t val2 ;
43196 int ecode2 = 0 ;
43197 int val3 ;
43198 int ecode3 = 0 ;
43199 bool temp4 = false ;
43200 bool temp5 = false ;
43201 int val6 ;
43202 int ecode6 = 0 ;
43203 PyObject * obj0 = 0 ;
43204 PyObject * obj1 = 0 ;
43205 PyObject * obj2 = 0 ;
43206 PyObject * obj3 = 0 ;
43207 PyObject * obj4 = 0 ;
43208 PyObject * obj5 = 0 ;
43209 char * kwnames[] = {
43210 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43211 };
43212
43213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43215 if (!SWIG_IsOK(res1)) {
43216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
43217 }
43218 arg1 = reinterpret_cast< wxMenu * >(argp1);
43219 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43220 if (!SWIG_IsOK(ecode2)) {
43221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
43222 }
43223 arg2 = static_cast< size_t >(val2);
43224 ecode3 = SWIG_AsVal_int(obj2, &val3);
43225 if (!SWIG_IsOK(ecode3)) {
43226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
43227 }
43228 arg3 = static_cast< int >(val3);
43229 if (obj3) {
43230 {
43231 arg4 = wxString_in_helper(obj3);
43232 if (arg4 == NULL) SWIG_fail;
43233 temp4 = true;
43234 }
43235 }
43236 if (obj4) {
43237 {
43238 arg5 = wxString_in_helper(obj4);
43239 if (arg5 == NULL) SWIG_fail;
43240 temp5 = true;
43241 }
43242 }
43243 if (obj5) {
43244 ecode6 = SWIG_AsVal_int(obj5, &val6);
43245 if (!SWIG_IsOK(ecode6)) {
43246 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
43247 }
43248 arg6 = static_cast< wxItemKind >(val6);
43249 }
43250 {
43251 PyThreadState* __tstate = wxPyBeginAllowThreads();
43252 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
43253 wxPyEndAllowThreads(__tstate);
43254 if (PyErr_Occurred()) SWIG_fail;
43255 }
43256 {
43257 resultobj = wxPyMake_wxObject(result, (bool)0);
43258 }
43259 {
43260 if (temp4)
43261 delete arg4;
43262 }
43263 {
43264 if (temp5)
43265 delete arg5;
43266 }
43267 return resultobj;
43268 fail:
43269 {
43270 if (temp4)
43271 delete arg4;
43272 }
43273 {
43274 if (temp5)
43275 delete arg5;
43276 }
43277 return NULL;
43278 }
43279
43280
43281 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43282 PyObject *resultobj = 0;
43283 wxMenu *arg1 = (wxMenu *) 0 ;
43284 size_t arg2 ;
43285 wxMenuItem *result = 0 ;
43286 void *argp1 = 0 ;
43287 int res1 = 0 ;
43288 size_t val2 ;
43289 int ecode2 = 0 ;
43290 PyObject * obj0 = 0 ;
43291 PyObject * obj1 = 0 ;
43292 char * kwnames[] = {
43293 (char *) "self",(char *) "pos", NULL
43294 };
43295
43296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
43297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43298 if (!SWIG_IsOK(res1)) {
43299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43300 }
43301 arg1 = reinterpret_cast< wxMenu * >(argp1);
43302 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43303 if (!SWIG_IsOK(ecode2)) {
43304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
43305 }
43306 arg2 = static_cast< size_t >(val2);
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 {
43314 resultobj = wxPyMake_wxObject(result, (bool)0);
43315 }
43316 return resultobj;
43317 fail:
43318 return NULL;
43319 }
43320
43321
43322 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43323 PyObject *resultobj = 0;
43324 wxMenu *arg1 = (wxMenu *) 0 ;
43325 size_t arg2 ;
43326 int arg3 ;
43327 wxString *arg4 = 0 ;
43328 wxString const &arg5_defvalue = wxPyEmptyString ;
43329 wxString *arg5 = (wxString *) &arg5_defvalue ;
43330 wxMenuItem *result = 0 ;
43331 void *argp1 = 0 ;
43332 int res1 = 0 ;
43333 size_t val2 ;
43334 int ecode2 = 0 ;
43335 int val3 ;
43336 int ecode3 = 0 ;
43337 bool temp4 = false ;
43338 bool temp5 = false ;
43339 PyObject * obj0 = 0 ;
43340 PyObject * obj1 = 0 ;
43341 PyObject * obj2 = 0 ;
43342 PyObject * obj3 = 0 ;
43343 PyObject * obj4 = 0 ;
43344 char * kwnames[] = {
43345 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43346 };
43347
43348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43350 if (!SWIG_IsOK(res1)) {
43351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43352 }
43353 arg1 = reinterpret_cast< wxMenu * >(argp1);
43354 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43355 if (!SWIG_IsOK(ecode2)) {
43356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
43357 }
43358 arg2 = static_cast< size_t >(val2);
43359 ecode3 = SWIG_AsVal_int(obj2, &val3);
43360 if (!SWIG_IsOK(ecode3)) {
43361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
43362 }
43363 arg3 = static_cast< int >(val3);
43364 {
43365 arg4 = wxString_in_helper(obj3);
43366 if (arg4 == NULL) SWIG_fail;
43367 temp4 = true;
43368 }
43369 if (obj4) {
43370 {
43371 arg5 = wxString_in_helper(obj4);
43372 if (arg5 == NULL) SWIG_fail;
43373 temp5 = true;
43374 }
43375 }
43376 {
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 {
43383 resultobj = wxPyMake_wxObject(result, (bool)0);
43384 }
43385 {
43386 if (temp4)
43387 delete arg4;
43388 }
43389 {
43390 if (temp5)
43391 delete arg5;
43392 }
43393 return resultobj;
43394 fail:
43395 {
43396 if (temp4)
43397 delete arg4;
43398 }
43399 {
43400 if (temp5)
43401 delete arg5;
43402 }
43403 return NULL;
43404 }
43405
43406
43407 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43408 PyObject *resultobj = 0;
43409 wxMenu *arg1 = (wxMenu *) 0 ;
43410 size_t arg2 ;
43411 int arg3 ;
43412 wxString *arg4 = 0 ;
43413 wxString const &arg5_defvalue = wxPyEmptyString ;
43414 wxString *arg5 = (wxString *) &arg5_defvalue ;
43415 wxMenuItem *result = 0 ;
43416 void *argp1 = 0 ;
43417 int res1 = 0 ;
43418 size_t val2 ;
43419 int ecode2 = 0 ;
43420 int val3 ;
43421 int ecode3 = 0 ;
43422 bool temp4 = false ;
43423 bool temp5 = false ;
43424 PyObject * obj0 = 0 ;
43425 PyObject * obj1 = 0 ;
43426 PyObject * obj2 = 0 ;
43427 PyObject * obj3 = 0 ;
43428 PyObject * obj4 = 0 ;
43429 char * kwnames[] = {
43430 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43431 };
43432
43433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43435 if (!SWIG_IsOK(res1)) {
43436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43437 }
43438 arg1 = reinterpret_cast< wxMenu * >(argp1);
43439 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43440 if (!SWIG_IsOK(ecode2)) {
43441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
43442 }
43443 arg2 = static_cast< size_t >(val2);
43444 ecode3 = SWIG_AsVal_int(obj2, &val3);
43445 if (!SWIG_IsOK(ecode3)) {
43446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
43447 }
43448 arg3 = static_cast< int >(val3);
43449 {
43450 arg4 = wxString_in_helper(obj3);
43451 if (arg4 == NULL) SWIG_fail;
43452 temp4 = true;
43453 }
43454 if (obj4) {
43455 {
43456 arg5 = wxString_in_helper(obj4);
43457 if (arg5 == NULL) SWIG_fail;
43458 temp5 = true;
43459 }
43460 }
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43464 wxPyEndAllowThreads(__tstate);
43465 if (PyErr_Occurred()) SWIG_fail;
43466 }
43467 {
43468 resultobj = wxPyMake_wxObject(result, (bool)0);
43469 }
43470 {
43471 if (temp4)
43472 delete arg4;
43473 }
43474 {
43475 if (temp5)
43476 delete arg5;
43477 }
43478 return resultobj;
43479 fail:
43480 {
43481 if (temp4)
43482 delete arg4;
43483 }
43484 {
43485 if (temp5)
43486 delete arg5;
43487 }
43488 return NULL;
43489 }
43490
43491
43492 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43493 PyObject *resultobj = 0;
43494 wxMenu *arg1 = (wxMenu *) 0 ;
43495 size_t arg2 ;
43496 int arg3 ;
43497 wxString *arg4 = 0 ;
43498 wxMenu *arg5 = (wxMenu *) 0 ;
43499 wxString const &arg6_defvalue = wxPyEmptyString ;
43500 wxString *arg6 = (wxString *) &arg6_defvalue ;
43501 wxMenuItem *result = 0 ;
43502 void *argp1 = 0 ;
43503 int res1 = 0 ;
43504 size_t val2 ;
43505 int ecode2 = 0 ;
43506 int val3 ;
43507 int ecode3 = 0 ;
43508 bool temp4 = false ;
43509 void *argp5 = 0 ;
43510 int res5 = 0 ;
43511 bool temp6 = false ;
43512 PyObject * obj0 = 0 ;
43513 PyObject * obj1 = 0 ;
43514 PyObject * obj2 = 0 ;
43515 PyObject * obj3 = 0 ;
43516 PyObject * obj4 = 0 ;
43517 PyObject * obj5 = 0 ;
43518 char * kwnames[] = {
43519 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43520 };
43521
43522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43524 if (!SWIG_IsOK(res1)) {
43525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43526 }
43527 arg1 = reinterpret_cast< wxMenu * >(argp1);
43528 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43529 if (!SWIG_IsOK(ecode2)) {
43530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43531 }
43532 arg2 = static_cast< size_t >(val2);
43533 ecode3 = SWIG_AsVal_int(obj2, &val3);
43534 if (!SWIG_IsOK(ecode3)) {
43535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43536 }
43537 arg3 = static_cast< int >(val3);
43538 {
43539 arg4 = wxString_in_helper(obj3);
43540 if (arg4 == NULL) SWIG_fail;
43541 temp4 = true;
43542 }
43543 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43544 if (!SWIG_IsOK(res5)) {
43545 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43546 }
43547 arg5 = reinterpret_cast< wxMenu * >(argp5);
43548 if (obj5) {
43549 {
43550 arg6 = wxString_in_helper(obj5);
43551 if (arg6 == NULL) SWIG_fail;
43552 temp6 = true;
43553 }
43554 }
43555 {
43556 PyThreadState* __tstate = wxPyBeginAllowThreads();
43557 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43558 wxPyEndAllowThreads(__tstate);
43559 if (PyErr_Occurred()) SWIG_fail;
43560 }
43561 {
43562 resultobj = wxPyMake_wxObject(result, (bool)0);
43563 }
43564 {
43565 if (temp4)
43566 delete arg4;
43567 }
43568 {
43569 if (temp6)
43570 delete arg6;
43571 }
43572 return resultobj;
43573 fail:
43574 {
43575 if (temp4)
43576 delete arg4;
43577 }
43578 {
43579 if (temp6)
43580 delete arg6;
43581 }
43582 return NULL;
43583 }
43584
43585
43586 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43587 PyObject *resultobj = 0;
43588 wxMenu *arg1 = (wxMenu *) 0 ;
43589 int arg2 ;
43590 wxString const &arg3_defvalue = wxPyEmptyString ;
43591 wxString *arg3 = (wxString *) &arg3_defvalue ;
43592 wxString const &arg4_defvalue = wxPyEmptyString ;
43593 wxString *arg4 = (wxString *) &arg4_defvalue ;
43594 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43595 wxMenuItem *result = 0 ;
43596 void *argp1 = 0 ;
43597 int res1 = 0 ;
43598 int val2 ;
43599 int ecode2 = 0 ;
43600 bool temp3 = false ;
43601 bool temp4 = false ;
43602 int val5 ;
43603 int ecode5 = 0 ;
43604 PyObject * obj0 = 0 ;
43605 PyObject * obj1 = 0 ;
43606 PyObject * obj2 = 0 ;
43607 PyObject * obj3 = 0 ;
43608 PyObject * obj4 = 0 ;
43609 char * kwnames[] = {
43610 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43611 };
43612
43613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43615 if (!SWIG_IsOK(res1)) {
43616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43617 }
43618 arg1 = reinterpret_cast< wxMenu * >(argp1);
43619 ecode2 = SWIG_AsVal_int(obj1, &val2);
43620 if (!SWIG_IsOK(ecode2)) {
43621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43622 }
43623 arg2 = static_cast< int >(val2);
43624 if (obj2) {
43625 {
43626 arg3 = wxString_in_helper(obj2);
43627 if (arg3 == NULL) SWIG_fail;
43628 temp3 = true;
43629 }
43630 }
43631 if (obj3) {
43632 {
43633 arg4 = wxString_in_helper(obj3);
43634 if (arg4 == NULL) SWIG_fail;
43635 temp4 = true;
43636 }
43637 }
43638 if (obj4) {
43639 ecode5 = SWIG_AsVal_int(obj4, &val5);
43640 if (!SWIG_IsOK(ecode5)) {
43641 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43642 }
43643 arg5 = static_cast< wxItemKind >(val5);
43644 }
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 {
43652 resultobj = wxPyMake_wxObject(result, (bool)0);
43653 }
43654 {
43655 if (temp3)
43656 delete arg3;
43657 }
43658 {
43659 if (temp4)
43660 delete arg4;
43661 }
43662 return resultobj;
43663 fail:
43664 {
43665 if (temp3)
43666 delete arg3;
43667 }
43668 {
43669 if (temp4)
43670 delete arg4;
43671 }
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43677 PyObject *resultobj = 0;
43678 wxMenu *arg1 = (wxMenu *) 0 ;
43679 wxMenuItem *result = 0 ;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 PyObject *swig_obj[1] ;
43683
43684 if (!args) SWIG_fail;
43685 swig_obj[0] = args;
43686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43687 if (!SWIG_IsOK(res1)) {
43688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43689 }
43690 arg1 = reinterpret_cast< wxMenu * >(argp1);
43691 {
43692 PyThreadState* __tstate = wxPyBeginAllowThreads();
43693 result = (wxMenuItem *)(arg1)->PrependSeparator();
43694 wxPyEndAllowThreads(__tstate);
43695 if (PyErr_Occurred()) SWIG_fail;
43696 }
43697 {
43698 resultobj = wxPyMake_wxObject(result, (bool)0);
43699 }
43700 return resultobj;
43701 fail:
43702 return NULL;
43703 }
43704
43705
43706 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43707 PyObject *resultobj = 0;
43708 wxMenu *arg1 = (wxMenu *) 0 ;
43709 int arg2 ;
43710 wxString *arg3 = 0 ;
43711 wxString const &arg4_defvalue = wxPyEmptyString ;
43712 wxString *arg4 = (wxString *) &arg4_defvalue ;
43713 wxMenuItem *result = 0 ;
43714 void *argp1 = 0 ;
43715 int res1 = 0 ;
43716 int val2 ;
43717 int ecode2 = 0 ;
43718 bool temp3 = false ;
43719 bool temp4 = false ;
43720 PyObject * obj0 = 0 ;
43721 PyObject * obj1 = 0 ;
43722 PyObject * obj2 = 0 ;
43723 PyObject * obj3 = 0 ;
43724 char * kwnames[] = {
43725 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43726 };
43727
43728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43730 if (!SWIG_IsOK(res1)) {
43731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43732 }
43733 arg1 = reinterpret_cast< wxMenu * >(argp1);
43734 ecode2 = SWIG_AsVal_int(obj1, &val2);
43735 if (!SWIG_IsOK(ecode2)) {
43736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43737 }
43738 arg2 = static_cast< int >(val2);
43739 {
43740 arg3 = wxString_in_helper(obj2);
43741 if (arg3 == NULL) SWIG_fail;
43742 temp3 = true;
43743 }
43744 if (obj3) {
43745 {
43746 arg4 = wxString_in_helper(obj3);
43747 if (arg4 == NULL) SWIG_fail;
43748 temp4 = true;
43749 }
43750 }
43751 {
43752 PyThreadState* __tstate = wxPyBeginAllowThreads();
43753 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43754 wxPyEndAllowThreads(__tstate);
43755 if (PyErr_Occurred()) SWIG_fail;
43756 }
43757 {
43758 resultobj = wxPyMake_wxObject(result, (bool)0);
43759 }
43760 {
43761 if (temp3)
43762 delete arg3;
43763 }
43764 {
43765 if (temp4)
43766 delete arg4;
43767 }
43768 return resultobj;
43769 fail:
43770 {
43771 if (temp3)
43772 delete arg3;
43773 }
43774 {
43775 if (temp4)
43776 delete arg4;
43777 }
43778 return NULL;
43779 }
43780
43781
43782 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43783 PyObject *resultobj = 0;
43784 wxMenu *arg1 = (wxMenu *) 0 ;
43785 int arg2 ;
43786 wxString *arg3 = 0 ;
43787 wxString const &arg4_defvalue = wxPyEmptyString ;
43788 wxString *arg4 = (wxString *) &arg4_defvalue ;
43789 wxMenuItem *result = 0 ;
43790 void *argp1 = 0 ;
43791 int res1 = 0 ;
43792 int val2 ;
43793 int ecode2 = 0 ;
43794 bool temp3 = false ;
43795 bool temp4 = false ;
43796 PyObject * obj0 = 0 ;
43797 PyObject * obj1 = 0 ;
43798 PyObject * obj2 = 0 ;
43799 PyObject * obj3 = 0 ;
43800 char * kwnames[] = {
43801 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43802 };
43803
43804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43806 if (!SWIG_IsOK(res1)) {
43807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43808 }
43809 arg1 = reinterpret_cast< wxMenu * >(argp1);
43810 ecode2 = SWIG_AsVal_int(obj1, &val2);
43811 if (!SWIG_IsOK(ecode2)) {
43812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43813 }
43814 arg2 = static_cast< int >(val2);
43815 {
43816 arg3 = wxString_in_helper(obj2);
43817 if (arg3 == NULL) SWIG_fail;
43818 temp3 = true;
43819 }
43820 if (obj3) {
43821 {
43822 arg4 = wxString_in_helper(obj3);
43823 if (arg4 == NULL) SWIG_fail;
43824 temp4 = true;
43825 }
43826 }
43827 {
43828 PyThreadState* __tstate = wxPyBeginAllowThreads();
43829 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43830 wxPyEndAllowThreads(__tstate);
43831 if (PyErr_Occurred()) SWIG_fail;
43832 }
43833 {
43834 resultobj = wxPyMake_wxObject(result, (bool)0);
43835 }
43836 {
43837 if (temp3)
43838 delete arg3;
43839 }
43840 {
43841 if (temp4)
43842 delete arg4;
43843 }
43844 return resultobj;
43845 fail:
43846 {
43847 if (temp3)
43848 delete arg3;
43849 }
43850 {
43851 if (temp4)
43852 delete arg4;
43853 }
43854 return NULL;
43855 }
43856
43857
43858 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43859 PyObject *resultobj = 0;
43860 wxMenu *arg1 = (wxMenu *) 0 ;
43861 int arg2 ;
43862 wxString *arg3 = 0 ;
43863 wxMenu *arg4 = (wxMenu *) 0 ;
43864 wxString const &arg5_defvalue = wxPyEmptyString ;
43865 wxString *arg5 = (wxString *) &arg5_defvalue ;
43866 wxMenuItem *result = 0 ;
43867 void *argp1 = 0 ;
43868 int res1 = 0 ;
43869 int val2 ;
43870 int ecode2 = 0 ;
43871 bool temp3 = false ;
43872 void *argp4 = 0 ;
43873 int res4 = 0 ;
43874 bool temp5 = false ;
43875 PyObject * obj0 = 0 ;
43876 PyObject * obj1 = 0 ;
43877 PyObject * obj2 = 0 ;
43878 PyObject * obj3 = 0 ;
43879 PyObject * obj4 = 0 ;
43880 char * kwnames[] = {
43881 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43882 };
43883
43884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43886 if (!SWIG_IsOK(res1)) {
43887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43888 }
43889 arg1 = reinterpret_cast< wxMenu * >(argp1);
43890 ecode2 = SWIG_AsVal_int(obj1, &val2);
43891 if (!SWIG_IsOK(ecode2)) {
43892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43893 }
43894 arg2 = static_cast< int >(val2);
43895 {
43896 arg3 = wxString_in_helper(obj2);
43897 if (arg3 == NULL) SWIG_fail;
43898 temp3 = true;
43899 }
43900 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43901 if (!SWIG_IsOK(res4)) {
43902 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43903 }
43904 arg4 = reinterpret_cast< wxMenu * >(argp4);
43905 if (obj4) {
43906 {
43907 arg5 = wxString_in_helper(obj4);
43908 if (arg5 == NULL) SWIG_fail;
43909 temp5 = true;
43910 }
43911 }
43912 {
43913 PyThreadState* __tstate = wxPyBeginAllowThreads();
43914 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43915 wxPyEndAllowThreads(__tstate);
43916 if (PyErr_Occurred()) SWIG_fail;
43917 }
43918 {
43919 resultobj = wxPyMake_wxObject(result, (bool)0);
43920 }
43921 {
43922 if (temp3)
43923 delete arg3;
43924 }
43925 {
43926 if (temp5)
43927 delete arg5;
43928 }
43929 return resultobj;
43930 fail:
43931 {
43932 if (temp3)
43933 delete arg3;
43934 }
43935 {
43936 if (temp5)
43937 delete arg5;
43938 }
43939 return NULL;
43940 }
43941
43942
43943 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43944 PyObject *resultobj = 0;
43945 wxMenu *arg1 = (wxMenu *) 0 ;
43946 int arg2 ;
43947 wxMenuItem *result = 0 ;
43948 void *argp1 = 0 ;
43949 int res1 = 0 ;
43950 int val2 ;
43951 int ecode2 = 0 ;
43952 PyObject * obj0 = 0 ;
43953 PyObject * obj1 = 0 ;
43954 char * kwnames[] = {
43955 (char *) "self",(char *) "id", NULL
43956 };
43957
43958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43960 if (!SWIG_IsOK(res1)) {
43961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43962 }
43963 arg1 = reinterpret_cast< wxMenu * >(argp1);
43964 ecode2 = SWIG_AsVal_int(obj1, &val2);
43965 if (!SWIG_IsOK(ecode2)) {
43966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43967 }
43968 arg2 = static_cast< int >(val2);
43969 {
43970 PyThreadState* __tstate = wxPyBeginAllowThreads();
43971 result = (wxMenuItem *)(arg1)->Remove(arg2);
43972 wxPyEndAllowThreads(__tstate);
43973 if (PyErr_Occurred()) SWIG_fail;
43974 }
43975 {
43976 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43977 }
43978 return resultobj;
43979 fail:
43980 return NULL;
43981 }
43982
43983
43984 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43985 PyObject *resultobj = 0;
43986 wxMenu *arg1 = (wxMenu *) 0 ;
43987 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43988 wxMenuItem *result = 0 ;
43989 void *argp1 = 0 ;
43990 int res1 = 0 ;
43991 void *argp2 = 0 ;
43992 int res2 = 0 ;
43993 PyObject * obj0 = 0 ;
43994 PyObject * obj1 = 0 ;
43995 char * kwnames[] = {
43996 (char *) "self",(char *) "item", NULL
43997 };
43998
43999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
44000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44001 if (!SWIG_IsOK(res1)) {
44002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44003 }
44004 arg1 = reinterpret_cast< wxMenu * >(argp1);
44005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44006 if (!SWIG_IsOK(res2)) {
44007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44008 }
44009 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44010 {
44011 PyThreadState* __tstate = wxPyBeginAllowThreads();
44012 result = (wxMenuItem *)(arg1)->Remove(arg2);
44013 wxPyEndAllowThreads(__tstate);
44014 if (PyErr_Occurred()) SWIG_fail;
44015 }
44016 {
44017 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
44018 }
44019 return resultobj;
44020 fail:
44021 return NULL;
44022 }
44023
44024
44025 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44026 PyObject *resultobj = 0;
44027 wxMenu *arg1 = (wxMenu *) 0 ;
44028 int arg2 ;
44029 bool result;
44030 void *argp1 = 0 ;
44031 int res1 = 0 ;
44032 int val2 ;
44033 int ecode2 = 0 ;
44034 PyObject * obj0 = 0 ;
44035 PyObject * obj1 = 0 ;
44036 char * kwnames[] = {
44037 (char *) "self",(char *) "id", NULL
44038 };
44039
44040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44042 if (!SWIG_IsOK(res1)) {
44043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
44044 }
44045 arg1 = reinterpret_cast< wxMenu * >(argp1);
44046 ecode2 = SWIG_AsVal_int(obj1, &val2);
44047 if (!SWIG_IsOK(ecode2)) {
44048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
44049 }
44050 arg2 = static_cast< int >(val2);
44051 {
44052 PyThreadState* __tstate = wxPyBeginAllowThreads();
44053 result = (bool)(arg1)->Delete(arg2);
44054 wxPyEndAllowThreads(__tstate);
44055 if (PyErr_Occurred()) SWIG_fail;
44056 }
44057 {
44058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44059 }
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj = 0;
44068 wxMenu *arg1 = (wxMenu *) 0 ;
44069 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44070 bool result;
44071 void *argp1 = 0 ;
44072 int res1 = 0 ;
44073 void *argp2 = 0 ;
44074 int res2 = 0 ;
44075 PyObject * obj0 = 0 ;
44076 PyObject * obj1 = 0 ;
44077 char * kwnames[] = {
44078 (char *) "self",(char *) "item", NULL
44079 };
44080
44081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
44082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44083 if (!SWIG_IsOK(res1)) {
44084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44085 }
44086 arg1 = reinterpret_cast< wxMenu * >(argp1);
44087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44088 if (!SWIG_IsOK(res2)) {
44089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44090 }
44091 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44092 {
44093 PyThreadState* __tstate = wxPyBeginAllowThreads();
44094 result = (bool)(arg1)->Delete(arg2);
44095 wxPyEndAllowThreads(__tstate);
44096 if (PyErr_Occurred()) SWIG_fail;
44097 }
44098 {
44099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44100 }
44101 return resultobj;
44102 fail:
44103 return NULL;
44104 }
44105
44106
44107 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44108 PyObject *resultobj = 0;
44109 wxMenu *arg1 = (wxMenu *) 0 ;
44110 void *argp1 = 0 ;
44111 int res1 = 0 ;
44112 PyObject *swig_obj[1] ;
44113
44114 if (!args) SWIG_fail;
44115 swig_obj[0] = args;
44116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44117 if (!SWIG_IsOK(res1)) {
44118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
44119 }
44120 arg1 = reinterpret_cast< wxMenu * >(argp1);
44121 {
44122 PyThreadState* __tstate = wxPyBeginAllowThreads();
44123 wxMenu_Destroy(arg1);
44124 wxPyEndAllowThreads(__tstate);
44125 if (PyErr_Occurred()) SWIG_fail;
44126 }
44127 resultobj = SWIG_Py_Void();
44128 return resultobj;
44129 fail:
44130 return NULL;
44131 }
44132
44133
44134 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44135 PyObject *resultobj = 0;
44136 wxMenu *arg1 = (wxMenu *) 0 ;
44137 int arg2 ;
44138 bool result;
44139 void *argp1 = 0 ;
44140 int res1 = 0 ;
44141 int val2 ;
44142 int ecode2 = 0 ;
44143 PyObject * obj0 = 0 ;
44144 PyObject * obj1 = 0 ;
44145 char * kwnames[] = {
44146 (char *) "self",(char *) "id", NULL
44147 };
44148
44149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
44150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44151 if (!SWIG_IsOK(res1)) {
44152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
44153 }
44154 arg1 = reinterpret_cast< wxMenu * >(argp1);
44155 ecode2 = SWIG_AsVal_int(obj1, &val2);
44156 if (!SWIG_IsOK(ecode2)) {
44157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
44158 }
44159 arg2 = static_cast< int >(val2);
44160 {
44161 PyThreadState* __tstate = wxPyBeginAllowThreads();
44162 result = (bool)(arg1)->Destroy(arg2);
44163 wxPyEndAllowThreads(__tstate);
44164 if (PyErr_Occurred()) SWIG_fail;
44165 }
44166 {
44167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44168 }
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj = 0;
44177 wxMenu *arg1 = (wxMenu *) 0 ;
44178 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44179 bool result;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 void *argp2 = 0 ;
44183 int res2 = 0 ;
44184 PyObject * obj0 = 0 ;
44185 PyObject * obj1 = 0 ;
44186 char * kwnames[] = {
44187 (char *) "self",(char *) "item", NULL
44188 };
44189
44190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
44191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44192 if (!SWIG_IsOK(res1)) {
44193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44194 }
44195 arg1 = reinterpret_cast< wxMenu * >(argp1);
44196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44197 if (!SWIG_IsOK(res2)) {
44198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44199 }
44200 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44201 {
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 result = (bool)(arg1)->Destroy(arg2);
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 {
44208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44209 }
44210 return resultobj;
44211 fail:
44212 return NULL;
44213 }
44214
44215
44216 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44217 PyObject *resultobj = 0;
44218 wxMenu *arg1 = (wxMenu *) 0 ;
44219 size_t result;
44220 void *argp1 = 0 ;
44221 int res1 = 0 ;
44222 PyObject *swig_obj[1] ;
44223
44224 if (!args) SWIG_fail;
44225 swig_obj[0] = args;
44226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44227 if (!SWIG_IsOK(res1)) {
44228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
44229 }
44230 arg1 = reinterpret_cast< wxMenu * >(argp1);
44231 {
44232 PyThreadState* __tstate = wxPyBeginAllowThreads();
44233 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
44234 wxPyEndAllowThreads(__tstate);
44235 if (PyErr_Occurred()) SWIG_fail;
44236 }
44237 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44238 return resultobj;
44239 fail:
44240 return NULL;
44241 }
44242
44243
44244 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44245 PyObject *resultobj = 0;
44246 wxMenu *arg1 = (wxMenu *) 0 ;
44247 PyObject *result = 0 ;
44248 void *argp1 = 0 ;
44249 int res1 = 0 ;
44250 PyObject *swig_obj[1] ;
44251
44252 if (!args) SWIG_fail;
44253 swig_obj[0] = args;
44254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44255 if (!SWIG_IsOK(res1)) {
44256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
44257 }
44258 arg1 = reinterpret_cast< wxMenu * >(argp1);
44259 {
44260 PyThreadState* __tstate = wxPyBeginAllowThreads();
44261 result = (PyObject *)wxMenu_GetMenuItems(arg1);
44262 wxPyEndAllowThreads(__tstate);
44263 if (PyErr_Occurred()) SWIG_fail;
44264 }
44265 resultobj = result;
44266 return resultobj;
44267 fail:
44268 return NULL;
44269 }
44270
44271
44272 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44273 PyObject *resultobj = 0;
44274 wxMenu *arg1 = (wxMenu *) 0 ;
44275 wxString *arg2 = 0 ;
44276 int result;
44277 void *argp1 = 0 ;
44278 int res1 = 0 ;
44279 bool temp2 = false ;
44280 PyObject * obj0 = 0 ;
44281 PyObject * obj1 = 0 ;
44282 char * kwnames[] = {
44283 (char *) "self",(char *) "item", NULL
44284 };
44285
44286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
44287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44288 if (!SWIG_IsOK(res1)) {
44289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
44290 }
44291 arg1 = reinterpret_cast< wxMenu * >(argp1);
44292 {
44293 arg2 = wxString_in_helper(obj1);
44294 if (arg2 == NULL) SWIG_fail;
44295 temp2 = true;
44296 }
44297 {
44298 PyThreadState* __tstate = wxPyBeginAllowThreads();
44299 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
44300 wxPyEndAllowThreads(__tstate);
44301 if (PyErr_Occurred()) SWIG_fail;
44302 }
44303 resultobj = SWIG_From_int(static_cast< int >(result));
44304 {
44305 if (temp2)
44306 delete arg2;
44307 }
44308 return resultobj;
44309 fail:
44310 {
44311 if (temp2)
44312 delete arg2;
44313 }
44314 return NULL;
44315 }
44316
44317
44318 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44319 PyObject *resultobj = 0;
44320 wxMenu *arg1 = (wxMenu *) 0 ;
44321 int arg2 ;
44322 wxMenuItem *result = 0 ;
44323 void *argp1 = 0 ;
44324 int res1 = 0 ;
44325 int val2 ;
44326 int ecode2 = 0 ;
44327 PyObject * obj0 = 0 ;
44328 PyObject * obj1 = 0 ;
44329 char * kwnames[] = {
44330 (char *) "self",(char *) "id", NULL
44331 };
44332
44333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44335 if (!SWIG_IsOK(res1)) {
44336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
44337 }
44338 arg1 = reinterpret_cast< wxMenu * >(argp1);
44339 ecode2 = SWIG_AsVal_int(obj1, &val2);
44340 if (!SWIG_IsOK(ecode2)) {
44341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
44342 }
44343 arg2 = static_cast< int >(val2);
44344 {
44345 PyThreadState* __tstate = wxPyBeginAllowThreads();
44346 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
44347 wxPyEndAllowThreads(__tstate);
44348 if (PyErr_Occurred()) SWIG_fail;
44349 }
44350 {
44351 resultobj = wxPyMake_wxObject(result, (bool)0);
44352 }
44353 return resultobj;
44354 fail:
44355 return NULL;
44356 }
44357
44358
44359 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44360 PyObject *resultobj = 0;
44361 wxMenu *arg1 = (wxMenu *) 0 ;
44362 size_t arg2 ;
44363 wxMenuItem *result = 0 ;
44364 void *argp1 = 0 ;
44365 int res1 = 0 ;
44366 size_t val2 ;
44367 int ecode2 = 0 ;
44368 PyObject * obj0 = 0 ;
44369 PyObject * obj1 = 0 ;
44370 char * kwnames[] = {
44371 (char *) "self",(char *) "position", NULL
44372 };
44373
44374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
44375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenu * >(argp1);
44380 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44381 if (!SWIG_IsOK(ecode2)) {
44382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
44383 }
44384 arg2 = static_cast< size_t >(val2);
44385 {
44386 PyThreadState* __tstate = wxPyBeginAllowThreads();
44387 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
44388 wxPyEndAllowThreads(__tstate);
44389 if (PyErr_Occurred()) SWIG_fail;
44390 }
44391 {
44392 resultobj = wxPyMake_wxObject(result, (bool)0);
44393 }
44394 return resultobj;
44395 fail:
44396 return NULL;
44397 }
44398
44399
44400 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44401 PyObject *resultobj = 0;
44402 wxMenu *arg1 = (wxMenu *) 0 ;
44403 int arg2 ;
44404 bool arg3 ;
44405 void *argp1 = 0 ;
44406 int res1 = 0 ;
44407 int val2 ;
44408 int ecode2 = 0 ;
44409 bool val3 ;
44410 int ecode3 = 0 ;
44411 PyObject * obj0 = 0 ;
44412 PyObject * obj1 = 0 ;
44413 PyObject * obj2 = 0 ;
44414 char * kwnames[] = {
44415 (char *) "self",(char *) "id",(char *) "enable", NULL
44416 };
44417
44418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44420 if (!SWIG_IsOK(res1)) {
44421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
44422 }
44423 arg1 = reinterpret_cast< wxMenu * >(argp1);
44424 ecode2 = SWIG_AsVal_int(obj1, &val2);
44425 if (!SWIG_IsOK(ecode2)) {
44426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
44427 }
44428 arg2 = static_cast< int >(val2);
44429 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44430 if (!SWIG_IsOK(ecode3)) {
44431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
44432 }
44433 arg3 = static_cast< bool >(val3);
44434 {
44435 PyThreadState* __tstate = wxPyBeginAllowThreads();
44436 (arg1)->Enable(arg2,arg3);
44437 wxPyEndAllowThreads(__tstate);
44438 if (PyErr_Occurred()) SWIG_fail;
44439 }
44440 resultobj = SWIG_Py_Void();
44441 return resultobj;
44442 fail:
44443 return NULL;
44444 }
44445
44446
44447 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj = 0;
44449 wxMenu *arg1 = (wxMenu *) 0 ;
44450 int arg2 ;
44451 bool result;
44452 void *argp1 = 0 ;
44453 int res1 = 0 ;
44454 int val2 ;
44455 int ecode2 = 0 ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 char * kwnames[] = {
44459 (char *) "self",(char *) "id", NULL
44460 };
44461
44462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
44463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44464 if (!SWIG_IsOK(res1)) {
44465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
44466 }
44467 arg1 = reinterpret_cast< wxMenu * >(argp1);
44468 ecode2 = SWIG_AsVal_int(obj1, &val2);
44469 if (!SWIG_IsOK(ecode2)) {
44470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
44471 }
44472 arg2 = static_cast< int >(val2);
44473 {
44474 PyThreadState* __tstate = wxPyBeginAllowThreads();
44475 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
44476 wxPyEndAllowThreads(__tstate);
44477 if (PyErr_Occurred()) SWIG_fail;
44478 }
44479 {
44480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44481 }
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44489 PyObject *resultobj = 0;
44490 wxMenu *arg1 = (wxMenu *) 0 ;
44491 int arg2 ;
44492 bool arg3 ;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 int val2 ;
44496 int ecode2 = 0 ;
44497 bool val3 ;
44498 int ecode3 = 0 ;
44499 PyObject * obj0 = 0 ;
44500 PyObject * obj1 = 0 ;
44501 PyObject * obj2 = 0 ;
44502 char * kwnames[] = {
44503 (char *) "self",(char *) "id",(char *) "check", NULL
44504 };
44505
44506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44508 if (!SWIG_IsOK(res1)) {
44509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44510 }
44511 arg1 = reinterpret_cast< wxMenu * >(argp1);
44512 ecode2 = SWIG_AsVal_int(obj1, &val2);
44513 if (!SWIG_IsOK(ecode2)) {
44514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44515 }
44516 arg2 = static_cast< int >(val2);
44517 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44518 if (!SWIG_IsOK(ecode3)) {
44519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44520 }
44521 arg3 = static_cast< bool >(val3);
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 (arg1)->Check(arg2,arg3);
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 resultobj = SWIG_Py_Void();
44529 return resultobj;
44530 fail:
44531 return NULL;
44532 }
44533
44534
44535 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44536 PyObject *resultobj = 0;
44537 wxMenu *arg1 = (wxMenu *) 0 ;
44538 int arg2 ;
44539 bool result;
44540 void *argp1 = 0 ;
44541 int res1 = 0 ;
44542 int val2 ;
44543 int ecode2 = 0 ;
44544 PyObject * obj0 = 0 ;
44545 PyObject * obj1 = 0 ;
44546 char * kwnames[] = {
44547 (char *) "self",(char *) "id", NULL
44548 };
44549
44550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44552 if (!SWIG_IsOK(res1)) {
44553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44554 }
44555 arg1 = reinterpret_cast< wxMenu * >(argp1);
44556 ecode2 = SWIG_AsVal_int(obj1, &val2);
44557 if (!SWIG_IsOK(ecode2)) {
44558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44559 }
44560 arg2 = static_cast< int >(val2);
44561 {
44562 PyThreadState* __tstate = wxPyBeginAllowThreads();
44563 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44564 wxPyEndAllowThreads(__tstate);
44565 if (PyErr_Occurred()) SWIG_fail;
44566 }
44567 {
44568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44569 }
44570 return resultobj;
44571 fail:
44572 return NULL;
44573 }
44574
44575
44576 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44577 PyObject *resultobj = 0;
44578 wxMenu *arg1 = (wxMenu *) 0 ;
44579 int arg2 ;
44580 wxString *arg3 = 0 ;
44581 void *argp1 = 0 ;
44582 int res1 = 0 ;
44583 int val2 ;
44584 int ecode2 = 0 ;
44585 bool temp3 = false ;
44586 PyObject * obj0 = 0 ;
44587 PyObject * obj1 = 0 ;
44588 PyObject * obj2 = 0 ;
44589 char * kwnames[] = {
44590 (char *) "self",(char *) "id",(char *) "label", NULL
44591 };
44592
44593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44595 if (!SWIG_IsOK(res1)) {
44596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44597 }
44598 arg1 = reinterpret_cast< wxMenu * >(argp1);
44599 ecode2 = SWIG_AsVal_int(obj1, &val2);
44600 if (!SWIG_IsOK(ecode2)) {
44601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44602 }
44603 arg2 = static_cast< int >(val2);
44604 {
44605 arg3 = wxString_in_helper(obj2);
44606 if (arg3 == NULL) SWIG_fail;
44607 temp3 = true;
44608 }
44609 {
44610 PyThreadState* __tstate = wxPyBeginAllowThreads();
44611 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44612 wxPyEndAllowThreads(__tstate);
44613 if (PyErr_Occurred()) SWIG_fail;
44614 }
44615 resultobj = SWIG_Py_Void();
44616 {
44617 if (temp3)
44618 delete arg3;
44619 }
44620 return resultobj;
44621 fail:
44622 {
44623 if (temp3)
44624 delete arg3;
44625 }
44626 return NULL;
44627 }
44628
44629
44630 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44631 PyObject *resultobj = 0;
44632 wxMenu *arg1 = (wxMenu *) 0 ;
44633 int arg2 ;
44634 wxString result;
44635 void *argp1 = 0 ;
44636 int res1 = 0 ;
44637 int val2 ;
44638 int ecode2 = 0 ;
44639 PyObject * obj0 = 0 ;
44640 PyObject * obj1 = 0 ;
44641 char * kwnames[] = {
44642 (char *) "self",(char *) "id", NULL
44643 };
44644
44645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44647 if (!SWIG_IsOK(res1)) {
44648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44649 }
44650 arg1 = reinterpret_cast< wxMenu * >(argp1);
44651 ecode2 = SWIG_AsVal_int(obj1, &val2);
44652 if (!SWIG_IsOK(ecode2)) {
44653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44654 }
44655 arg2 = static_cast< int >(val2);
44656 {
44657 PyThreadState* __tstate = wxPyBeginAllowThreads();
44658 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44659 wxPyEndAllowThreads(__tstate);
44660 if (PyErr_Occurred()) SWIG_fail;
44661 }
44662 {
44663 #if wxUSE_UNICODE
44664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44665 #else
44666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44667 #endif
44668 }
44669 return resultobj;
44670 fail:
44671 return NULL;
44672 }
44673
44674
44675 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44676 PyObject *resultobj = 0;
44677 wxMenu *arg1 = (wxMenu *) 0 ;
44678 int arg2 ;
44679 wxString *arg3 = 0 ;
44680 void *argp1 = 0 ;
44681 int res1 = 0 ;
44682 int val2 ;
44683 int ecode2 = 0 ;
44684 bool temp3 = false ;
44685 PyObject * obj0 = 0 ;
44686 PyObject * obj1 = 0 ;
44687 PyObject * obj2 = 0 ;
44688 char * kwnames[] = {
44689 (char *) "self",(char *) "id",(char *) "helpString", NULL
44690 };
44691
44692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44694 if (!SWIG_IsOK(res1)) {
44695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44696 }
44697 arg1 = reinterpret_cast< wxMenu * >(argp1);
44698 ecode2 = SWIG_AsVal_int(obj1, &val2);
44699 if (!SWIG_IsOK(ecode2)) {
44700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44701 }
44702 arg2 = static_cast< int >(val2);
44703 {
44704 arg3 = wxString_in_helper(obj2);
44705 if (arg3 == NULL) SWIG_fail;
44706 temp3 = true;
44707 }
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 resultobj = SWIG_Py_Void();
44715 {
44716 if (temp3)
44717 delete arg3;
44718 }
44719 return resultobj;
44720 fail:
44721 {
44722 if (temp3)
44723 delete arg3;
44724 }
44725 return NULL;
44726 }
44727
44728
44729 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44730 PyObject *resultobj = 0;
44731 wxMenu *arg1 = (wxMenu *) 0 ;
44732 int arg2 ;
44733 wxString result;
44734 void *argp1 = 0 ;
44735 int res1 = 0 ;
44736 int val2 ;
44737 int ecode2 = 0 ;
44738 PyObject * obj0 = 0 ;
44739 PyObject * obj1 = 0 ;
44740 char * kwnames[] = {
44741 (char *) "self",(char *) "id", NULL
44742 };
44743
44744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44746 if (!SWIG_IsOK(res1)) {
44747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44748 }
44749 arg1 = reinterpret_cast< wxMenu * >(argp1);
44750 ecode2 = SWIG_AsVal_int(obj1, &val2);
44751 if (!SWIG_IsOK(ecode2)) {
44752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44753 }
44754 arg2 = static_cast< int >(val2);
44755 {
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 {
44762 #if wxUSE_UNICODE
44763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44764 #else
44765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44766 #endif
44767 }
44768 return resultobj;
44769 fail:
44770 return NULL;
44771 }
44772
44773
44774 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44775 PyObject *resultobj = 0;
44776 wxMenu *arg1 = (wxMenu *) 0 ;
44777 wxString *arg2 = 0 ;
44778 void *argp1 = 0 ;
44779 int res1 = 0 ;
44780 bool temp2 = false ;
44781 PyObject * obj0 = 0 ;
44782 PyObject * obj1 = 0 ;
44783 char * kwnames[] = {
44784 (char *) "self",(char *) "title", NULL
44785 };
44786
44787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44789 if (!SWIG_IsOK(res1)) {
44790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44791 }
44792 arg1 = reinterpret_cast< wxMenu * >(argp1);
44793 {
44794 arg2 = wxString_in_helper(obj1);
44795 if (arg2 == NULL) SWIG_fail;
44796 temp2 = true;
44797 }
44798 {
44799 PyThreadState* __tstate = wxPyBeginAllowThreads();
44800 (arg1)->SetTitle((wxString const &)*arg2);
44801 wxPyEndAllowThreads(__tstate);
44802 if (PyErr_Occurred()) SWIG_fail;
44803 }
44804 resultobj = SWIG_Py_Void();
44805 {
44806 if (temp2)
44807 delete arg2;
44808 }
44809 return resultobj;
44810 fail:
44811 {
44812 if (temp2)
44813 delete arg2;
44814 }
44815 return NULL;
44816 }
44817
44818
44819 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44820 PyObject *resultobj = 0;
44821 wxMenu *arg1 = (wxMenu *) 0 ;
44822 wxString result;
44823 void *argp1 = 0 ;
44824 int res1 = 0 ;
44825 PyObject *swig_obj[1] ;
44826
44827 if (!args) SWIG_fail;
44828 swig_obj[0] = args;
44829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44830 if (!SWIG_IsOK(res1)) {
44831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44832 }
44833 arg1 = reinterpret_cast< wxMenu * >(argp1);
44834 {
44835 PyThreadState* __tstate = wxPyBeginAllowThreads();
44836 result = ((wxMenu const *)arg1)->GetTitle();
44837 wxPyEndAllowThreads(__tstate);
44838 if (PyErr_Occurred()) SWIG_fail;
44839 }
44840 {
44841 #if wxUSE_UNICODE
44842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44843 #else
44844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44845 #endif
44846 }
44847 return resultobj;
44848 fail:
44849 return NULL;
44850 }
44851
44852
44853 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44854 PyObject *resultobj = 0;
44855 wxMenu *arg1 = (wxMenu *) 0 ;
44856 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44857 void *argp1 = 0 ;
44858 int res1 = 0 ;
44859 void *argp2 = 0 ;
44860 int res2 = 0 ;
44861 PyObject * obj0 = 0 ;
44862 PyObject * obj1 = 0 ;
44863 char * kwnames[] = {
44864 (char *) "self",(char *) "handler", NULL
44865 };
44866
44867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44869 if (!SWIG_IsOK(res1)) {
44870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44871 }
44872 arg1 = reinterpret_cast< wxMenu * >(argp1);
44873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44874 if (!SWIG_IsOK(res2)) {
44875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44876 }
44877 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44878 {
44879 PyThreadState* __tstate = wxPyBeginAllowThreads();
44880 (arg1)->SetEventHandler(arg2);
44881 wxPyEndAllowThreads(__tstate);
44882 if (PyErr_Occurred()) SWIG_fail;
44883 }
44884 resultobj = SWIG_Py_Void();
44885 return resultobj;
44886 fail:
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44892 PyObject *resultobj = 0;
44893 wxMenu *arg1 = (wxMenu *) 0 ;
44894 wxEvtHandler *result = 0 ;
44895 void *argp1 = 0 ;
44896 int res1 = 0 ;
44897 PyObject *swig_obj[1] ;
44898
44899 if (!args) SWIG_fail;
44900 swig_obj[0] = args;
44901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44902 if (!SWIG_IsOK(res1)) {
44903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44904 }
44905 arg1 = reinterpret_cast< wxMenu * >(argp1);
44906 {
44907 PyThreadState* __tstate = wxPyBeginAllowThreads();
44908 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 {
44913 resultobj = wxPyMake_wxObject(result, 0);
44914 }
44915 return resultobj;
44916 fail:
44917 return NULL;
44918 }
44919
44920
44921 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44922 PyObject *resultobj = 0;
44923 wxMenu *arg1 = (wxMenu *) 0 ;
44924 wxWindow *arg2 = (wxWindow *) 0 ;
44925 void *argp1 = 0 ;
44926 int res1 = 0 ;
44927 void *argp2 = 0 ;
44928 int res2 = 0 ;
44929 PyObject * obj0 = 0 ;
44930 PyObject * obj1 = 0 ;
44931 char * kwnames[] = {
44932 (char *) "self",(char *) "win", NULL
44933 };
44934
44935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44937 if (!SWIG_IsOK(res1)) {
44938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44939 }
44940 arg1 = reinterpret_cast< wxMenu * >(argp1);
44941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44942 if (!SWIG_IsOK(res2)) {
44943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44944 }
44945 arg2 = reinterpret_cast< wxWindow * >(argp2);
44946 {
44947 PyThreadState* __tstate = wxPyBeginAllowThreads();
44948 (arg1)->SetInvokingWindow(arg2);
44949 wxPyEndAllowThreads(__tstate);
44950 if (PyErr_Occurred()) SWIG_fail;
44951 }
44952 resultobj = SWIG_Py_Void();
44953 return resultobj;
44954 fail:
44955 return NULL;
44956 }
44957
44958
44959 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44960 PyObject *resultobj = 0;
44961 wxMenu *arg1 = (wxMenu *) 0 ;
44962 wxWindow *result = 0 ;
44963 void *argp1 = 0 ;
44964 int res1 = 0 ;
44965 PyObject *swig_obj[1] ;
44966
44967 if (!args) SWIG_fail;
44968 swig_obj[0] = args;
44969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44970 if (!SWIG_IsOK(res1)) {
44971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44972 }
44973 arg1 = reinterpret_cast< wxMenu * >(argp1);
44974 {
44975 PyThreadState* __tstate = wxPyBeginAllowThreads();
44976 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44977 wxPyEndAllowThreads(__tstate);
44978 if (PyErr_Occurred()) SWIG_fail;
44979 }
44980 {
44981 resultobj = wxPyMake_wxObject(result, 0);
44982 }
44983 return resultobj;
44984 fail:
44985 return NULL;
44986 }
44987
44988
44989 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44990 PyObject *resultobj = 0;
44991 wxMenu *arg1 = (wxMenu *) 0 ;
44992 long result;
44993 void *argp1 = 0 ;
44994 int res1 = 0 ;
44995 PyObject *swig_obj[1] ;
44996
44997 if (!args) SWIG_fail;
44998 swig_obj[0] = args;
44999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45000 if (!SWIG_IsOK(res1)) {
45001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
45002 }
45003 arg1 = reinterpret_cast< wxMenu * >(argp1);
45004 {
45005 PyThreadState* __tstate = wxPyBeginAllowThreads();
45006 result = (long)((wxMenu const *)arg1)->GetStyle();
45007 wxPyEndAllowThreads(__tstate);
45008 if (PyErr_Occurred()) SWIG_fail;
45009 }
45010 resultobj = SWIG_From_long(static_cast< long >(result));
45011 return resultobj;
45012 fail:
45013 return NULL;
45014 }
45015
45016
45017 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45018 PyObject *resultobj = 0;
45019 wxMenu *arg1 = (wxMenu *) 0 ;
45020 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
45021 void *argp1 = 0 ;
45022 int res1 = 0 ;
45023 void *argp2 = 0 ;
45024 int res2 = 0 ;
45025 PyObject * obj0 = 0 ;
45026 PyObject * obj1 = 0 ;
45027 char * kwnames[] = {
45028 (char *) "self",(char *) "source", NULL
45029 };
45030
45031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
45032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45033 if (!SWIG_IsOK(res1)) {
45034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
45035 }
45036 arg1 = reinterpret_cast< wxMenu * >(argp1);
45037 if (obj1) {
45038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
45039 if (!SWIG_IsOK(res2)) {
45040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
45041 }
45042 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
45043 }
45044 {
45045 PyThreadState* __tstate = wxPyBeginAllowThreads();
45046 (arg1)->UpdateUI(arg2);
45047 wxPyEndAllowThreads(__tstate);
45048 if (PyErr_Occurred()) SWIG_fail;
45049 }
45050 resultobj = SWIG_Py_Void();
45051 return resultobj;
45052 fail:
45053 return NULL;
45054 }
45055
45056
45057 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45058 PyObject *resultobj = 0;
45059 wxMenu *arg1 = (wxMenu *) 0 ;
45060 wxMenuBar *result = 0 ;
45061 void *argp1 = 0 ;
45062 int res1 = 0 ;
45063 PyObject *swig_obj[1] ;
45064
45065 if (!args) SWIG_fail;
45066 swig_obj[0] = args;
45067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45068 if (!SWIG_IsOK(res1)) {
45069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
45070 }
45071 arg1 = reinterpret_cast< wxMenu * >(argp1);
45072 {
45073 PyThreadState* __tstate = wxPyBeginAllowThreads();
45074 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
45075 wxPyEndAllowThreads(__tstate);
45076 if (PyErr_Occurred()) SWIG_fail;
45077 }
45078 {
45079 resultobj = wxPyMake_wxObject(result, (bool)0);
45080 }
45081 return resultobj;
45082 fail:
45083 return NULL;
45084 }
45085
45086
45087 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45088 PyObject *resultobj = 0;
45089 wxMenu *arg1 = (wxMenu *) 0 ;
45090 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
45091 void *argp1 = 0 ;
45092 int res1 = 0 ;
45093 void *argp2 = 0 ;
45094 int res2 = 0 ;
45095 PyObject * obj0 = 0 ;
45096 PyObject * obj1 = 0 ;
45097 char * kwnames[] = {
45098 (char *) "self",(char *) "menubar", NULL
45099 };
45100
45101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45103 if (!SWIG_IsOK(res1)) {
45104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
45105 }
45106 arg1 = reinterpret_cast< wxMenu * >(argp1);
45107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
45108 if (!SWIG_IsOK(res2)) {
45109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
45110 }
45111 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
45112 {
45113 PyThreadState* __tstate = wxPyBeginAllowThreads();
45114 (arg1)->Attach(arg2);
45115 wxPyEndAllowThreads(__tstate);
45116 if (PyErr_Occurred()) SWIG_fail;
45117 }
45118 resultobj = SWIG_Py_Void();
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45126 PyObject *resultobj = 0;
45127 wxMenu *arg1 = (wxMenu *) 0 ;
45128 void *argp1 = 0 ;
45129 int res1 = 0 ;
45130 PyObject *swig_obj[1] ;
45131
45132 if (!args) SWIG_fail;
45133 swig_obj[0] = args;
45134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45135 if (!SWIG_IsOK(res1)) {
45136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
45137 }
45138 arg1 = reinterpret_cast< wxMenu * >(argp1);
45139 {
45140 PyThreadState* __tstate = wxPyBeginAllowThreads();
45141 (arg1)->Detach();
45142 wxPyEndAllowThreads(__tstate);
45143 if (PyErr_Occurred()) SWIG_fail;
45144 }
45145 resultobj = SWIG_Py_Void();
45146 return resultobj;
45147 fail:
45148 return NULL;
45149 }
45150
45151
45152 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45153 PyObject *resultobj = 0;
45154 wxMenu *arg1 = (wxMenu *) 0 ;
45155 bool result;
45156 void *argp1 = 0 ;
45157 int res1 = 0 ;
45158 PyObject *swig_obj[1] ;
45159
45160 if (!args) SWIG_fail;
45161 swig_obj[0] = args;
45162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45163 if (!SWIG_IsOK(res1)) {
45164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
45165 }
45166 arg1 = reinterpret_cast< wxMenu * >(argp1);
45167 {
45168 PyThreadState* __tstate = wxPyBeginAllowThreads();
45169 result = (bool)((wxMenu const *)arg1)->IsAttached();
45170 wxPyEndAllowThreads(__tstate);
45171 if (PyErr_Occurred()) SWIG_fail;
45172 }
45173 {
45174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45175 }
45176 return resultobj;
45177 fail:
45178 return NULL;
45179 }
45180
45181
45182 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45183 PyObject *resultobj = 0;
45184 wxMenu *arg1 = (wxMenu *) 0 ;
45185 wxMenu *arg2 = (wxMenu *) 0 ;
45186 void *argp1 = 0 ;
45187 int res1 = 0 ;
45188 void *argp2 = 0 ;
45189 int res2 = 0 ;
45190 PyObject * obj0 = 0 ;
45191 PyObject * obj1 = 0 ;
45192 char * kwnames[] = {
45193 (char *) "self",(char *) "parent", NULL
45194 };
45195
45196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
45197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45198 if (!SWIG_IsOK(res1)) {
45199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
45200 }
45201 arg1 = reinterpret_cast< wxMenu * >(argp1);
45202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45203 if (!SWIG_IsOK(res2)) {
45204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
45205 }
45206 arg2 = reinterpret_cast< wxMenu * >(argp2);
45207 {
45208 PyThreadState* __tstate = wxPyBeginAllowThreads();
45209 (arg1)->SetParent(arg2);
45210 wxPyEndAllowThreads(__tstate);
45211 if (PyErr_Occurred()) SWIG_fail;
45212 }
45213 resultobj = SWIG_Py_Void();
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45221 PyObject *resultobj = 0;
45222 wxMenu *arg1 = (wxMenu *) 0 ;
45223 wxMenu *result = 0 ;
45224 void *argp1 = 0 ;
45225 int res1 = 0 ;
45226 PyObject *swig_obj[1] ;
45227
45228 if (!args) SWIG_fail;
45229 swig_obj[0] = args;
45230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45231 if (!SWIG_IsOK(res1)) {
45232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
45233 }
45234 arg1 = reinterpret_cast< wxMenu * >(argp1);
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
45238 wxPyEndAllowThreads(__tstate);
45239 if (PyErr_Occurred()) SWIG_fail;
45240 }
45241 {
45242 resultobj = wxPyMake_wxObject(result, 0);
45243 }
45244 return resultobj;
45245 fail:
45246 return NULL;
45247 }
45248
45249
45250 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45251 PyObject *obj;
45252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45253 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
45254 return SWIG_Py_Void();
45255 }
45256
45257 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 return SWIG_Python_InitShadowInstance(args);
45259 }
45260
45261 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45262 PyObject *resultobj = 0;
45263 long arg1 = (long) 0 ;
45264 wxMenuBar *result = 0 ;
45265 long val1 ;
45266 int ecode1 = 0 ;
45267 PyObject * obj0 = 0 ;
45268 char * kwnames[] = {
45269 (char *) "style", NULL
45270 };
45271
45272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
45273 if (obj0) {
45274 ecode1 = SWIG_AsVal_long(obj0, &val1);
45275 if (!SWIG_IsOK(ecode1)) {
45276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
45277 }
45278 arg1 = static_cast< long >(val1);
45279 }
45280 {
45281 if (!wxPyCheckForApp()) SWIG_fail;
45282 PyThreadState* __tstate = wxPyBeginAllowThreads();
45283 result = (wxMenuBar *)new wxMenuBar(arg1);
45284 wxPyEndAllowThreads(__tstate);
45285 if (PyErr_Occurred()) SWIG_fail;
45286 }
45287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
45288 return resultobj;
45289 fail:
45290 return NULL;
45291 }
45292
45293
45294 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45295 PyObject *resultobj = 0;
45296 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45297 wxMenu *arg2 = (wxMenu *) 0 ;
45298 wxString *arg3 = 0 ;
45299 bool result;
45300 void *argp1 = 0 ;
45301 int res1 = 0 ;
45302 void *argp2 = 0 ;
45303 int res2 = 0 ;
45304 bool temp3 = false ;
45305 PyObject * obj0 = 0 ;
45306 PyObject * obj1 = 0 ;
45307 PyObject * obj2 = 0 ;
45308 char * kwnames[] = {
45309 (char *) "self",(char *) "menu",(char *) "title", NULL
45310 };
45311
45312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45314 if (!SWIG_IsOK(res1)) {
45315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45316 }
45317 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45319 if (!SWIG_IsOK(res2)) {
45320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
45321 }
45322 arg2 = reinterpret_cast< wxMenu * >(argp2);
45323 {
45324 arg3 = wxString_in_helper(obj2);
45325 if (arg3 == NULL) SWIG_fail;
45326 temp3 = true;
45327 }
45328 {
45329 PyThreadState* __tstate = wxPyBeginAllowThreads();
45330 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
45331 wxPyEndAllowThreads(__tstate);
45332 if (PyErr_Occurred()) SWIG_fail;
45333 }
45334 {
45335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45336 }
45337 {
45338 if (temp3)
45339 delete arg3;
45340 }
45341 return resultobj;
45342 fail:
45343 {
45344 if (temp3)
45345 delete arg3;
45346 }
45347 return NULL;
45348 }
45349
45350
45351 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45352 PyObject *resultobj = 0;
45353 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45354 size_t arg2 ;
45355 wxMenu *arg3 = (wxMenu *) 0 ;
45356 wxString *arg4 = 0 ;
45357 bool result;
45358 void *argp1 = 0 ;
45359 int res1 = 0 ;
45360 size_t val2 ;
45361 int ecode2 = 0 ;
45362 void *argp3 = 0 ;
45363 int res3 = 0 ;
45364 bool temp4 = false ;
45365 PyObject * obj0 = 0 ;
45366 PyObject * obj1 = 0 ;
45367 PyObject * obj2 = 0 ;
45368 PyObject * obj3 = 0 ;
45369 char * kwnames[] = {
45370 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45371 };
45372
45373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45375 if (!SWIG_IsOK(res1)) {
45376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45377 }
45378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45379 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45380 if (!SWIG_IsOK(ecode2)) {
45381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
45382 }
45383 arg2 = static_cast< size_t >(val2);
45384 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45385 if (!SWIG_IsOK(res3)) {
45386 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
45387 }
45388 arg3 = reinterpret_cast< wxMenu * >(argp3);
45389 {
45390 arg4 = wxString_in_helper(obj3);
45391 if (arg4 == NULL) SWIG_fail;
45392 temp4 = true;
45393 }
45394 {
45395 PyThreadState* __tstate = wxPyBeginAllowThreads();
45396 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
45397 wxPyEndAllowThreads(__tstate);
45398 if (PyErr_Occurred()) SWIG_fail;
45399 }
45400 {
45401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45402 }
45403 {
45404 if (temp4)
45405 delete arg4;
45406 }
45407 return resultobj;
45408 fail:
45409 {
45410 if (temp4)
45411 delete arg4;
45412 }
45413 return NULL;
45414 }
45415
45416
45417 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45418 PyObject *resultobj = 0;
45419 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45420 size_t result;
45421 void *argp1 = 0 ;
45422 int res1 = 0 ;
45423 PyObject *swig_obj[1] ;
45424
45425 if (!args) SWIG_fail;
45426 swig_obj[0] = args;
45427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45430 }
45431 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
45435 wxPyEndAllowThreads(__tstate);
45436 if (PyErr_Occurred()) SWIG_fail;
45437 }
45438 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
45439 return resultobj;
45440 fail:
45441 return NULL;
45442 }
45443
45444
45445 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45446 PyObject *resultobj = 0;
45447 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45448 size_t arg2 ;
45449 wxMenu *result = 0 ;
45450 void *argp1 = 0 ;
45451 int res1 = 0 ;
45452 size_t val2 ;
45453 int ecode2 = 0 ;
45454 PyObject * obj0 = 0 ;
45455 PyObject * obj1 = 0 ;
45456 char * kwnames[] = {
45457 (char *) "self",(char *) "pos", NULL
45458 };
45459
45460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45462 if (!SWIG_IsOK(res1)) {
45463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45464 }
45465 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45466 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45467 if (!SWIG_IsOK(ecode2)) {
45468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
45469 }
45470 arg2 = static_cast< size_t >(val2);
45471 {
45472 PyThreadState* __tstate = wxPyBeginAllowThreads();
45473 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
45474 wxPyEndAllowThreads(__tstate);
45475 if (PyErr_Occurred()) SWIG_fail;
45476 }
45477 {
45478 resultobj = wxPyMake_wxObject(result, 0);
45479 }
45480 return resultobj;
45481 fail:
45482 return NULL;
45483 }
45484
45485
45486 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45487 PyObject *resultobj = 0;
45488 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45489 size_t arg2 ;
45490 wxMenu *arg3 = (wxMenu *) 0 ;
45491 wxString *arg4 = 0 ;
45492 wxMenu *result = 0 ;
45493 void *argp1 = 0 ;
45494 int res1 = 0 ;
45495 size_t val2 ;
45496 int ecode2 = 0 ;
45497 void *argp3 = 0 ;
45498 int res3 = 0 ;
45499 bool temp4 = false ;
45500 PyObject * obj0 = 0 ;
45501 PyObject * obj1 = 0 ;
45502 PyObject * obj2 = 0 ;
45503 PyObject * obj3 = 0 ;
45504 char * kwnames[] = {
45505 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45506 };
45507
45508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45510 if (!SWIG_IsOK(res1)) {
45511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45512 }
45513 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45514 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45515 if (!SWIG_IsOK(ecode2)) {
45516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45517 }
45518 arg2 = static_cast< size_t >(val2);
45519 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45520 if (!SWIG_IsOK(res3)) {
45521 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45522 }
45523 arg3 = reinterpret_cast< wxMenu * >(argp3);
45524 {
45525 arg4 = wxString_in_helper(obj3);
45526 if (arg4 == NULL) SWIG_fail;
45527 temp4 = true;
45528 }
45529 {
45530 PyThreadState* __tstate = wxPyBeginAllowThreads();
45531 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45532 wxPyEndAllowThreads(__tstate);
45533 if (PyErr_Occurred()) SWIG_fail;
45534 }
45535 {
45536 resultobj = wxPyMake_wxObject(result, 0);
45537 }
45538 {
45539 if (temp4)
45540 delete arg4;
45541 }
45542 return resultobj;
45543 fail:
45544 {
45545 if (temp4)
45546 delete arg4;
45547 }
45548 return NULL;
45549 }
45550
45551
45552 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45553 PyObject *resultobj = 0;
45554 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45555 size_t arg2 ;
45556 wxMenu *result = 0 ;
45557 void *argp1 = 0 ;
45558 int res1 = 0 ;
45559 size_t val2 ;
45560 int ecode2 = 0 ;
45561 PyObject * obj0 = 0 ;
45562 PyObject * obj1 = 0 ;
45563 char * kwnames[] = {
45564 (char *) "self",(char *) "pos", NULL
45565 };
45566
45567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45569 if (!SWIG_IsOK(res1)) {
45570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45571 }
45572 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45573 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45574 if (!SWIG_IsOK(ecode2)) {
45575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45576 }
45577 arg2 = static_cast< size_t >(val2);
45578 {
45579 PyThreadState* __tstate = wxPyBeginAllowThreads();
45580 result = (wxMenu *)(arg1)->Remove(arg2);
45581 wxPyEndAllowThreads(__tstate);
45582 if (PyErr_Occurred()) SWIG_fail;
45583 }
45584 {
45585 resultobj = wxPyMake_wxObject(result, 0);
45586 }
45587 return resultobj;
45588 fail:
45589 return NULL;
45590 }
45591
45592
45593 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45594 PyObject *resultobj = 0;
45595 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45596 size_t arg2 ;
45597 bool arg3 ;
45598 void *argp1 = 0 ;
45599 int res1 = 0 ;
45600 size_t val2 ;
45601 int ecode2 = 0 ;
45602 bool val3 ;
45603 int ecode3 = 0 ;
45604 PyObject * obj0 = 0 ;
45605 PyObject * obj1 = 0 ;
45606 PyObject * obj2 = 0 ;
45607 char * kwnames[] = {
45608 (char *) "self",(char *) "pos",(char *) "enable", NULL
45609 };
45610
45611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45613 if (!SWIG_IsOK(res1)) {
45614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45615 }
45616 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45617 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45618 if (!SWIG_IsOK(ecode2)) {
45619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45620 }
45621 arg2 = static_cast< size_t >(val2);
45622 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45623 if (!SWIG_IsOK(ecode3)) {
45624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45625 }
45626 arg3 = static_cast< bool >(val3);
45627 {
45628 PyThreadState* __tstate = wxPyBeginAllowThreads();
45629 (arg1)->EnableTop(arg2,arg3);
45630 wxPyEndAllowThreads(__tstate);
45631 if (PyErr_Occurred()) SWIG_fail;
45632 }
45633 resultobj = SWIG_Py_Void();
45634 return resultobj;
45635 fail:
45636 return NULL;
45637 }
45638
45639
45640 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45641 PyObject *resultobj = 0;
45642 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45643 size_t arg2 ;
45644 bool result;
45645 void *argp1 = 0 ;
45646 int res1 = 0 ;
45647 size_t val2 ;
45648 int ecode2 = 0 ;
45649 PyObject * obj0 = 0 ;
45650 PyObject * obj1 = 0 ;
45651 char * kwnames[] = {
45652 (char *) "self",(char *) "pos", NULL
45653 };
45654
45655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45657 if (!SWIG_IsOK(res1)) {
45658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45659 }
45660 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45661 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45662 if (!SWIG_IsOK(ecode2)) {
45663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45664 }
45665 arg2 = static_cast< size_t >(val2);
45666 {
45667 PyThreadState* __tstate = wxPyBeginAllowThreads();
45668 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45669 wxPyEndAllowThreads(__tstate);
45670 if (PyErr_Occurred()) SWIG_fail;
45671 }
45672 {
45673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45674 }
45675 return resultobj;
45676 fail:
45677 return NULL;
45678 }
45679
45680
45681 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45682 PyObject *resultobj = 0;
45683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45684 size_t arg2 ;
45685 wxString *arg3 = 0 ;
45686 void *argp1 = 0 ;
45687 int res1 = 0 ;
45688 size_t val2 ;
45689 int ecode2 = 0 ;
45690 bool temp3 = false ;
45691 PyObject * obj0 = 0 ;
45692 PyObject * obj1 = 0 ;
45693 PyObject * obj2 = 0 ;
45694 char * kwnames[] = {
45695 (char *) "self",(char *) "pos",(char *) "label", NULL
45696 };
45697
45698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45700 if (!SWIG_IsOK(res1)) {
45701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45702 }
45703 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45704 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45705 if (!SWIG_IsOK(ecode2)) {
45706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45707 }
45708 arg2 = static_cast< size_t >(val2);
45709 {
45710 arg3 = wxString_in_helper(obj2);
45711 if (arg3 == NULL) SWIG_fail;
45712 temp3 = true;
45713 }
45714 {
45715 PyThreadState* __tstate = wxPyBeginAllowThreads();
45716 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45717 wxPyEndAllowThreads(__tstate);
45718 if (PyErr_Occurred()) SWIG_fail;
45719 }
45720 resultobj = SWIG_Py_Void();
45721 {
45722 if (temp3)
45723 delete arg3;
45724 }
45725 return resultobj;
45726 fail:
45727 {
45728 if (temp3)
45729 delete arg3;
45730 }
45731 return NULL;
45732 }
45733
45734
45735 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45736 PyObject *resultobj = 0;
45737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45738 size_t arg2 ;
45739 wxString result;
45740 void *argp1 = 0 ;
45741 int res1 = 0 ;
45742 size_t val2 ;
45743 int ecode2 = 0 ;
45744 PyObject * obj0 = 0 ;
45745 PyObject * obj1 = 0 ;
45746 char * kwnames[] = {
45747 (char *) "self",(char *) "pos", NULL
45748 };
45749
45750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45752 if (!SWIG_IsOK(res1)) {
45753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45754 }
45755 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45756 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45757 if (!SWIG_IsOK(ecode2)) {
45758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45759 }
45760 arg2 = static_cast< size_t >(val2);
45761 {
45762 PyThreadState* __tstate = wxPyBeginAllowThreads();
45763 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45764 wxPyEndAllowThreads(__tstate);
45765 if (PyErr_Occurred()) SWIG_fail;
45766 }
45767 {
45768 #if wxUSE_UNICODE
45769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45770 #else
45771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45772 #endif
45773 }
45774 return resultobj;
45775 fail:
45776 return NULL;
45777 }
45778
45779
45780 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45781 PyObject *resultobj = 0;
45782 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45783 wxString *arg2 = 0 ;
45784 wxString *arg3 = 0 ;
45785 int result;
45786 void *argp1 = 0 ;
45787 int res1 = 0 ;
45788 bool temp2 = false ;
45789 bool temp3 = false ;
45790 PyObject * obj0 = 0 ;
45791 PyObject * obj1 = 0 ;
45792 PyObject * obj2 = 0 ;
45793 char * kwnames[] = {
45794 (char *) "self",(char *) "menu",(char *) "item", NULL
45795 };
45796
45797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45799 if (!SWIG_IsOK(res1)) {
45800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45801 }
45802 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45803 {
45804 arg2 = wxString_in_helper(obj1);
45805 if (arg2 == NULL) SWIG_fail;
45806 temp2 = true;
45807 }
45808 {
45809 arg3 = wxString_in_helper(obj2);
45810 if (arg3 == NULL) SWIG_fail;
45811 temp3 = true;
45812 }
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45816 wxPyEndAllowThreads(__tstate);
45817 if (PyErr_Occurred()) SWIG_fail;
45818 }
45819 resultobj = SWIG_From_int(static_cast< int >(result));
45820 {
45821 if (temp2)
45822 delete arg2;
45823 }
45824 {
45825 if (temp3)
45826 delete arg3;
45827 }
45828 return resultobj;
45829 fail:
45830 {
45831 if (temp2)
45832 delete arg2;
45833 }
45834 {
45835 if (temp3)
45836 delete arg3;
45837 }
45838 return NULL;
45839 }
45840
45841
45842 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45843 PyObject *resultobj = 0;
45844 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45845 int arg2 ;
45846 wxMenuItem *result = 0 ;
45847 void *argp1 = 0 ;
45848 int res1 = 0 ;
45849 int val2 ;
45850 int ecode2 = 0 ;
45851 PyObject * obj0 = 0 ;
45852 PyObject * obj1 = 0 ;
45853 char * kwnames[] = {
45854 (char *) "self",(char *) "id", NULL
45855 };
45856
45857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45859 if (!SWIG_IsOK(res1)) {
45860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45861 }
45862 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45863 ecode2 = SWIG_AsVal_int(obj1, &val2);
45864 if (!SWIG_IsOK(ecode2)) {
45865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45866 }
45867 arg2 = static_cast< int >(val2);
45868 {
45869 PyThreadState* __tstate = wxPyBeginAllowThreads();
45870 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 {
45875 resultobj = wxPyMake_wxObject(result, (bool)0);
45876 }
45877 return resultobj;
45878 fail:
45879 return NULL;
45880 }
45881
45882
45883 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45884 PyObject *resultobj = 0;
45885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45886 wxString *arg2 = 0 ;
45887 int result;
45888 void *argp1 = 0 ;
45889 int res1 = 0 ;
45890 bool temp2 = false ;
45891 PyObject * obj0 = 0 ;
45892 PyObject * obj1 = 0 ;
45893 char * kwnames[] = {
45894 (char *) "self",(char *) "title", NULL
45895 };
45896
45897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45899 if (!SWIG_IsOK(res1)) {
45900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45901 }
45902 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45903 {
45904 arg2 = wxString_in_helper(obj1);
45905 if (arg2 == NULL) SWIG_fail;
45906 temp2 = true;
45907 }
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 resultobj = SWIG_From_int(static_cast< int >(result));
45915 {
45916 if (temp2)
45917 delete arg2;
45918 }
45919 return resultobj;
45920 fail:
45921 {
45922 if (temp2)
45923 delete arg2;
45924 }
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45930 PyObject *resultobj = 0;
45931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45932 int arg2 ;
45933 bool arg3 ;
45934 void *argp1 = 0 ;
45935 int res1 = 0 ;
45936 int val2 ;
45937 int ecode2 = 0 ;
45938 bool val3 ;
45939 int ecode3 = 0 ;
45940 PyObject * obj0 = 0 ;
45941 PyObject * obj1 = 0 ;
45942 PyObject * obj2 = 0 ;
45943 char * kwnames[] = {
45944 (char *) "self",(char *) "id",(char *) "enable", NULL
45945 };
45946
45947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45949 if (!SWIG_IsOK(res1)) {
45950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45951 }
45952 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45953 ecode2 = SWIG_AsVal_int(obj1, &val2);
45954 if (!SWIG_IsOK(ecode2)) {
45955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45956 }
45957 arg2 = static_cast< int >(val2);
45958 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45959 if (!SWIG_IsOK(ecode3)) {
45960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45961 }
45962 arg3 = static_cast< bool >(val3);
45963 {
45964 PyThreadState* __tstate = wxPyBeginAllowThreads();
45965 (arg1)->Enable(arg2,arg3);
45966 wxPyEndAllowThreads(__tstate);
45967 if (PyErr_Occurred()) SWIG_fail;
45968 }
45969 resultobj = SWIG_Py_Void();
45970 return resultobj;
45971 fail:
45972 return NULL;
45973 }
45974
45975
45976 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45977 PyObject *resultobj = 0;
45978 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45979 int arg2 ;
45980 bool arg3 ;
45981 void *argp1 = 0 ;
45982 int res1 = 0 ;
45983 int val2 ;
45984 int ecode2 = 0 ;
45985 bool val3 ;
45986 int ecode3 = 0 ;
45987 PyObject * obj0 = 0 ;
45988 PyObject * obj1 = 0 ;
45989 PyObject * obj2 = 0 ;
45990 char * kwnames[] = {
45991 (char *) "self",(char *) "id",(char *) "check", NULL
45992 };
45993
45994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45996 if (!SWIG_IsOK(res1)) {
45997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45998 }
45999 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46000 ecode2 = SWIG_AsVal_int(obj1, &val2);
46001 if (!SWIG_IsOK(ecode2)) {
46002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
46003 }
46004 arg2 = static_cast< int >(val2);
46005 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46006 if (!SWIG_IsOK(ecode3)) {
46007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
46008 }
46009 arg3 = static_cast< bool >(val3);
46010 {
46011 PyThreadState* __tstate = wxPyBeginAllowThreads();
46012 (arg1)->Check(arg2,arg3);
46013 wxPyEndAllowThreads(__tstate);
46014 if (PyErr_Occurred()) SWIG_fail;
46015 }
46016 resultobj = SWIG_Py_Void();
46017 return resultobj;
46018 fail:
46019 return NULL;
46020 }
46021
46022
46023 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46024 PyObject *resultobj = 0;
46025 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46026 int arg2 ;
46027 bool result;
46028 void *argp1 = 0 ;
46029 int res1 = 0 ;
46030 int val2 ;
46031 int ecode2 = 0 ;
46032 PyObject * obj0 = 0 ;
46033 PyObject * obj1 = 0 ;
46034 char * kwnames[] = {
46035 (char *) "self",(char *) "id", NULL
46036 };
46037
46038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
46039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46040 if (!SWIG_IsOK(res1)) {
46041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46042 }
46043 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46044 ecode2 = SWIG_AsVal_int(obj1, &val2);
46045 if (!SWIG_IsOK(ecode2)) {
46046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
46047 }
46048 arg2 = static_cast< int >(val2);
46049 {
46050 PyThreadState* __tstate = wxPyBeginAllowThreads();
46051 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
46052 wxPyEndAllowThreads(__tstate);
46053 if (PyErr_Occurred()) SWIG_fail;
46054 }
46055 {
46056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46057 }
46058 return resultobj;
46059 fail:
46060 return NULL;
46061 }
46062
46063
46064 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46065 PyObject *resultobj = 0;
46066 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46067 int arg2 ;
46068 bool result;
46069 void *argp1 = 0 ;
46070 int res1 = 0 ;
46071 int val2 ;
46072 int ecode2 = 0 ;
46073 PyObject * obj0 = 0 ;
46074 PyObject * obj1 = 0 ;
46075 char * kwnames[] = {
46076 (char *) "self",(char *) "id", NULL
46077 };
46078
46079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
46080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46081 if (!SWIG_IsOK(res1)) {
46082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46083 }
46084 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46085 ecode2 = SWIG_AsVal_int(obj1, &val2);
46086 if (!SWIG_IsOK(ecode2)) {
46087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
46088 }
46089 arg2 = static_cast< int >(val2);
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 {
46097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46098 }
46099 return resultobj;
46100 fail:
46101 return NULL;
46102 }
46103
46104
46105 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46106 PyObject *resultobj = 0;
46107 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46108 int arg2 ;
46109 wxString *arg3 = 0 ;
46110 void *argp1 = 0 ;
46111 int res1 = 0 ;
46112 int val2 ;
46113 int ecode2 = 0 ;
46114 bool temp3 = false ;
46115 PyObject * obj0 = 0 ;
46116 PyObject * obj1 = 0 ;
46117 PyObject * obj2 = 0 ;
46118 char * kwnames[] = {
46119 (char *) "self",(char *) "id",(char *) "label", NULL
46120 };
46121
46122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46126 }
46127 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46128 ecode2 = SWIG_AsVal_int(obj1, &val2);
46129 if (!SWIG_IsOK(ecode2)) {
46130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
46131 }
46132 arg2 = static_cast< int >(val2);
46133 {
46134 arg3 = wxString_in_helper(obj2);
46135 if (arg3 == NULL) SWIG_fail;
46136 temp3 = true;
46137 }
46138 {
46139 PyThreadState* __tstate = wxPyBeginAllowThreads();
46140 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
46141 wxPyEndAllowThreads(__tstate);
46142 if (PyErr_Occurred()) SWIG_fail;
46143 }
46144 resultobj = SWIG_Py_Void();
46145 {
46146 if (temp3)
46147 delete arg3;
46148 }
46149 return resultobj;
46150 fail:
46151 {
46152 if (temp3)
46153 delete arg3;
46154 }
46155 return NULL;
46156 }
46157
46158
46159 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46160 PyObject *resultobj = 0;
46161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46162 int arg2 ;
46163 wxString result;
46164 void *argp1 = 0 ;
46165 int res1 = 0 ;
46166 int val2 ;
46167 int ecode2 = 0 ;
46168 PyObject * obj0 = 0 ;
46169 PyObject * obj1 = 0 ;
46170 char * kwnames[] = {
46171 (char *) "self",(char *) "id", NULL
46172 };
46173
46174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
46175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46178 }
46179 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46180 ecode2 = SWIG_AsVal_int(obj1, &val2);
46181 if (!SWIG_IsOK(ecode2)) {
46182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
46183 }
46184 arg2 = static_cast< int >(val2);
46185 {
46186 PyThreadState* __tstate = wxPyBeginAllowThreads();
46187 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
46188 wxPyEndAllowThreads(__tstate);
46189 if (PyErr_Occurred()) SWIG_fail;
46190 }
46191 {
46192 #if wxUSE_UNICODE
46193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46194 #else
46195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46196 #endif
46197 }
46198 return resultobj;
46199 fail:
46200 return NULL;
46201 }
46202
46203
46204 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46205 PyObject *resultobj = 0;
46206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46207 int arg2 ;
46208 wxString *arg3 = 0 ;
46209 void *argp1 = 0 ;
46210 int res1 = 0 ;
46211 int val2 ;
46212 int ecode2 = 0 ;
46213 bool temp3 = false ;
46214 PyObject * obj0 = 0 ;
46215 PyObject * obj1 = 0 ;
46216 PyObject * obj2 = 0 ;
46217 char * kwnames[] = {
46218 (char *) "self",(char *) "id",(char *) "helpString", NULL
46219 };
46220
46221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46223 if (!SWIG_IsOK(res1)) {
46224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46225 }
46226 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46227 ecode2 = SWIG_AsVal_int(obj1, &val2);
46228 if (!SWIG_IsOK(ecode2)) {
46229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
46230 }
46231 arg2 = static_cast< int >(val2);
46232 {
46233 arg3 = wxString_in_helper(obj2);
46234 if (arg3 == NULL) SWIG_fail;
46235 temp3 = true;
46236 }
46237 {
46238 PyThreadState* __tstate = wxPyBeginAllowThreads();
46239 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
46240 wxPyEndAllowThreads(__tstate);
46241 if (PyErr_Occurred()) SWIG_fail;
46242 }
46243 resultobj = SWIG_Py_Void();
46244 {
46245 if (temp3)
46246 delete arg3;
46247 }
46248 return resultobj;
46249 fail:
46250 {
46251 if (temp3)
46252 delete arg3;
46253 }
46254 return NULL;
46255 }
46256
46257
46258 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46259 PyObject *resultobj = 0;
46260 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46261 int arg2 ;
46262 wxString result;
46263 void *argp1 = 0 ;
46264 int res1 = 0 ;
46265 int val2 ;
46266 int ecode2 = 0 ;
46267 PyObject * obj0 = 0 ;
46268 PyObject * obj1 = 0 ;
46269 char * kwnames[] = {
46270 (char *) "self",(char *) "id", NULL
46271 };
46272
46273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
46274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46275 if (!SWIG_IsOK(res1)) {
46276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46277 }
46278 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46279 ecode2 = SWIG_AsVal_int(obj1, &val2);
46280 if (!SWIG_IsOK(ecode2)) {
46281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
46282 }
46283 arg2 = static_cast< int >(val2);
46284 {
46285 PyThreadState* __tstate = wxPyBeginAllowThreads();
46286 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
46287 wxPyEndAllowThreads(__tstate);
46288 if (PyErr_Occurred()) SWIG_fail;
46289 }
46290 {
46291 #if wxUSE_UNICODE
46292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46293 #else
46294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46295 #endif
46296 }
46297 return resultobj;
46298 fail:
46299 return NULL;
46300 }
46301
46302
46303 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46304 PyObject *resultobj = 0;
46305 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46306 wxFrame *result = 0 ;
46307 void *argp1 = 0 ;
46308 int res1 = 0 ;
46309 PyObject *swig_obj[1] ;
46310
46311 if (!args) SWIG_fail;
46312 swig_obj[0] = args;
46313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46314 if (!SWIG_IsOK(res1)) {
46315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46316 }
46317 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46318 {
46319 PyThreadState* __tstate = wxPyBeginAllowThreads();
46320 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
46321 wxPyEndAllowThreads(__tstate);
46322 if (PyErr_Occurred()) SWIG_fail;
46323 }
46324 {
46325 resultobj = wxPyMake_wxObject(result, (bool)0);
46326 }
46327 return resultobj;
46328 fail:
46329 return NULL;
46330 }
46331
46332
46333 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46334 PyObject *resultobj = 0;
46335 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46336 bool result;
46337 void *argp1 = 0 ;
46338 int res1 = 0 ;
46339 PyObject *swig_obj[1] ;
46340
46341 if (!args) SWIG_fail;
46342 swig_obj[0] = args;
46343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46344 if (!SWIG_IsOK(res1)) {
46345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46346 }
46347 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46348 {
46349 PyThreadState* __tstate = wxPyBeginAllowThreads();
46350 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
46351 wxPyEndAllowThreads(__tstate);
46352 if (PyErr_Occurred()) SWIG_fail;
46353 }
46354 {
46355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46356 }
46357 return resultobj;
46358 fail:
46359 return NULL;
46360 }
46361
46362
46363 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46364 PyObject *resultobj = 0;
46365 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46366 wxFrame *arg2 = (wxFrame *) 0 ;
46367 void *argp1 = 0 ;
46368 int res1 = 0 ;
46369 void *argp2 = 0 ;
46370 int res2 = 0 ;
46371 PyObject * obj0 = 0 ;
46372 PyObject * obj1 = 0 ;
46373 char * kwnames[] = {
46374 (char *) "self",(char *) "frame", NULL
46375 };
46376
46377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
46378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46379 if (!SWIG_IsOK(res1)) {
46380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46381 }
46382 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
46384 if (!SWIG_IsOK(res2)) {
46385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
46386 }
46387 arg2 = reinterpret_cast< wxFrame * >(argp2);
46388 {
46389 PyThreadState* __tstate = wxPyBeginAllowThreads();
46390 (arg1)->Attach(arg2);
46391 wxPyEndAllowThreads(__tstate);
46392 if (PyErr_Occurred()) SWIG_fail;
46393 }
46394 resultobj = SWIG_Py_Void();
46395 return resultobj;
46396 fail:
46397 return NULL;
46398 }
46399
46400
46401 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46402 PyObject *resultobj = 0;
46403 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46404 void *argp1 = 0 ;
46405 int res1 = 0 ;
46406 PyObject *swig_obj[1] ;
46407
46408 if (!args) SWIG_fail;
46409 swig_obj[0] = args;
46410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46411 if (!SWIG_IsOK(res1)) {
46412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46413 }
46414 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46415 {
46416 PyThreadState* __tstate = wxPyBeginAllowThreads();
46417 (arg1)->Detach();
46418 wxPyEndAllowThreads(__tstate);
46419 if (PyErr_Occurred()) SWIG_fail;
46420 }
46421 resultobj = SWIG_Py_Void();
46422 return resultobj;
46423 fail:
46424 return NULL;
46425 }
46426
46427
46428 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46429 PyObject *resultobj = 0;
46430 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46431 void *argp1 = 0 ;
46432 int res1 = 0 ;
46433 PyObject *swig_obj[1] ;
46434
46435 if (!args) SWIG_fail;
46436 swig_obj[0] = args;
46437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46438 if (!SWIG_IsOK(res1)) {
46439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46440 }
46441 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46442 {
46443 PyThreadState* __tstate = wxPyBeginAllowThreads();
46444 (arg1)->UpdateMenus();
46445 wxPyEndAllowThreads(__tstate);
46446 if (PyErr_Occurred()) SWIG_fail;
46447 }
46448 resultobj = SWIG_Py_Void();
46449 return resultobj;
46450 fail:
46451 return NULL;
46452 }
46453
46454
46455 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46456 PyObject *resultobj = 0;
46457 bool arg1 ;
46458 bool val1 ;
46459 int ecode1 = 0 ;
46460 PyObject * obj0 = 0 ;
46461 char * kwnames[] = {
46462 (char *) "enable", NULL
46463 };
46464
46465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
46466 ecode1 = SWIG_AsVal_bool(obj0, &val1);
46467 if (!SWIG_IsOK(ecode1)) {
46468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
46469 }
46470 arg1 = static_cast< bool >(val1);
46471 {
46472 PyThreadState* __tstate = wxPyBeginAllowThreads();
46473 wxMenuBar_SetAutoWindowMenu(arg1);
46474 wxPyEndAllowThreads(__tstate);
46475 if (PyErr_Occurred()) SWIG_fail;
46476 }
46477 resultobj = SWIG_Py_Void();
46478 return resultobj;
46479 fail:
46480 return NULL;
46481 }
46482
46483
46484 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46485 PyObject *resultobj = 0;
46486 bool result;
46487
46488 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
46489 {
46490 PyThreadState* __tstate = wxPyBeginAllowThreads();
46491 result = (bool)wxMenuBar_GetAutoWindowMenu();
46492 wxPyEndAllowThreads(__tstate);
46493 if (PyErr_Occurred()) SWIG_fail;
46494 }
46495 {
46496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46497 }
46498 return resultobj;
46499 fail:
46500 return NULL;
46501 }
46502
46503
46504 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46505 PyObject *obj;
46506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46507 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46508 return SWIG_Py_Void();
46509 }
46510
46511 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46512 return SWIG_Python_InitShadowInstance(args);
46513 }
46514
46515 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46516 PyObject *resultobj = 0;
46517 wxMenu *arg1 = (wxMenu *) NULL ;
46518 int arg2 = (int) wxID_SEPARATOR ;
46519 wxString const &arg3_defvalue = wxPyEmptyString ;
46520 wxString *arg3 = (wxString *) &arg3_defvalue ;
46521 wxString const &arg4_defvalue = wxPyEmptyString ;
46522 wxString *arg4 = (wxString *) &arg4_defvalue ;
46523 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46524 wxMenu *arg6 = (wxMenu *) NULL ;
46525 wxMenuItem *result = 0 ;
46526 void *argp1 = 0 ;
46527 int res1 = 0 ;
46528 int val2 ;
46529 int ecode2 = 0 ;
46530 bool temp3 = false ;
46531 bool temp4 = false ;
46532 int val5 ;
46533 int ecode5 = 0 ;
46534 void *argp6 = 0 ;
46535 int res6 = 0 ;
46536 PyObject * obj0 = 0 ;
46537 PyObject * obj1 = 0 ;
46538 PyObject * obj2 = 0 ;
46539 PyObject * obj3 = 0 ;
46540 PyObject * obj4 = 0 ;
46541 PyObject * obj5 = 0 ;
46542 char * kwnames[] = {
46543 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46544 };
46545
46546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46547 if (obj0) {
46548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46549 if (!SWIG_IsOK(res1)) {
46550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46551 }
46552 arg1 = reinterpret_cast< wxMenu * >(argp1);
46553 }
46554 if (obj1) {
46555 ecode2 = SWIG_AsVal_int(obj1, &val2);
46556 if (!SWIG_IsOK(ecode2)) {
46557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46558 }
46559 arg2 = static_cast< int >(val2);
46560 }
46561 if (obj2) {
46562 {
46563 arg3 = wxString_in_helper(obj2);
46564 if (arg3 == NULL) SWIG_fail;
46565 temp3 = true;
46566 }
46567 }
46568 if (obj3) {
46569 {
46570 arg4 = wxString_in_helper(obj3);
46571 if (arg4 == NULL) SWIG_fail;
46572 temp4 = true;
46573 }
46574 }
46575 if (obj4) {
46576 ecode5 = SWIG_AsVal_int(obj4, &val5);
46577 if (!SWIG_IsOK(ecode5)) {
46578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46579 }
46580 arg5 = static_cast< wxItemKind >(val5);
46581 }
46582 if (obj5) {
46583 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46584 if (!SWIG_IsOK(res6)) {
46585 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46586 }
46587 arg6 = reinterpret_cast< wxMenu * >(argp6);
46588 }
46589 {
46590 PyThreadState* __tstate = wxPyBeginAllowThreads();
46591 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46592 wxPyEndAllowThreads(__tstate);
46593 if (PyErr_Occurred()) SWIG_fail;
46594 }
46595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46596 {
46597 if (temp3)
46598 delete arg3;
46599 }
46600 {
46601 if (temp4)
46602 delete arg4;
46603 }
46604 return resultobj;
46605 fail:
46606 {
46607 if (temp3)
46608 delete arg3;
46609 }
46610 {
46611 if (temp4)
46612 delete arg4;
46613 }
46614 return NULL;
46615 }
46616
46617
46618 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46619 PyObject *resultobj = 0;
46620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46621 void *argp1 = 0 ;
46622 int res1 = 0 ;
46623 PyObject *swig_obj[1] ;
46624
46625 if (!args) SWIG_fail;
46626 swig_obj[0] = args;
46627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46628 if (!SWIG_IsOK(res1)) {
46629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46630 }
46631 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46632 {
46633 PyThreadState* __tstate = wxPyBeginAllowThreads();
46634 delete arg1;
46635
46636 wxPyEndAllowThreads(__tstate);
46637 if (PyErr_Occurred()) SWIG_fail;
46638 }
46639 resultobj = SWIG_Py_Void();
46640 return resultobj;
46641 fail:
46642 return NULL;
46643 }
46644
46645
46646 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46647 PyObject *resultobj = 0;
46648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46649 wxMenu *result = 0 ;
46650 void *argp1 = 0 ;
46651 int res1 = 0 ;
46652 PyObject *swig_obj[1] ;
46653
46654 if (!args) SWIG_fail;
46655 swig_obj[0] = args;
46656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46659 }
46660 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46661 {
46662 PyThreadState* __tstate = wxPyBeginAllowThreads();
46663 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46664 wxPyEndAllowThreads(__tstate);
46665 if (PyErr_Occurred()) SWIG_fail;
46666 }
46667 {
46668 resultobj = wxPyMake_wxObject(result, 0);
46669 }
46670 return resultobj;
46671 fail:
46672 return NULL;
46673 }
46674
46675
46676 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46677 PyObject *resultobj = 0;
46678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46679 wxMenu *arg2 = (wxMenu *) 0 ;
46680 void *argp1 = 0 ;
46681 int res1 = 0 ;
46682 void *argp2 = 0 ;
46683 int res2 = 0 ;
46684 PyObject * obj0 = 0 ;
46685 PyObject * obj1 = 0 ;
46686 char * kwnames[] = {
46687 (char *) "self",(char *) "menu", NULL
46688 };
46689
46690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46692 if (!SWIG_IsOK(res1)) {
46693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46694 }
46695 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46697 if (!SWIG_IsOK(res2)) {
46698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46699 }
46700 arg2 = reinterpret_cast< wxMenu * >(argp2);
46701 {
46702 PyThreadState* __tstate = wxPyBeginAllowThreads();
46703 (arg1)->SetMenu(arg2);
46704 wxPyEndAllowThreads(__tstate);
46705 if (PyErr_Occurred()) SWIG_fail;
46706 }
46707 resultobj = SWIG_Py_Void();
46708 return resultobj;
46709 fail:
46710 return NULL;
46711 }
46712
46713
46714 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46715 PyObject *resultobj = 0;
46716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46717 int arg2 ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 int val2 ;
46721 int ecode2 = 0 ;
46722 PyObject * obj0 = 0 ;
46723 PyObject * obj1 = 0 ;
46724 char * kwnames[] = {
46725 (char *) "self",(char *) "id", NULL
46726 };
46727
46728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46730 if (!SWIG_IsOK(res1)) {
46731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46732 }
46733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46734 ecode2 = SWIG_AsVal_int(obj1, &val2);
46735 if (!SWIG_IsOK(ecode2)) {
46736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46737 }
46738 arg2 = static_cast< int >(val2);
46739 {
46740 PyThreadState* __tstate = wxPyBeginAllowThreads();
46741 (arg1)->SetId(arg2);
46742 wxPyEndAllowThreads(__tstate);
46743 if (PyErr_Occurred()) SWIG_fail;
46744 }
46745 resultobj = SWIG_Py_Void();
46746 return resultobj;
46747 fail:
46748 return NULL;
46749 }
46750
46751
46752 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46753 PyObject *resultobj = 0;
46754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46755 int result;
46756 void *argp1 = 0 ;
46757 int res1 = 0 ;
46758 PyObject *swig_obj[1] ;
46759
46760 if (!args) SWIG_fail;
46761 swig_obj[0] = args;
46762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46763 if (!SWIG_IsOK(res1)) {
46764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46765 }
46766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46767 {
46768 PyThreadState* __tstate = wxPyBeginAllowThreads();
46769 result = (int)((wxMenuItem const *)arg1)->GetId();
46770 wxPyEndAllowThreads(__tstate);
46771 if (PyErr_Occurred()) SWIG_fail;
46772 }
46773 resultobj = SWIG_From_int(static_cast< int >(result));
46774 return resultobj;
46775 fail:
46776 return NULL;
46777 }
46778
46779
46780 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46781 PyObject *resultobj = 0;
46782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46783 bool result;
46784 void *argp1 = 0 ;
46785 int res1 = 0 ;
46786 PyObject *swig_obj[1] ;
46787
46788 if (!args) SWIG_fail;
46789 swig_obj[0] = args;
46790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46791 if (!SWIG_IsOK(res1)) {
46792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46793 }
46794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46795 {
46796 PyThreadState* __tstate = wxPyBeginAllowThreads();
46797 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46798 wxPyEndAllowThreads(__tstate);
46799 if (PyErr_Occurred()) SWIG_fail;
46800 }
46801 {
46802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46803 }
46804 return resultobj;
46805 fail:
46806 return NULL;
46807 }
46808
46809
46810 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46811 PyObject *resultobj = 0;
46812 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46813 wxString *arg2 = 0 ;
46814 void *argp1 = 0 ;
46815 int res1 = 0 ;
46816 bool temp2 = false ;
46817 PyObject * obj0 = 0 ;
46818 PyObject * obj1 = 0 ;
46819 char * kwnames[] = {
46820 (char *) "self",(char *) "str", NULL
46821 };
46822
46823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46825 if (!SWIG_IsOK(res1)) {
46826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46827 }
46828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46829 {
46830 arg2 = wxString_in_helper(obj1);
46831 if (arg2 == NULL) SWIG_fail;
46832 temp2 = true;
46833 }
46834 {
46835 PyThreadState* __tstate = wxPyBeginAllowThreads();
46836 (arg1)->SetText((wxString const &)*arg2);
46837 wxPyEndAllowThreads(__tstate);
46838 if (PyErr_Occurred()) SWIG_fail;
46839 }
46840 resultobj = SWIG_Py_Void();
46841 {
46842 if (temp2)
46843 delete arg2;
46844 }
46845 return resultobj;
46846 fail:
46847 {
46848 if (temp2)
46849 delete arg2;
46850 }
46851 return NULL;
46852 }
46853
46854
46855 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46856 PyObject *resultobj = 0;
46857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46858 wxString result;
46859 void *argp1 = 0 ;
46860 int res1 = 0 ;
46861 PyObject *swig_obj[1] ;
46862
46863 if (!args) SWIG_fail;
46864 swig_obj[0] = args;
46865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46866 if (!SWIG_IsOK(res1)) {
46867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46868 }
46869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 result = ((wxMenuItem const *)arg1)->GetLabel();
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 {
46877 #if wxUSE_UNICODE
46878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46879 #else
46880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46881 #endif
46882 }
46883 return resultobj;
46884 fail:
46885 return NULL;
46886 }
46887
46888
46889 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46890 PyObject *resultobj = 0;
46891 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46892 wxString *result = 0 ;
46893 void *argp1 = 0 ;
46894 int res1 = 0 ;
46895 PyObject *swig_obj[1] ;
46896
46897 if (!args) SWIG_fail;
46898 swig_obj[0] = args;
46899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46900 if (!SWIG_IsOK(res1)) {
46901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46902 }
46903 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46904 {
46905 PyThreadState* __tstate = wxPyBeginAllowThreads();
46906 {
46907 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46908 result = (wxString *) &_result_ref;
46909 }
46910 wxPyEndAllowThreads(__tstate);
46911 if (PyErr_Occurred()) SWIG_fail;
46912 }
46913 {
46914 #if wxUSE_UNICODE
46915 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46916 #else
46917 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46918 #endif
46919 }
46920 return resultobj;
46921 fail:
46922 return NULL;
46923 }
46924
46925
46926 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46927 PyObject *resultobj = 0;
46928 wxString *arg1 = 0 ;
46929 wxString result;
46930 bool temp1 = false ;
46931 PyObject * obj0 = 0 ;
46932 char * kwnames[] = {
46933 (char *) "text", NULL
46934 };
46935
46936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46937 {
46938 arg1 = wxString_in_helper(obj0);
46939 if (arg1 == NULL) SWIG_fail;
46940 temp1 = true;
46941 }
46942 {
46943 PyThreadState* __tstate = wxPyBeginAllowThreads();
46944 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46945 wxPyEndAllowThreads(__tstate);
46946 if (PyErr_Occurred()) SWIG_fail;
46947 }
46948 {
46949 #if wxUSE_UNICODE
46950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46951 #else
46952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46953 #endif
46954 }
46955 {
46956 if (temp1)
46957 delete arg1;
46958 }
46959 return resultobj;
46960 fail:
46961 {
46962 if (temp1)
46963 delete arg1;
46964 }
46965 return NULL;
46966 }
46967
46968
46969 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46970 PyObject *resultobj = 0;
46971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46972 wxItemKind result;
46973 void *argp1 = 0 ;
46974 int res1 = 0 ;
46975 PyObject *swig_obj[1] ;
46976
46977 if (!args) SWIG_fail;
46978 swig_obj[0] = args;
46979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46980 if (!SWIG_IsOK(res1)) {
46981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46982 }
46983 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46984 {
46985 PyThreadState* __tstate = wxPyBeginAllowThreads();
46986 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46987 wxPyEndAllowThreads(__tstate);
46988 if (PyErr_Occurred()) SWIG_fail;
46989 }
46990 resultobj = SWIG_From_int(static_cast< int >(result));
46991 return resultobj;
46992 fail:
46993 return NULL;
46994 }
46995
46996
46997 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46998 PyObject *resultobj = 0;
46999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47000 wxItemKind arg2 ;
47001 void *argp1 = 0 ;
47002 int res1 = 0 ;
47003 int val2 ;
47004 int ecode2 = 0 ;
47005 PyObject * obj0 = 0 ;
47006 PyObject * obj1 = 0 ;
47007 char * kwnames[] = {
47008 (char *) "self",(char *) "kind", NULL
47009 };
47010
47011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
47012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47013 if (!SWIG_IsOK(res1)) {
47014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47015 }
47016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47017 ecode2 = SWIG_AsVal_int(obj1, &val2);
47018 if (!SWIG_IsOK(ecode2)) {
47019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
47020 }
47021 arg2 = static_cast< wxItemKind >(val2);
47022 {
47023 PyThreadState* __tstate = wxPyBeginAllowThreads();
47024 (arg1)->SetKind(arg2);
47025 wxPyEndAllowThreads(__tstate);
47026 if (PyErr_Occurred()) SWIG_fail;
47027 }
47028 resultobj = SWIG_Py_Void();
47029 return resultobj;
47030 fail:
47031 return NULL;
47032 }
47033
47034
47035 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47036 PyObject *resultobj = 0;
47037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47038 bool arg2 ;
47039 void *argp1 = 0 ;
47040 int res1 = 0 ;
47041 bool val2 ;
47042 int ecode2 = 0 ;
47043 PyObject * obj0 = 0 ;
47044 PyObject * obj1 = 0 ;
47045 char * kwnames[] = {
47046 (char *) "self",(char *) "checkable", NULL
47047 };
47048
47049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
47050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47051 if (!SWIG_IsOK(res1)) {
47052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47053 }
47054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47056 if (!SWIG_IsOK(ecode2)) {
47057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
47058 }
47059 arg2 = static_cast< bool >(val2);
47060 {
47061 PyThreadState* __tstate = wxPyBeginAllowThreads();
47062 (arg1)->SetCheckable(arg2);
47063 wxPyEndAllowThreads(__tstate);
47064 if (PyErr_Occurred()) SWIG_fail;
47065 }
47066 resultobj = SWIG_Py_Void();
47067 return resultobj;
47068 fail:
47069 return NULL;
47070 }
47071
47072
47073 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47074 PyObject *resultobj = 0;
47075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47076 bool result;
47077 void *argp1 = 0 ;
47078 int res1 = 0 ;
47079 PyObject *swig_obj[1] ;
47080
47081 if (!args) SWIG_fail;
47082 swig_obj[0] = args;
47083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47084 if (!SWIG_IsOK(res1)) {
47085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47086 }
47087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47088 {
47089 PyThreadState* __tstate = wxPyBeginAllowThreads();
47090 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
47091 wxPyEndAllowThreads(__tstate);
47092 if (PyErr_Occurred()) SWIG_fail;
47093 }
47094 {
47095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47096 }
47097 return resultobj;
47098 fail:
47099 return NULL;
47100 }
47101
47102
47103 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47104 PyObject *resultobj = 0;
47105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47106 bool result;
47107 void *argp1 = 0 ;
47108 int res1 = 0 ;
47109 PyObject *swig_obj[1] ;
47110
47111 if (!args) SWIG_fail;
47112 swig_obj[0] = args;
47113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47114 if (!SWIG_IsOK(res1)) {
47115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47116 }
47117 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47118 {
47119 PyThreadState* __tstate = wxPyBeginAllowThreads();
47120 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
47121 wxPyEndAllowThreads(__tstate);
47122 if (PyErr_Occurred()) SWIG_fail;
47123 }
47124 {
47125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47126 }
47127 return resultobj;
47128 fail:
47129 return NULL;
47130 }
47131
47132
47133 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47134 PyObject *resultobj = 0;
47135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47136 wxMenu *arg2 = (wxMenu *) 0 ;
47137 void *argp1 = 0 ;
47138 int res1 = 0 ;
47139 void *argp2 = 0 ;
47140 int res2 = 0 ;
47141 PyObject * obj0 = 0 ;
47142 PyObject * obj1 = 0 ;
47143 char * kwnames[] = {
47144 (char *) "self",(char *) "menu", NULL
47145 };
47146
47147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
47148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47149 if (!SWIG_IsOK(res1)) {
47150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47151 }
47152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
47154 if (!SWIG_IsOK(res2)) {
47155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
47156 }
47157 arg2 = reinterpret_cast< wxMenu * >(argp2);
47158 {
47159 PyThreadState* __tstate = wxPyBeginAllowThreads();
47160 (arg1)->SetSubMenu(arg2);
47161 wxPyEndAllowThreads(__tstate);
47162 if (PyErr_Occurred()) SWIG_fail;
47163 }
47164 resultobj = SWIG_Py_Void();
47165 return resultobj;
47166 fail:
47167 return NULL;
47168 }
47169
47170
47171 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47172 PyObject *resultobj = 0;
47173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47174 wxMenu *result = 0 ;
47175 void *argp1 = 0 ;
47176 int res1 = 0 ;
47177 PyObject *swig_obj[1] ;
47178
47179 if (!args) SWIG_fail;
47180 swig_obj[0] = args;
47181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47184 }
47185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47186 {
47187 PyThreadState* __tstate = wxPyBeginAllowThreads();
47188 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
47189 wxPyEndAllowThreads(__tstate);
47190 if (PyErr_Occurred()) SWIG_fail;
47191 }
47192 {
47193 resultobj = wxPyMake_wxObject(result, 0);
47194 }
47195 return resultobj;
47196 fail:
47197 return NULL;
47198 }
47199
47200
47201 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47202 PyObject *resultobj = 0;
47203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47204 bool arg2 = (bool) true ;
47205 void *argp1 = 0 ;
47206 int res1 = 0 ;
47207 bool val2 ;
47208 int ecode2 = 0 ;
47209 PyObject * obj0 = 0 ;
47210 PyObject * obj1 = 0 ;
47211 char * kwnames[] = {
47212 (char *) "self",(char *) "enable", NULL
47213 };
47214
47215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
47216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47217 if (!SWIG_IsOK(res1)) {
47218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47219 }
47220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47221 if (obj1) {
47222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47223 if (!SWIG_IsOK(ecode2)) {
47224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
47225 }
47226 arg2 = static_cast< bool >(val2);
47227 }
47228 {
47229 PyThreadState* __tstate = wxPyBeginAllowThreads();
47230 (arg1)->Enable(arg2);
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 *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47242 PyObject *resultobj = 0;
47243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47244 bool result;
47245 void *argp1 = 0 ;
47246 int res1 = 0 ;
47247 PyObject *swig_obj[1] ;
47248
47249 if (!args) SWIG_fail;
47250 swig_obj[0] = args;
47251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47252 if (!SWIG_IsOK(res1)) {
47253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47254 }
47255 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47256 {
47257 PyThreadState* __tstate = wxPyBeginAllowThreads();
47258 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
47259 wxPyEndAllowThreads(__tstate);
47260 if (PyErr_Occurred()) SWIG_fail;
47261 }
47262 {
47263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47264 }
47265 return resultobj;
47266 fail:
47267 return NULL;
47268 }
47269
47270
47271 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47272 PyObject *resultobj = 0;
47273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47274 bool arg2 = (bool) true ;
47275 void *argp1 = 0 ;
47276 int res1 = 0 ;
47277 bool val2 ;
47278 int ecode2 = 0 ;
47279 PyObject * obj0 = 0 ;
47280 PyObject * obj1 = 0 ;
47281 char * kwnames[] = {
47282 (char *) "self",(char *) "check", NULL
47283 };
47284
47285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
47286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47287 if (!SWIG_IsOK(res1)) {
47288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47289 }
47290 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47291 if (obj1) {
47292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47293 if (!SWIG_IsOK(ecode2)) {
47294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
47295 }
47296 arg2 = static_cast< bool >(val2);
47297 }
47298 {
47299 PyThreadState* __tstate = wxPyBeginAllowThreads();
47300 (arg1)->Check(arg2);
47301 wxPyEndAllowThreads(__tstate);
47302 if (PyErr_Occurred()) SWIG_fail;
47303 }
47304 resultobj = SWIG_Py_Void();
47305 return resultobj;
47306 fail:
47307 return NULL;
47308 }
47309
47310
47311 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47312 PyObject *resultobj = 0;
47313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47314 bool result;
47315 void *argp1 = 0 ;
47316 int res1 = 0 ;
47317 PyObject *swig_obj[1] ;
47318
47319 if (!args) SWIG_fail;
47320 swig_obj[0] = args;
47321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47322 if (!SWIG_IsOK(res1)) {
47323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47324 }
47325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47326 {
47327 PyThreadState* __tstate = wxPyBeginAllowThreads();
47328 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
47329 wxPyEndAllowThreads(__tstate);
47330 if (PyErr_Occurred()) SWIG_fail;
47331 }
47332 {
47333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47334 }
47335 return resultobj;
47336 fail:
47337 return NULL;
47338 }
47339
47340
47341 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47342 PyObject *resultobj = 0;
47343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47344 void *argp1 = 0 ;
47345 int res1 = 0 ;
47346 PyObject *swig_obj[1] ;
47347
47348 if (!args) SWIG_fail;
47349 swig_obj[0] = args;
47350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47351 if (!SWIG_IsOK(res1)) {
47352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47353 }
47354 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47355 {
47356 PyThreadState* __tstate = wxPyBeginAllowThreads();
47357 (arg1)->Toggle();
47358 wxPyEndAllowThreads(__tstate);
47359 if (PyErr_Occurred()) SWIG_fail;
47360 }
47361 resultobj = SWIG_Py_Void();
47362 return resultobj;
47363 fail:
47364 return NULL;
47365 }
47366
47367
47368 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47369 PyObject *resultobj = 0;
47370 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47371 wxString *arg2 = 0 ;
47372 void *argp1 = 0 ;
47373 int res1 = 0 ;
47374 bool temp2 = false ;
47375 PyObject * obj0 = 0 ;
47376 PyObject * obj1 = 0 ;
47377 char * kwnames[] = {
47378 (char *) "self",(char *) "str", NULL
47379 };
47380
47381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
47382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47383 if (!SWIG_IsOK(res1)) {
47384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47385 }
47386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47387 {
47388 arg2 = wxString_in_helper(obj1);
47389 if (arg2 == NULL) SWIG_fail;
47390 temp2 = true;
47391 }
47392 {
47393 PyThreadState* __tstate = wxPyBeginAllowThreads();
47394 (arg1)->SetHelp((wxString const &)*arg2);
47395 wxPyEndAllowThreads(__tstate);
47396 if (PyErr_Occurred()) SWIG_fail;
47397 }
47398 resultobj = SWIG_Py_Void();
47399 {
47400 if (temp2)
47401 delete arg2;
47402 }
47403 return resultobj;
47404 fail:
47405 {
47406 if (temp2)
47407 delete arg2;
47408 }
47409 return NULL;
47410 }
47411
47412
47413 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47414 PyObject *resultobj = 0;
47415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47416 wxString *result = 0 ;
47417 void *argp1 = 0 ;
47418 int res1 = 0 ;
47419 PyObject *swig_obj[1] ;
47420
47421 if (!args) SWIG_fail;
47422 swig_obj[0] = args;
47423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47424 if (!SWIG_IsOK(res1)) {
47425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47426 }
47427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47428 {
47429 PyThreadState* __tstate = wxPyBeginAllowThreads();
47430 {
47431 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
47432 result = (wxString *) &_result_ref;
47433 }
47434 wxPyEndAllowThreads(__tstate);
47435 if (PyErr_Occurred()) SWIG_fail;
47436 }
47437 {
47438 #if wxUSE_UNICODE
47439 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
47440 #else
47441 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
47442 #endif
47443 }
47444 return resultobj;
47445 fail:
47446 return NULL;
47447 }
47448
47449
47450 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47451 PyObject *resultobj = 0;
47452 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47453 wxAcceleratorEntry *result = 0 ;
47454 void *argp1 = 0 ;
47455 int res1 = 0 ;
47456 PyObject *swig_obj[1] ;
47457
47458 if (!args) SWIG_fail;
47459 swig_obj[0] = args;
47460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47463 }
47464 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47465 {
47466 PyThreadState* __tstate = wxPyBeginAllowThreads();
47467 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
47468 wxPyEndAllowThreads(__tstate);
47469 if (PyErr_Occurred()) SWIG_fail;
47470 }
47471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47472 return resultobj;
47473 fail:
47474 return NULL;
47475 }
47476
47477
47478 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47479 PyObject *resultobj = 0;
47480 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47481 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
47482 void *argp1 = 0 ;
47483 int res1 = 0 ;
47484 void *argp2 = 0 ;
47485 int res2 = 0 ;
47486 PyObject * obj0 = 0 ;
47487 PyObject * obj1 = 0 ;
47488 char * kwnames[] = {
47489 (char *) "self",(char *) "accel", NULL
47490 };
47491
47492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
47493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47494 if (!SWIG_IsOK(res1)) {
47495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47496 }
47497 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47499 if (!SWIG_IsOK(res2)) {
47500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47501 }
47502 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47503 {
47504 PyThreadState* __tstate = wxPyBeginAllowThreads();
47505 (arg1)->SetAccel(arg2);
47506 wxPyEndAllowThreads(__tstate);
47507 if (PyErr_Occurred()) SWIG_fail;
47508 }
47509 resultobj = SWIG_Py_Void();
47510 return resultobj;
47511 fail:
47512 return NULL;
47513 }
47514
47515
47516 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47517 PyObject *resultobj = 0;
47518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47519 wxBitmap *arg2 = 0 ;
47520 void *argp1 = 0 ;
47521 int res1 = 0 ;
47522 void *argp2 = 0 ;
47523 int res2 = 0 ;
47524 PyObject * obj0 = 0 ;
47525 PyObject * obj1 = 0 ;
47526 char * kwnames[] = {
47527 (char *) "self",(char *) "bitmap", NULL
47528 };
47529
47530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47532 if (!SWIG_IsOK(res1)) {
47533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47534 }
47535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47537 if (!SWIG_IsOK(res2)) {
47538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47539 }
47540 if (!argp2) {
47541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47542 }
47543 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47544 {
47545 PyThreadState* __tstate = wxPyBeginAllowThreads();
47546 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47547 wxPyEndAllowThreads(__tstate);
47548 if (PyErr_Occurred()) SWIG_fail;
47549 }
47550 resultobj = SWIG_Py_Void();
47551 return resultobj;
47552 fail:
47553 return NULL;
47554 }
47555
47556
47557 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47558 PyObject *resultobj = 0;
47559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47560 wxBitmap *result = 0 ;
47561 void *argp1 = 0 ;
47562 int res1 = 0 ;
47563 PyObject *swig_obj[1] ;
47564
47565 if (!args) SWIG_fail;
47566 swig_obj[0] = args;
47567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47568 if (!SWIG_IsOK(res1)) {
47569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47570 }
47571 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47572 {
47573 PyThreadState* __tstate = wxPyBeginAllowThreads();
47574 {
47575 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47576 result = (wxBitmap *) &_result_ref;
47577 }
47578 wxPyEndAllowThreads(__tstate);
47579 if (PyErr_Occurred()) SWIG_fail;
47580 }
47581 {
47582 wxBitmap* resultptr = new wxBitmap(*result);
47583 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47584 }
47585 return resultobj;
47586 fail:
47587 return NULL;
47588 }
47589
47590
47591 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47592 PyObject *resultobj = 0;
47593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47594 wxFont *arg2 = 0 ;
47595 void *argp1 = 0 ;
47596 int res1 = 0 ;
47597 void *argp2 = 0 ;
47598 int res2 = 0 ;
47599 PyObject * obj0 = 0 ;
47600 PyObject * obj1 = 0 ;
47601 char * kwnames[] = {
47602 (char *) "self",(char *) "font", NULL
47603 };
47604
47605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47607 if (!SWIG_IsOK(res1)) {
47608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47609 }
47610 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47611 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47612 if (!SWIG_IsOK(res2)) {
47613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47614 }
47615 if (!argp2) {
47616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47617 }
47618 arg2 = reinterpret_cast< wxFont * >(argp2);
47619 {
47620 PyThreadState* __tstate = wxPyBeginAllowThreads();
47621 (arg1)->SetFont((wxFont const &)*arg2);
47622 wxPyEndAllowThreads(__tstate);
47623 if (PyErr_Occurred()) SWIG_fail;
47624 }
47625 resultobj = SWIG_Py_Void();
47626 return resultobj;
47627 fail:
47628 return NULL;
47629 }
47630
47631
47632 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47633 PyObject *resultobj = 0;
47634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47635 wxFont result;
47636 void *argp1 = 0 ;
47637 int res1 = 0 ;
47638 PyObject *swig_obj[1] ;
47639
47640 if (!args) SWIG_fail;
47641 swig_obj[0] = args;
47642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47643 if (!SWIG_IsOK(res1)) {
47644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47645 }
47646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47647 {
47648 PyThreadState* __tstate = wxPyBeginAllowThreads();
47649 result = (arg1)->GetFont();
47650 wxPyEndAllowThreads(__tstate);
47651 if (PyErr_Occurred()) SWIG_fail;
47652 }
47653 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47654 return resultobj;
47655 fail:
47656 return NULL;
47657 }
47658
47659
47660 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47661 PyObject *resultobj = 0;
47662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47663 wxColour *arg2 = 0 ;
47664 void *argp1 = 0 ;
47665 int res1 = 0 ;
47666 wxColour temp2 ;
47667 PyObject * obj0 = 0 ;
47668 PyObject * obj1 = 0 ;
47669 char * kwnames[] = {
47670 (char *) "self",(char *) "colText", NULL
47671 };
47672
47673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47675 if (!SWIG_IsOK(res1)) {
47676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47677 }
47678 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47679 {
47680 arg2 = &temp2;
47681 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47682 }
47683 {
47684 PyThreadState* __tstate = wxPyBeginAllowThreads();
47685 (arg1)->SetTextColour((wxColour const &)*arg2);
47686 wxPyEndAllowThreads(__tstate);
47687 if (PyErr_Occurred()) SWIG_fail;
47688 }
47689 resultobj = SWIG_Py_Void();
47690 return resultobj;
47691 fail:
47692 return NULL;
47693 }
47694
47695
47696 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47697 PyObject *resultobj = 0;
47698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47699 wxColour result;
47700 void *argp1 = 0 ;
47701 int res1 = 0 ;
47702 PyObject *swig_obj[1] ;
47703
47704 if (!args) SWIG_fail;
47705 swig_obj[0] = args;
47706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47707 if (!SWIG_IsOK(res1)) {
47708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47709 }
47710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47711 {
47712 PyThreadState* __tstate = wxPyBeginAllowThreads();
47713 result = (arg1)->GetTextColour();
47714 wxPyEndAllowThreads(__tstate);
47715 if (PyErr_Occurred()) SWIG_fail;
47716 }
47717 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47718 return resultobj;
47719 fail:
47720 return NULL;
47721 }
47722
47723
47724 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47725 PyObject *resultobj = 0;
47726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47727 wxColour *arg2 = 0 ;
47728 void *argp1 = 0 ;
47729 int res1 = 0 ;
47730 wxColour temp2 ;
47731 PyObject * obj0 = 0 ;
47732 PyObject * obj1 = 0 ;
47733 char * kwnames[] = {
47734 (char *) "self",(char *) "colBack", NULL
47735 };
47736
47737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47739 if (!SWIG_IsOK(res1)) {
47740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47741 }
47742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47743 {
47744 arg2 = &temp2;
47745 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47746 }
47747 {
47748 PyThreadState* __tstate = wxPyBeginAllowThreads();
47749 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
47750 wxPyEndAllowThreads(__tstate);
47751 if (PyErr_Occurred()) SWIG_fail;
47752 }
47753 resultobj = SWIG_Py_Void();
47754 return resultobj;
47755 fail:
47756 return NULL;
47757 }
47758
47759
47760 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47761 PyObject *resultobj = 0;
47762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47763 wxColour result;
47764 void *argp1 = 0 ;
47765 int res1 = 0 ;
47766 PyObject *swig_obj[1] ;
47767
47768 if (!args) SWIG_fail;
47769 swig_obj[0] = args;
47770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47771 if (!SWIG_IsOK(res1)) {
47772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47773 }
47774 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47775 {
47776 PyThreadState* __tstate = wxPyBeginAllowThreads();
47777 result = (arg1)->GetBackgroundColour();
47778 wxPyEndAllowThreads(__tstate);
47779 if (PyErr_Occurred()) SWIG_fail;
47780 }
47781 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47782 return resultobj;
47783 fail:
47784 return NULL;
47785 }
47786
47787
47788 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47789 PyObject *resultobj = 0;
47790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47791 wxBitmap *arg2 = 0 ;
47792 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47793 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47794 void *argp1 = 0 ;
47795 int res1 = 0 ;
47796 void *argp2 = 0 ;
47797 int res2 = 0 ;
47798 void *argp3 = 0 ;
47799 int res3 = 0 ;
47800 PyObject * obj0 = 0 ;
47801 PyObject * obj1 = 0 ;
47802 PyObject * obj2 = 0 ;
47803 char * kwnames[] = {
47804 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47805 };
47806
47807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47809 if (!SWIG_IsOK(res1)) {
47810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47811 }
47812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47814 if (!SWIG_IsOK(res2)) {
47815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47816 }
47817 if (!argp2) {
47818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47819 }
47820 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47821 if (obj2) {
47822 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47823 if (!SWIG_IsOK(res3)) {
47824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47825 }
47826 if (!argp3) {
47827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47828 }
47829 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47830 }
47831 {
47832 PyThreadState* __tstate = wxPyBeginAllowThreads();
47833 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47834 wxPyEndAllowThreads(__tstate);
47835 if (PyErr_Occurred()) SWIG_fail;
47836 }
47837 resultobj = SWIG_Py_Void();
47838 return resultobj;
47839 fail:
47840 return NULL;
47841 }
47842
47843
47844 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47845 PyObject *resultobj = 0;
47846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47847 wxBitmap *arg2 = 0 ;
47848 void *argp1 = 0 ;
47849 int res1 = 0 ;
47850 void *argp2 = 0 ;
47851 int res2 = 0 ;
47852 PyObject * obj0 = 0 ;
47853 PyObject * obj1 = 0 ;
47854 char * kwnames[] = {
47855 (char *) "self",(char *) "bmpDisabled", NULL
47856 };
47857
47858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47860 if (!SWIG_IsOK(res1)) {
47861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47862 }
47863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47865 if (!SWIG_IsOK(res2)) {
47866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47867 }
47868 if (!argp2) {
47869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47870 }
47871 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47872 {
47873 PyThreadState* __tstate = wxPyBeginAllowThreads();
47874 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47875 wxPyEndAllowThreads(__tstate);
47876 if (PyErr_Occurred()) SWIG_fail;
47877 }
47878 resultobj = SWIG_Py_Void();
47879 return resultobj;
47880 fail:
47881 return NULL;
47882 }
47883
47884
47885 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47886 PyObject *resultobj = 0;
47887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47888 wxBitmap *result = 0 ;
47889 void *argp1 = 0 ;
47890 int res1 = 0 ;
47891 PyObject *swig_obj[1] ;
47892
47893 if (!args) SWIG_fail;
47894 swig_obj[0] = args;
47895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47896 if (!SWIG_IsOK(res1)) {
47897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47898 }
47899 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47900 {
47901 PyThreadState* __tstate = wxPyBeginAllowThreads();
47902 {
47903 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47904 result = (wxBitmap *) &_result_ref;
47905 }
47906 wxPyEndAllowThreads(__tstate);
47907 if (PyErr_Occurred()) SWIG_fail;
47908 }
47909 {
47910 wxBitmap* resultptr = new wxBitmap(*result);
47911 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47912 }
47913 return resultobj;
47914 fail:
47915 return NULL;
47916 }
47917
47918
47919 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47920 PyObject *resultobj = 0;
47921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47922 int arg2 ;
47923 void *argp1 = 0 ;
47924 int res1 = 0 ;
47925 int val2 ;
47926 int ecode2 = 0 ;
47927 PyObject * obj0 = 0 ;
47928 PyObject * obj1 = 0 ;
47929 char * kwnames[] = {
47930 (char *) "self",(char *) "nWidth", NULL
47931 };
47932
47933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47935 if (!SWIG_IsOK(res1)) {
47936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47937 }
47938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47939 ecode2 = SWIG_AsVal_int(obj1, &val2);
47940 if (!SWIG_IsOK(ecode2)) {
47941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47942 }
47943 arg2 = static_cast< int >(val2);
47944 {
47945 PyThreadState* __tstate = wxPyBeginAllowThreads();
47946 (arg1)->SetMarginWidth(arg2);
47947 wxPyEndAllowThreads(__tstate);
47948 if (PyErr_Occurred()) SWIG_fail;
47949 }
47950 resultobj = SWIG_Py_Void();
47951 return resultobj;
47952 fail:
47953 return NULL;
47954 }
47955
47956
47957 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47958 PyObject *resultobj = 0;
47959 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47960 int result;
47961 void *argp1 = 0 ;
47962 int res1 = 0 ;
47963 PyObject *swig_obj[1] ;
47964
47965 if (!args) SWIG_fail;
47966 swig_obj[0] = args;
47967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47968 if (!SWIG_IsOK(res1)) {
47969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47970 }
47971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47972 {
47973 PyThreadState* __tstate = wxPyBeginAllowThreads();
47974 result = (int)(arg1)->GetMarginWidth();
47975 wxPyEndAllowThreads(__tstate);
47976 if (PyErr_Occurred()) SWIG_fail;
47977 }
47978 resultobj = SWIG_From_int(static_cast< int >(result));
47979 return resultobj;
47980 fail:
47981 return NULL;
47982 }
47983
47984
47985 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47986 PyObject *resultobj = 0;
47987 int result;
47988
47989 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47990 {
47991 PyThreadState* __tstate = wxPyBeginAllowThreads();
47992 result = (int)wxMenuItem::GetDefaultMarginWidth();
47993 wxPyEndAllowThreads(__tstate);
47994 if (PyErr_Occurred()) SWIG_fail;
47995 }
47996 resultobj = SWIG_From_int(static_cast< int >(result));
47997 return resultobj;
47998 fail:
47999 return NULL;
48000 }
48001
48002
48003 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48004 PyObject *resultobj = 0;
48005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48006 bool result;
48007 void *argp1 = 0 ;
48008 int res1 = 0 ;
48009 PyObject *swig_obj[1] ;
48010
48011 if (!args) SWIG_fail;
48012 swig_obj[0] = args;
48013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48014 if (!SWIG_IsOK(res1)) {
48015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48016 }
48017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48018 {
48019 PyThreadState* __tstate = wxPyBeginAllowThreads();
48020 result = (bool)(arg1)->IsOwnerDrawn();
48021 wxPyEndAllowThreads(__tstate);
48022 if (PyErr_Occurred()) SWIG_fail;
48023 }
48024 {
48025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48026 }
48027 return resultobj;
48028 fail:
48029 return NULL;
48030 }
48031
48032
48033 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48034 PyObject *resultobj = 0;
48035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48036 bool arg2 = (bool) true ;
48037 void *argp1 = 0 ;
48038 int res1 = 0 ;
48039 bool val2 ;
48040 int ecode2 = 0 ;
48041 PyObject * obj0 = 0 ;
48042 PyObject * obj1 = 0 ;
48043 char * kwnames[] = {
48044 (char *) "self",(char *) "ownerDrawn", NULL
48045 };
48046
48047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
48048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48049 if (!SWIG_IsOK(res1)) {
48050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48051 }
48052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48053 if (obj1) {
48054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48055 if (!SWIG_IsOK(ecode2)) {
48056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
48057 }
48058 arg2 = static_cast< bool >(val2);
48059 }
48060 {
48061 PyThreadState* __tstate = wxPyBeginAllowThreads();
48062 (arg1)->SetOwnerDrawn(arg2);
48063 wxPyEndAllowThreads(__tstate);
48064 if (PyErr_Occurred()) SWIG_fail;
48065 }
48066 resultobj = SWIG_Py_Void();
48067 return resultobj;
48068 fail:
48069 return NULL;
48070 }
48071
48072
48073 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48074 PyObject *resultobj = 0;
48075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48076 void *argp1 = 0 ;
48077 int res1 = 0 ;
48078 PyObject *swig_obj[1] ;
48079
48080 if (!args) SWIG_fail;
48081 swig_obj[0] = args;
48082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48083 if (!SWIG_IsOK(res1)) {
48084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48085 }
48086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48087 {
48088 PyThreadState* __tstate = wxPyBeginAllowThreads();
48089 (arg1)->ResetOwnerDrawn();
48090 wxPyEndAllowThreads(__tstate);
48091 if (PyErr_Occurred()) SWIG_fail;
48092 }
48093 resultobj = SWIG_Py_Void();
48094 return resultobj;
48095 fail:
48096 return NULL;
48097 }
48098
48099
48100 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48101 PyObject *obj;
48102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48103 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
48104 return SWIG_Py_Void();
48105 }
48106
48107 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48108 return SWIG_Python_InitShadowInstance(args);
48109 }
48110
48111 SWIGINTERN int ControlNameStr_set(PyObject *) {
48112 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
48113 return 1;
48114 }
48115
48116
48117 SWIGINTERN PyObject *ControlNameStr_get(void) {
48118 PyObject *pyobj = 0;
48119
48120 {
48121 #if wxUSE_UNICODE
48122 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48123 #else
48124 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48125 #endif
48126 }
48127 return pyobj;
48128 }
48129
48130
48131 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48132 PyObject *resultobj = 0;
48133 wxWindow *arg1 = (wxWindow *) 0 ;
48134 int arg2 = (int) -1 ;
48135 wxPoint const &arg3_defvalue = wxDefaultPosition ;
48136 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
48137 wxSize const &arg4_defvalue = wxDefaultSize ;
48138 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
48139 long arg5 = (long) 0 ;
48140 wxValidator const &arg6_defvalue = wxDefaultValidator ;
48141 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
48142 wxString const &arg7_defvalue = wxPyControlNameStr ;
48143 wxString *arg7 = (wxString *) &arg7_defvalue ;
48144 wxControl *result = 0 ;
48145 void *argp1 = 0 ;
48146 int res1 = 0 ;
48147 int val2 ;
48148 int ecode2 = 0 ;
48149 wxPoint temp3 ;
48150 wxSize temp4 ;
48151 long val5 ;
48152 int ecode5 = 0 ;
48153 void *argp6 = 0 ;
48154 int res6 = 0 ;
48155 bool temp7 = false ;
48156 PyObject * obj0 = 0 ;
48157 PyObject * obj1 = 0 ;
48158 PyObject * obj2 = 0 ;
48159 PyObject * obj3 = 0 ;
48160 PyObject * obj4 = 0 ;
48161 PyObject * obj5 = 0 ;
48162 PyObject * obj6 = 0 ;
48163 char * kwnames[] = {
48164 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48165 };
48166
48167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
48168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48169 if (!SWIG_IsOK(res1)) {
48170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
48171 }
48172 arg1 = reinterpret_cast< wxWindow * >(argp1);
48173 if (obj1) {
48174 ecode2 = SWIG_AsVal_int(obj1, &val2);
48175 if (!SWIG_IsOK(ecode2)) {
48176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
48177 }
48178 arg2 = static_cast< int >(val2);
48179 }
48180 if (obj2) {
48181 {
48182 arg3 = &temp3;
48183 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
48184 }
48185 }
48186 if (obj3) {
48187 {
48188 arg4 = &temp4;
48189 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
48190 }
48191 }
48192 if (obj4) {
48193 ecode5 = SWIG_AsVal_long(obj4, &val5);
48194 if (!SWIG_IsOK(ecode5)) {
48195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
48196 }
48197 arg5 = static_cast< long >(val5);
48198 }
48199 if (obj5) {
48200 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
48201 if (!SWIG_IsOK(res6)) {
48202 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48203 }
48204 if (!argp6) {
48205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48206 }
48207 arg6 = reinterpret_cast< wxValidator * >(argp6);
48208 }
48209 if (obj6) {
48210 {
48211 arg7 = wxString_in_helper(obj6);
48212 if (arg7 == NULL) SWIG_fail;
48213 temp7 = true;
48214 }
48215 }
48216 {
48217 if (!wxPyCheckForApp()) SWIG_fail;
48218 PyThreadState* __tstate = wxPyBeginAllowThreads();
48219 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
48220 wxPyEndAllowThreads(__tstate);
48221 if (PyErr_Occurred()) SWIG_fail;
48222 }
48223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
48224 {
48225 if (temp7)
48226 delete arg7;
48227 }
48228 return resultobj;
48229 fail:
48230 {
48231 if (temp7)
48232 delete arg7;
48233 }
48234 return NULL;
48235 }
48236
48237
48238 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48239 PyObject *resultobj = 0;
48240 wxControl *result = 0 ;
48241
48242 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
48243 {
48244 if (!wxPyCheckForApp()) SWIG_fail;
48245 PyThreadState* __tstate = wxPyBeginAllowThreads();
48246 result = (wxControl *)new wxControl();
48247 wxPyEndAllowThreads(__tstate);
48248 if (PyErr_Occurred()) SWIG_fail;
48249 }
48250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
48251 return resultobj;
48252 fail:
48253 return NULL;
48254 }
48255
48256
48257 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48258 PyObject *resultobj = 0;
48259 wxControl *arg1 = (wxControl *) 0 ;
48260 wxWindow *arg2 = (wxWindow *) 0 ;
48261 int arg3 = (int) -1 ;
48262 wxPoint const &arg4_defvalue = wxDefaultPosition ;
48263 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
48264 wxSize const &arg5_defvalue = wxDefaultSize ;
48265 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
48266 long arg6 = (long) 0 ;
48267 wxValidator const &arg7_defvalue = wxDefaultValidator ;
48268 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
48269 wxString const &arg8_defvalue = wxPyControlNameStr ;
48270 wxString *arg8 = (wxString *) &arg8_defvalue ;
48271 bool result;
48272 void *argp1 = 0 ;
48273 int res1 = 0 ;
48274 void *argp2 = 0 ;
48275 int res2 = 0 ;
48276 int val3 ;
48277 int ecode3 = 0 ;
48278 wxPoint temp4 ;
48279 wxSize temp5 ;
48280 long val6 ;
48281 int ecode6 = 0 ;
48282 void *argp7 = 0 ;
48283 int res7 = 0 ;
48284 bool temp8 = false ;
48285 PyObject * obj0 = 0 ;
48286 PyObject * obj1 = 0 ;
48287 PyObject * obj2 = 0 ;
48288 PyObject * obj3 = 0 ;
48289 PyObject * obj4 = 0 ;
48290 PyObject * obj5 = 0 ;
48291 PyObject * obj6 = 0 ;
48292 PyObject * obj7 = 0 ;
48293 char * kwnames[] = {
48294 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48295 };
48296
48297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
48298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48299 if (!SWIG_IsOK(res1)) {
48300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
48301 }
48302 arg1 = reinterpret_cast< wxControl * >(argp1);
48303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48304 if (!SWIG_IsOK(res2)) {
48305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
48306 }
48307 arg2 = reinterpret_cast< wxWindow * >(argp2);
48308 if (obj2) {
48309 ecode3 = SWIG_AsVal_int(obj2, &val3);
48310 if (!SWIG_IsOK(ecode3)) {
48311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
48312 }
48313 arg3 = static_cast< int >(val3);
48314 }
48315 if (obj3) {
48316 {
48317 arg4 = &temp4;
48318 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
48319 }
48320 }
48321 if (obj4) {
48322 {
48323 arg5 = &temp5;
48324 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
48325 }
48326 }
48327 if (obj5) {
48328 ecode6 = SWIG_AsVal_long(obj5, &val6);
48329 if (!SWIG_IsOK(ecode6)) {
48330 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
48331 }
48332 arg6 = static_cast< long >(val6);
48333 }
48334 if (obj6) {
48335 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
48336 if (!SWIG_IsOK(res7)) {
48337 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48338 }
48339 if (!argp7) {
48340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48341 }
48342 arg7 = reinterpret_cast< wxValidator * >(argp7);
48343 }
48344 if (obj7) {
48345 {
48346 arg8 = wxString_in_helper(obj7);
48347 if (arg8 == NULL) SWIG_fail;
48348 temp8 = true;
48349 }
48350 }
48351 {
48352 PyThreadState* __tstate = wxPyBeginAllowThreads();
48353 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
48354 wxPyEndAllowThreads(__tstate);
48355 if (PyErr_Occurred()) SWIG_fail;
48356 }
48357 {
48358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48359 }
48360 {
48361 if (temp8)
48362 delete arg8;
48363 }
48364 return resultobj;
48365 fail:
48366 {
48367 if (temp8)
48368 delete arg8;
48369 }
48370 return NULL;
48371 }
48372
48373
48374 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48375 PyObject *resultobj = 0;
48376 wxControl *arg1 = (wxControl *) 0 ;
48377 int result;
48378 void *argp1 = 0 ;
48379 int res1 = 0 ;
48380 PyObject *swig_obj[1] ;
48381
48382 if (!args) SWIG_fail;
48383 swig_obj[0] = args;
48384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48385 if (!SWIG_IsOK(res1)) {
48386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
48387 }
48388 arg1 = reinterpret_cast< wxControl * >(argp1);
48389 {
48390 PyThreadState* __tstate = wxPyBeginAllowThreads();
48391 result = (int)((wxControl const *)arg1)->GetAlignment();
48392 wxPyEndAllowThreads(__tstate);
48393 if (PyErr_Occurred()) SWIG_fail;
48394 }
48395 resultobj = SWIG_From_int(static_cast< int >(result));
48396 return resultobj;
48397 fail:
48398 return NULL;
48399 }
48400
48401
48402 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48403 PyObject *resultobj = 0;
48404 wxControl *arg1 = (wxControl *) 0 ;
48405 wxString result;
48406 void *argp1 = 0 ;
48407 int res1 = 0 ;
48408 PyObject *swig_obj[1] ;
48409
48410 if (!args) SWIG_fail;
48411 swig_obj[0] = args;
48412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48413 if (!SWIG_IsOK(res1)) {
48414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
48415 }
48416 arg1 = reinterpret_cast< wxControl * >(argp1);
48417 {
48418 PyThreadState* __tstate = wxPyBeginAllowThreads();
48419 result = ((wxControl const *)arg1)->GetLabelText();
48420 wxPyEndAllowThreads(__tstate);
48421 if (PyErr_Occurred()) SWIG_fail;
48422 }
48423 {
48424 #if wxUSE_UNICODE
48425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48426 #else
48427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48428 #endif
48429 }
48430 return resultobj;
48431 fail:
48432 return NULL;
48433 }
48434
48435
48436 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48437 PyObject *resultobj = 0;
48438 wxControl *arg1 = (wxControl *) 0 ;
48439 wxCommandEvent *arg2 = 0 ;
48440 void *argp1 = 0 ;
48441 int res1 = 0 ;
48442 void *argp2 = 0 ;
48443 int res2 = 0 ;
48444 PyObject * obj0 = 0 ;
48445 PyObject * obj1 = 0 ;
48446 char * kwnames[] = {
48447 (char *) "self",(char *) "event", NULL
48448 };
48449
48450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
48451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48452 if (!SWIG_IsOK(res1)) {
48453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
48454 }
48455 arg1 = reinterpret_cast< wxControl * >(argp1);
48456 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
48457 if (!SWIG_IsOK(res2)) {
48458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48459 }
48460 if (!argp2) {
48461 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48462 }
48463 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
48464 {
48465 PyThreadState* __tstate = wxPyBeginAllowThreads();
48466 (arg1)->Command(*arg2);
48467 wxPyEndAllowThreads(__tstate);
48468 if (PyErr_Occurred()) SWIG_fail;
48469 }
48470 resultobj = SWIG_Py_Void();
48471 return resultobj;
48472 fail:
48473 return NULL;
48474 }
48475
48476
48477 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48478 PyObject *resultobj = 0;
48479 wxString *arg1 = 0 ;
48480 wxString result;
48481 bool temp1 = false ;
48482 PyObject * obj0 = 0 ;
48483 char * kwnames[] = {
48484 (char *) "str", NULL
48485 };
48486
48487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
48488 {
48489 arg1 = wxString_in_helper(obj0);
48490 if (arg1 == NULL) SWIG_fail;
48491 temp1 = true;
48492 }
48493 {
48494 PyThreadState* __tstate = wxPyBeginAllowThreads();
48495 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
48496 wxPyEndAllowThreads(__tstate);
48497 if (PyErr_Occurred()) SWIG_fail;
48498 }
48499 {
48500 #if wxUSE_UNICODE
48501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48502 #else
48503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48504 #endif
48505 }
48506 {
48507 if (temp1)
48508 delete arg1;
48509 }
48510 return resultobj;
48511 fail:
48512 {
48513 if (temp1)
48514 delete arg1;
48515 }
48516 return NULL;
48517 }
48518
48519
48520 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48521 PyObject *resultobj = 0;
48522 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48523 SwigValueWrapper<wxVisualAttributes > result;
48524 int val1 ;
48525 int ecode1 = 0 ;
48526 PyObject * obj0 = 0 ;
48527 char * kwnames[] = {
48528 (char *) "variant", NULL
48529 };
48530
48531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48532 if (obj0) {
48533 ecode1 = SWIG_AsVal_int(obj0, &val1);
48534 if (!SWIG_IsOK(ecode1)) {
48535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48536 }
48537 arg1 = static_cast< wxWindowVariant >(val1);
48538 }
48539 {
48540 if (!wxPyCheckForApp()) SWIG_fail;
48541 PyThreadState* __tstate = wxPyBeginAllowThreads();
48542 result = wxControl::GetClassDefaultAttributes(arg1);
48543 wxPyEndAllowThreads(__tstate);
48544 if (PyErr_Occurred()) SWIG_fail;
48545 }
48546 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48547 return resultobj;
48548 fail:
48549 return NULL;
48550 }
48551
48552
48553 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48554 PyObject *obj;
48555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48556 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48557 return SWIG_Py_Void();
48558 }
48559
48560 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48561 return SWIG_Python_InitShadowInstance(args);
48562 }
48563
48564 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48565 PyObject *resultobj = 0;
48566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48567 wxString *arg2 = 0 ;
48568 PyObject *arg3 = (PyObject *) NULL ;
48569 int result;
48570 void *argp1 = 0 ;
48571 int res1 = 0 ;
48572 bool temp2 = false ;
48573 PyObject * obj0 = 0 ;
48574 PyObject * obj1 = 0 ;
48575 PyObject * obj2 = 0 ;
48576 char * kwnames[] = {
48577 (char *) "self",(char *) "item",(char *) "clientData", NULL
48578 };
48579
48580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48582 if (!SWIG_IsOK(res1)) {
48583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48584 }
48585 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48586 {
48587 arg2 = wxString_in_helper(obj1);
48588 if (arg2 == NULL) SWIG_fail;
48589 temp2 = true;
48590 }
48591 if (obj2) {
48592 arg3 = obj2;
48593 }
48594 {
48595 PyThreadState* __tstate = wxPyBeginAllowThreads();
48596 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48597 wxPyEndAllowThreads(__tstate);
48598 if (PyErr_Occurred()) SWIG_fail;
48599 }
48600 resultobj = SWIG_From_int(static_cast< int >(result));
48601 {
48602 if (temp2)
48603 delete arg2;
48604 }
48605 return resultobj;
48606 fail:
48607 {
48608 if (temp2)
48609 delete arg2;
48610 }
48611 return NULL;
48612 }
48613
48614
48615 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48616 PyObject *resultobj = 0;
48617 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48618 wxArrayString *arg2 = 0 ;
48619 void *argp1 = 0 ;
48620 int res1 = 0 ;
48621 bool temp2 = false ;
48622 PyObject * obj0 = 0 ;
48623 PyObject * obj1 = 0 ;
48624 char * kwnames[] = {
48625 (char *) "self",(char *) "strings", NULL
48626 };
48627
48628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48630 if (!SWIG_IsOK(res1)) {
48631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48632 }
48633 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48634 {
48635 if (! PySequence_Check(obj1)) {
48636 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48637 SWIG_fail;
48638 }
48639 arg2 = new wxArrayString;
48640 temp2 = true;
48641 int i, len=PySequence_Length(obj1);
48642 for (i=0; i<len; i++) {
48643 PyObject* item = PySequence_GetItem(obj1, i);
48644 wxString* s = wxString_in_helper(item);
48645 if (PyErr_Occurred()) SWIG_fail;
48646 arg2->Add(*s);
48647 delete s;
48648 Py_DECREF(item);
48649 }
48650 }
48651 {
48652 PyThreadState* __tstate = wxPyBeginAllowThreads();
48653 (arg1)->Append((wxArrayString const &)*arg2);
48654 wxPyEndAllowThreads(__tstate);
48655 if (PyErr_Occurred()) SWIG_fail;
48656 }
48657 resultobj = SWIG_Py_Void();
48658 {
48659 if (temp2) delete arg2;
48660 }
48661 return resultobj;
48662 fail:
48663 {
48664 if (temp2) delete arg2;
48665 }
48666 return NULL;
48667 }
48668
48669
48670 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48671 PyObject *resultobj = 0;
48672 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48673 wxString *arg2 = 0 ;
48674 int arg3 ;
48675 PyObject *arg4 = (PyObject *) NULL ;
48676 int result;
48677 void *argp1 = 0 ;
48678 int res1 = 0 ;
48679 bool temp2 = false ;
48680 int val3 ;
48681 int ecode3 = 0 ;
48682 PyObject * obj0 = 0 ;
48683 PyObject * obj1 = 0 ;
48684 PyObject * obj2 = 0 ;
48685 PyObject * obj3 = 0 ;
48686 char * kwnames[] = {
48687 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48688 };
48689
48690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48692 if (!SWIG_IsOK(res1)) {
48693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48694 }
48695 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48696 {
48697 arg2 = wxString_in_helper(obj1);
48698 if (arg2 == NULL) SWIG_fail;
48699 temp2 = true;
48700 }
48701 ecode3 = SWIG_AsVal_int(obj2, &val3);
48702 if (!SWIG_IsOK(ecode3)) {
48703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48704 }
48705 arg3 = static_cast< int >(val3);
48706 if (obj3) {
48707 arg4 = obj3;
48708 }
48709 {
48710 PyThreadState* __tstate = wxPyBeginAllowThreads();
48711 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48712 wxPyEndAllowThreads(__tstate);
48713 if (PyErr_Occurred()) SWIG_fail;
48714 }
48715 resultobj = SWIG_From_int(static_cast< int >(result));
48716 {
48717 if (temp2)
48718 delete arg2;
48719 }
48720 return resultobj;
48721 fail:
48722 {
48723 if (temp2)
48724 delete arg2;
48725 }
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48731 PyObject *resultobj = 0;
48732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48733 void *argp1 = 0 ;
48734 int res1 = 0 ;
48735 PyObject *swig_obj[1] ;
48736
48737 if (!args) SWIG_fail;
48738 swig_obj[0] = args;
48739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48740 if (!SWIG_IsOK(res1)) {
48741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48742 }
48743 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48744 {
48745 PyThreadState* __tstate = wxPyBeginAllowThreads();
48746 (arg1)->Clear();
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_Py_Void();
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48758 PyObject *resultobj = 0;
48759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48760 int arg2 ;
48761 void *argp1 = 0 ;
48762 int res1 = 0 ;
48763 int val2 ;
48764 int ecode2 = 0 ;
48765 PyObject * obj0 = 0 ;
48766 PyObject * obj1 = 0 ;
48767 char * kwnames[] = {
48768 (char *) "self",(char *) "n", NULL
48769 };
48770
48771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48773 if (!SWIG_IsOK(res1)) {
48774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48775 }
48776 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48777 ecode2 = SWIG_AsVal_int(obj1, &val2);
48778 if (!SWIG_IsOK(ecode2)) {
48779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48780 }
48781 arg2 = static_cast< int >(val2);
48782 {
48783 PyThreadState* __tstate = wxPyBeginAllowThreads();
48784 (arg1)->Delete(arg2);
48785 wxPyEndAllowThreads(__tstate);
48786 if (PyErr_Occurred()) SWIG_fail;
48787 }
48788 resultobj = SWIG_Py_Void();
48789 return resultobj;
48790 fail:
48791 return NULL;
48792 }
48793
48794
48795 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48796 PyObject *resultobj = 0;
48797 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48798 int arg2 ;
48799 PyObject *result = 0 ;
48800 void *argp1 = 0 ;
48801 int res1 = 0 ;
48802 int val2 ;
48803 int ecode2 = 0 ;
48804 PyObject * obj0 = 0 ;
48805 PyObject * obj1 = 0 ;
48806 char * kwnames[] = {
48807 (char *) "self",(char *) "n", NULL
48808 };
48809
48810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48812 if (!SWIG_IsOK(res1)) {
48813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48814 }
48815 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48816 ecode2 = SWIG_AsVal_int(obj1, &val2);
48817 if (!SWIG_IsOK(ecode2)) {
48818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48819 }
48820 arg2 = static_cast< int >(val2);
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = result;
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48835 PyObject *resultobj = 0;
48836 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48837 int arg2 ;
48838 PyObject *arg3 = (PyObject *) 0 ;
48839 void *argp1 = 0 ;
48840 int res1 = 0 ;
48841 int val2 ;
48842 int ecode2 = 0 ;
48843 PyObject * obj0 = 0 ;
48844 PyObject * obj1 = 0 ;
48845 PyObject * obj2 = 0 ;
48846 char * kwnames[] = {
48847 (char *) "self",(char *) "n",(char *) "clientData", NULL
48848 };
48849
48850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48852 if (!SWIG_IsOK(res1)) {
48853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48854 }
48855 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48856 ecode2 = SWIG_AsVal_int(obj1, &val2);
48857 if (!SWIG_IsOK(ecode2)) {
48858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48859 }
48860 arg2 = static_cast< int >(val2);
48861 arg3 = obj2;
48862 {
48863 PyThreadState* __tstate = wxPyBeginAllowThreads();
48864 wxItemContainer_SetClientData(arg1,arg2,arg3);
48865 wxPyEndAllowThreads(__tstate);
48866 if (PyErr_Occurred()) SWIG_fail;
48867 }
48868 resultobj = SWIG_Py_Void();
48869 return resultobj;
48870 fail:
48871 return NULL;
48872 }
48873
48874
48875 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48876 PyObject *resultobj = 0;
48877 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48878 int result;
48879 void *argp1 = 0 ;
48880 int res1 = 0 ;
48881 PyObject *swig_obj[1] ;
48882
48883 if (!args) SWIG_fail;
48884 swig_obj[0] = args;
48885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48886 if (!SWIG_IsOK(res1)) {
48887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48888 }
48889 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48890 {
48891 PyThreadState* __tstate = wxPyBeginAllowThreads();
48892 result = (int)((wxItemContainer const *)arg1)->GetCount();
48893 wxPyEndAllowThreads(__tstate);
48894 if (PyErr_Occurred()) SWIG_fail;
48895 }
48896 resultobj = SWIG_From_int(static_cast< int >(result));
48897 return resultobj;
48898 fail:
48899 return NULL;
48900 }
48901
48902
48903 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48904 PyObject *resultobj = 0;
48905 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48906 bool result;
48907 void *argp1 = 0 ;
48908 int res1 = 0 ;
48909 PyObject *swig_obj[1] ;
48910
48911 if (!args) SWIG_fail;
48912 swig_obj[0] = args;
48913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48914 if (!SWIG_IsOK(res1)) {
48915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48916 }
48917 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48918 {
48919 PyThreadState* __tstate = wxPyBeginAllowThreads();
48920 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48921 wxPyEndAllowThreads(__tstate);
48922 if (PyErr_Occurred()) SWIG_fail;
48923 }
48924 {
48925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48926 }
48927 return resultobj;
48928 fail:
48929 return NULL;
48930 }
48931
48932
48933 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48934 PyObject *resultobj = 0;
48935 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48936 int arg2 ;
48937 wxString result;
48938 void *argp1 = 0 ;
48939 int res1 = 0 ;
48940 int val2 ;
48941 int ecode2 = 0 ;
48942 PyObject * obj0 = 0 ;
48943 PyObject * obj1 = 0 ;
48944 char * kwnames[] = {
48945 (char *) "self",(char *) "n", NULL
48946 };
48947
48948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48950 if (!SWIG_IsOK(res1)) {
48951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48952 }
48953 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48954 ecode2 = SWIG_AsVal_int(obj1, &val2);
48955 if (!SWIG_IsOK(ecode2)) {
48956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48957 }
48958 arg2 = static_cast< int >(val2);
48959 {
48960 PyThreadState* __tstate = wxPyBeginAllowThreads();
48961 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48962 wxPyEndAllowThreads(__tstate);
48963 if (PyErr_Occurred()) SWIG_fail;
48964 }
48965 {
48966 #if wxUSE_UNICODE
48967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48968 #else
48969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48970 #endif
48971 }
48972 return resultobj;
48973 fail:
48974 return NULL;
48975 }
48976
48977
48978 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48979 PyObject *resultobj = 0;
48980 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48981 wxArrayString result;
48982 void *argp1 = 0 ;
48983 int res1 = 0 ;
48984 PyObject *swig_obj[1] ;
48985
48986 if (!args) SWIG_fail;
48987 swig_obj[0] = args;
48988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48989 if (!SWIG_IsOK(res1)) {
48990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48991 }
48992 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48993 {
48994 PyThreadState* __tstate = wxPyBeginAllowThreads();
48995 result = ((wxItemContainer const *)arg1)->GetStrings();
48996 wxPyEndAllowThreads(__tstate);
48997 if (PyErr_Occurred()) SWIG_fail;
48998 }
48999 {
49000 resultobj = wxArrayString2PyList_helper(result);
49001 }
49002 return resultobj;
49003 fail:
49004 return NULL;
49005 }
49006
49007
49008 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49009 PyObject *resultobj = 0;
49010 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49011 int arg2 ;
49012 wxString *arg3 = 0 ;
49013 void *argp1 = 0 ;
49014 int res1 = 0 ;
49015 int val2 ;
49016 int ecode2 = 0 ;
49017 bool temp3 = false ;
49018 PyObject * obj0 = 0 ;
49019 PyObject * obj1 = 0 ;
49020 PyObject * obj2 = 0 ;
49021 char * kwnames[] = {
49022 (char *) "self",(char *) "n",(char *) "s", NULL
49023 };
49024
49025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49027 if (!SWIG_IsOK(res1)) {
49028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49029 }
49030 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49031 ecode2 = SWIG_AsVal_int(obj1, &val2);
49032 if (!SWIG_IsOK(ecode2)) {
49033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
49034 }
49035 arg2 = static_cast< int >(val2);
49036 {
49037 arg3 = wxString_in_helper(obj2);
49038 if (arg3 == NULL) SWIG_fail;
49039 temp3 = true;
49040 }
49041 {
49042 PyThreadState* __tstate = wxPyBeginAllowThreads();
49043 (arg1)->SetString(arg2,(wxString const &)*arg3);
49044 wxPyEndAllowThreads(__tstate);
49045 if (PyErr_Occurred()) SWIG_fail;
49046 }
49047 resultobj = SWIG_Py_Void();
49048 {
49049 if (temp3)
49050 delete arg3;
49051 }
49052 return resultobj;
49053 fail:
49054 {
49055 if (temp3)
49056 delete arg3;
49057 }
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49063 PyObject *resultobj = 0;
49064 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49065 wxString *arg2 = 0 ;
49066 int result;
49067 void *argp1 = 0 ;
49068 int res1 = 0 ;
49069 bool temp2 = false ;
49070 PyObject * obj0 = 0 ;
49071 PyObject * obj1 = 0 ;
49072 char * kwnames[] = {
49073 (char *) "self",(char *) "s", NULL
49074 };
49075
49076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
49077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49078 if (!SWIG_IsOK(res1)) {
49079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49080 }
49081 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49082 {
49083 arg2 = wxString_in_helper(obj1);
49084 if (arg2 == NULL) SWIG_fail;
49085 temp2 = true;
49086 }
49087 {
49088 PyThreadState* __tstate = wxPyBeginAllowThreads();
49089 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
49090 wxPyEndAllowThreads(__tstate);
49091 if (PyErr_Occurred()) SWIG_fail;
49092 }
49093 resultobj = SWIG_From_int(static_cast< int >(result));
49094 {
49095 if (temp2)
49096 delete arg2;
49097 }
49098 return resultobj;
49099 fail:
49100 {
49101 if (temp2)
49102 delete arg2;
49103 }
49104 return NULL;
49105 }
49106
49107
49108 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49109 PyObject *resultobj = 0;
49110 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49111 int arg2 ;
49112 void *argp1 = 0 ;
49113 int res1 = 0 ;
49114 int val2 ;
49115 int ecode2 = 0 ;
49116 PyObject * obj0 = 0 ;
49117 PyObject * obj1 = 0 ;
49118 char * kwnames[] = {
49119 (char *) "self",(char *) "n", NULL
49120 };
49121
49122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49124 if (!SWIG_IsOK(res1)) {
49125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49126 }
49127 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49128 ecode2 = SWIG_AsVal_int(obj1, &val2);
49129 if (!SWIG_IsOK(ecode2)) {
49130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
49131 }
49132 arg2 = static_cast< int >(val2);
49133 {
49134 PyThreadState* __tstate = wxPyBeginAllowThreads();
49135 (arg1)->SetSelection(arg2);
49136 wxPyEndAllowThreads(__tstate);
49137 if (PyErr_Occurred()) SWIG_fail;
49138 }
49139 resultobj = SWIG_Py_Void();
49140 return resultobj;
49141 fail:
49142 return NULL;
49143 }
49144
49145
49146 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49147 PyObject *resultobj = 0;
49148 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49149 int result;
49150 void *argp1 = 0 ;
49151 int res1 = 0 ;
49152 PyObject *swig_obj[1] ;
49153
49154 if (!args) SWIG_fail;
49155 swig_obj[0] = args;
49156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49157 if (!SWIG_IsOK(res1)) {
49158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49159 }
49160 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49161 {
49162 PyThreadState* __tstate = wxPyBeginAllowThreads();
49163 result = (int)((wxItemContainer const *)arg1)->GetSelection();
49164 wxPyEndAllowThreads(__tstate);
49165 if (PyErr_Occurred()) SWIG_fail;
49166 }
49167 resultobj = SWIG_From_int(static_cast< int >(result));
49168 return resultobj;
49169 fail:
49170 return NULL;
49171 }
49172
49173
49174 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49175 PyObject *resultobj = 0;
49176 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49177 wxString *arg2 = 0 ;
49178 bool result;
49179 void *argp1 = 0 ;
49180 int res1 = 0 ;
49181 bool temp2 = false ;
49182 PyObject * obj0 = 0 ;
49183 PyObject * obj1 = 0 ;
49184 char * kwnames[] = {
49185 (char *) "self",(char *) "s", NULL
49186 };
49187
49188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49190 if (!SWIG_IsOK(res1)) {
49191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49192 }
49193 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49194 {
49195 arg2 = wxString_in_helper(obj1);
49196 if (arg2 == NULL) SWIG_fail;
49197 temp2 = true;
49198 }
49199 {
49200 PyThreadState* __tstate = wxPyBeginAllowThreads();
49201 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
49202 wxPyEndAllowThreads(__tstate);
49203 if (PyErr_Occurred()) SWIG_fail;
49204 }
49205 {
49206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49207 }
49208 {
49209 if (temp2)
49210 delete arg2;
49211 }
49212 return resultobj;
49213 fail:
49214 {
49215 if (temp2)
49216 delete arg2;
49217 }
49218 return NULL;
49219 }
49220
49221
49222 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49223 PyObject *resultobj = 0;
49224 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49225 wxString result;
49226 void *argp1 = 0 ;
49227 int res1 = 0 ;
49228 PyObject *swig_obj[1] ;
49229
49230 if (!args) SWIG_fail;
49231 swig_obj[0] = args;
49232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49233 if (!SWIG_IsOK(res1)) {
49234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49235 }
49236 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49237 {
49238 PyThreadState* __tstate = wxPyBeginAllowThreads();
49239 result = ((wxItemContainer const *)arg1)->GetStringSelection();
49240 wxPyEndAllowThreads(__tstate);
49241 if (PyErr_Occurred()) SWIG_fail;
49242 }
49243 {
49244 #if wxUSE_UNICODE
49245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49246 #else
49247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49248 #endif
49249 }
49250 return resultobj;
49251 fail:
49252 return NULL;
49253 }
49254
49255
49256 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49257 PyObject *resultobj = 0;
49258 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49259 int arg2 ;
49260 void *argp1 = 0 ;
49261 int res1 = 0 ;
49262 int val2 ;
49263 int ecode2 = 0 ;
49264 PyObject * obj0 = 0 ;
49265 PyObject * obj1 = 0 ;
49266 char * kwnames[] = {
49267 (char *) "self",(char *) "n", NULL
49268 };
49269
49270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
49271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49272 if (!SWIG_IsOK(res1)) {
49273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49274 }
49275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49276 ecode2 = SWIG_AsVal_int(obj1, &val2);
49277 if (!SWIG_IsOK(ecode2)) {
49278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
49279 }
49280 arg2 = static_cast< int >(val2);
49281 {
49282 PyThreadState* __tstate = wxPyBeginAllowThreads();
49283 (arg1)->Select(arg2);
49284 wxPyEndAllowThreads(__tstate);
49285 if (PyErr_Occurred()) SWIG_fail;
49286 }
49287 resultobj = SWIG_Py_Void();
49288 return resultobj;
49289 fail:
49290 return NULL;
49291 }
49292
49293
49294 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49295 PyObject *obj;
49296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49297 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
49298 return SWIG_Py_Void();
49299 }
49300
49301 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49302 PyObject *obj;
49303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49304 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
49305 return SWIG_Py_Void();
49306 }
49307
49308 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49309 PyObject *resultobj = 0;
49310 int arg1 = (int) 0 ;
49311 wxSizerFlags *result = 0 ;
49312 int val1 ;
49313 int ecode1 = 0 ;
49314 PyObject * obj0 = 0 ;
49315 char * kwnames[] = {
49316 (char *) "proportion", NULL
49317 };
49318
49319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
49320 if (obj0) {
49321 ecode1 = SWIG_AsVal_int(obj0, &val1);
49322 if (!SWIG_IsOK(ecode1)) {
49323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
49324 }
49325 arg1 = static_cast< int >(val1);
49326 }
49327 {
49328 PyThreadState* __tstate = wxPyBeginAllowThreads();
49329 result = (wxSizerFlags *)new wxSizerFlags(arg1);
49330 wxPyEndAllowThreads(__tstate);
49331 if (PyErr_Occurred()) SWIG_fail;
49332 }
49333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
49334 return resultobj;
49335 fail:
49336 return NULL;
49337 }
49338
49339
49340 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49341 PyObject *resultobj = 0;
49342 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49343 void *argp1 = 0 ;
49344 int res1 = 0 ;
49345 PyObject *swig_obj[1] ;
49346
49347 if (!args) SWIG_fail;
49348 swig_obj[0] = args;
49349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
49350 if (!SWIG_IsOK(res1)) {
49351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49352 }
49353 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49354 {
49355 PyThreadState* __tstate = wxPyBeginAllowThreads();
49356 delete arg1;
49357
49358 wxPyEndAllowThreads(__tstate);
49359 if (PyErr_Occurred()) SWIG_fail;
49360 }
49361 resultobj = SWIG_Py_Void();
49362 return resultobj;
49363 fail:
49364 return NULL;
49365 }
49366
49367
49368 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49369 PyObject *resultobj = 0;
49370 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49371 int arg2 ;
49372 wxSizerFlags *result = 0 ;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 int val2 ;
49376 int ecode2 = 0 ;
49377 PyObject * obj0 = 0 ;
49378 PyObject * obj1 = 0 ;
49379 char * kwnames[] = {
49380 (char *) "self",(char *) "proportion", NULL
49381 };
49382
49383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
49384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49385 if (!SWIG_IsOK(res1)) {
49386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49387 }
49388 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49389 ecode2 = SWIG_AsVal_int(obj1, &val2);
49390 if (!SWIG_IsOK(ecode2)) {
49391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
49392 }
49393 arg2 = static_cast< int >(val2);
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 {
49397 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
49398 result = (wxSizerFlags *) &_result_ref;
49399 }
49400 wxPyEndAllowThreads(__tstate);
49401 if (PyErr_Occurred()) SWIG_fail;
49402 }
49403 {
49404 resultobj = obj0; Py_INCREF(resultobj);
49405 }
49406 return resultobj;
49407 fail:
49408 return NULL;
49409 }
49410
49411
49412 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49413 PyObject *resultobj = 0;
49414 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49415 int arg2 ;
49416 wxSizerFlags *result = 0 ;
49417 void *argp1 = 0 ;
49418 int res1 = 0 ;
49419 int val2 ;
49420 int ecode2 = 0 ;
49421 PyObject * obj0 = 0 ;
49422 PyObject * obj1 = 0 ;
49423 char * kwnames[] = {
49424 (char *) "self",(char *) "alignment", NULL
49425 };
49426
49427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
49428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49429 if (!SWIG_IsOK(res1)) {
49430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49431 }
49432 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49433 ecode2 = SWIG_AsVal_int(obj1, &val2);
49434 if (!SWIG_IsOK(ecode2)) {
49435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
49436 }
49437 arg2 = static_cast< int >(val2);
49438 {
49439 PyThreadState* __tstate = wxPyBeginAllowThreads();
49440 {
49441 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
49442 result = (wxSizerFlags *) &_result_ref;
49443 }
49444 wxPyEndAllowThreads(__tstate);
49445 if (PyErr_Occurred()) SWIG_fail;
49446 }
49447 {
49448 resultobj = obj0; Py_INCREF(resultobj);
49449 }
49450 return resultobj;
49451 fail:
49452 return NULL;
49453 }
49454
49455
49456 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49457 PyObject *resultobj = 0;
49458 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49459 wxSizerFlags *result = 0 ;
49460 void *argp1 = 0 ;
49461 int res1 = 0 ;
49462 PyObject *swig_obj[1] ;
49463
49464 if (!args) SWIG_fail;
49465 swig_obj[0] = args;
49466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49467 if (!SWIG_IsOK(res1)) {
49468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49469 }
49470 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49471 {
49472 PyThreadState* __tstate = wxPyBeginAllowThreads();
49473 {
49474 wxSizerFlags &_result_ref = (arg1)->Expand();
49475 result = (wxSizerFlags *) &_result_ref;
49476 }
49477 wxPyEndAllowThreads(__tstate);
49478 if (PyErr_Occurred()) SWIG_fail;
49479 }
49480 {
49481 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49482 }
49483 return resultobj;
49484 fail:
49485 return NULL;
49486 }
49487
49488
49489 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49490 PyObject *resultobj = 0;
49491 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49492 wxSizerFlags *result = 0 ;
49493 void *argp1 = 0 ;
49494 int res1 = 0 ;
49495 PyObject *swig_obj[1] ;
49496
49497 if (!args) SWIG_fail;
49498 swig_obj[0] = args;
49499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49500 if (!SWIG_IsOK(res1)) {
49501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49502 }
49503 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49504 {
49505 PyThreadState* __tstate = wxPyBeginAllowThreads();
49506 {
49507 wxSizerFlags &_result_ref = (arg1)->Centre();
49508 result = (wxSizerFlags *) &_result_ref;
49509 }
49510 wxPyEndAllowThreads(__tstate);
49511 if (PyErr_Occurred()) SWIG_fail;
49512 }
49513 {
49514 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49515 }
49516 return resultobj;
49517 fail:
49518 return NULL;
49519 }
49520
49521
49522 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49523 PyObject *resultobj = 0;
49524 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49525 wxSizerFlags *result = 0 ;
49526 void *argp1 = 0 ;
49527 int res1 = 0 ;
49528 PyObject *swig_obj[1] ;
49529
49530 if (!args) SWIG_fail;
49531 swig_obj[0] = args;
49532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49533 if (!SWIG_IsOK(res1)) {
49534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49535 }
49536 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49537 {
49538 PyThreadState* __tstate = wxPyBeginAllowThreads();
49539 {
49540 wxSizerFlags &_result_ref = (arg1)->Center();
49541 result = (wxSizerFlags *) &_result_ref;
49542 }
49543 wxPyEndAllowThreads(__tstate);
49544 if (PyErr_Occurred()) SWIG_fail;
49545 }
49546 {
49547 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49548 }
49549 return resultobj;
49550 fail:
49551 return NULL;
49552 }
49553
49554
49555 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49556 PyObject *resultobj = 0;
49557 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49558 wxSizerFlags *result = 0 ;
49559 void *argp1 = 0 ;
49560 int res1 = 0 ;
49561 PyObject *swig_obj[1] ;
49562
49563 if (!args) SWIG_fail;
49564 swig_obj[0] = args;
49565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49566 if (!SWIG_IsOK(res1)) {
49567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49568 }
49569 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49570 {
49571 PyThreadState* __tstate = wxPyBeginAllowThreads();
49572 {
49573 wxSizerFlags &_result_ref = (arg1)->Left();
49574 result = (wxSizerFlags *) &_result_ref;
49575 }
49576 wxPyEndAllowThreads(__tstate);
49577 if (PyErr_Occurred()) SWIG_fail;
49578 }
49579 {
49580 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49581 }
49582 return resultobj;
49583 fail:
49584 return NULL;
49585 }
49586
49587
49588 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49589 PyObject *resultobj = 0;
49590 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49591 wxSizerFlags *result = 0 ;
49592 void *argp1 = 0 ;
49593 int res1 = 0 ;
49594 PyObject *swig_obj[1] ;
49595
49596 if (!args) SWIG_fail;
49597 swig_obj[0] = args;
49598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49599 if (!SWIG_IsOK(res1)) {
49600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49601 }
49602 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49603 {
49604 PyThreadState* __tstate = wxPyBeginAllowThreads();
49605 {
49606 wxSizerFlags &_result_ref = (arg1)->Right();
49607 result = (wxSizerFlags *) &_result_ref;
49608 }
49609 wxPyEndAllowThreads(__tstate);
49610 if (PyErr_Occurred()) SWIG_fail;
49611 }
49612 {
49613 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49614 }
49615 return resultobj;
49616 fail:
49617 return NULL;
49618 }
49619
49620
49621 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49622 PyObject *resultobj = 0;
49623 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49624 wxSizerFlags *result = 0 ;
49625 void *argp1 = 0 ;
49626 int res1 = 0 ;
49627 PyObject *swig_obj[1] ;
49628
49629 if (!args) SWIG_fail;
49630 swig_obj[0] = args;
49631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49632 if (!SWIG_IsOK(res1)) {
49633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49634 }
49635 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49636 {
49637 PyThreadState* __tstate = wxPyBeginAllowThreads();
49638 {
49639 wxSizerFlags &_result_ref = (arg1)->Top();
49640 result = (wxSizerFlags *) &_result_ref;
49641 }
49642 wxPyEndAllowThreads(__tstate);
49643 if (PyErr_Occurred()) SWIG_fail;
49644 }
49645 {
49646 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49647 }
49648 return resultobj;
49649 fail:
49650 return NULL;
49651 }
49652
49653
49654 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49655 PyObject *resultobj = 0;
49656 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49657 wxSizerFlags *result = 0 ;
49658 void *argp1 = 0 ;
49659 int res1 = 0 ;
49660 PyObject *swig_obj[1] ;
49661
49662 if (!args) SWIG_fail;
49663 swig_obj[0] = args;
49664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49665 if (!SWIG_IsOK(res1)) {
49666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49667 }
49668 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49669 {
49670 PyThreadState* __tstate = wxPyBeginAllowThreads();
49671 {
49672 wxSizerFlags &_result_ref = (arg1)->Bottom();
49673 result = (wxSizerFlags *) &_result_ref;
49674 }
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 {
49679 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49680 }
49681 return resultobj;
49682 fail:
49683 return NULL;
49684 }
49685
49686
49687 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49688 PyObject *resultobj = 0;
49689 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49690 wxSizerFlags *result = 0 ;
49691 void *argp1 = 0 ;
49692 int res1 = 0 ;
49693 PyObject *swig_obj[1] ;
49694
49695 if (!args) SWIG_fail;
49696 swig_obj[0] = args;
49697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49698 if (!SWIG_IsOK(res1)) {
49699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49700 }
49701 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49702 {
49703 PyThreadState* __tstate = wxPyBeginAllowThreads();
49704 {
49705 wxSizerFlags &_result_ref = (arg1)->Shaped();
49706 result = (wxSizerFlags *) &_result_ref;
49707 }
49708 wxPyEndAllowThreads(__tstate);
49709 if (PyErr_Occurred()) SWIG_fail;
49710 }
49711 {
49712 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49713 }
49714 return resultobj;
49715 fail:
49716 return NULL;
49717 }
49718
49719
49720 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49721 PyObject *resultobj = 0;
49722 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49723 wxSizerFlags *result = 0 ;
49724 void *argp1 = 0 ;
49725 int res1 = 0 ;
49726 PyObject *swig_obj[1] ;
49727
49728 if (!args) SWIG_fail;
49729 swig_obj[0] = args;
49730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49731 if (!SWIG_IsOK(res1)) {
49732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49733 }
49734 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49735 {
49736 PyThreadState* __tstate = wxPyBeginAllowThreads();
49737 {
49738 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49739 result = (wxSizerFlags *) &_result_ref;
49740 }
49741 wxPyEndAllowThreads(__tstate);
49742 if (PyErr_Occurred()) SWIG_fail;
49743 }
49744 {
49745 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49746 }
49747 return resultobj;
49748 fail:
49749 return NULL;
49750 }
49751
49752
49753 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49754 PyObject *resultobj = 0;
49755 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49756 int arg2 = (int) wxALL ;
49757 int arg3 = (int) -1 ;
49758 wxSizerFlags *result = 0 ;
49759 void *argp1 = 0 ;
49760 int res1 = 0 ;
49761 int val2 ;
49762 int ecode2 = 0 ;
49763 int val3 ;
49764 int ecode3 = 0 ;
49765 PyObject * obj0 = 0 ;
49766 PyObject * obj1 = 0 ;
49767 PyObject * obj2 = 0 ;
49768 char * kwnames[] = {
49769 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49770 };
49771
49772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49774 if (!SWIG_IsOK(res1)) {
49775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49776 }
49777 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49778 if (obj1) {
49779 ecode2 = SWIG_AsVal_int(obj1, &val2);
49780 if (!SWIG_IsOK(ecode2)) {
49781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49782 }
49783 arg2 = static_cast< int >(val2);
49784 }
49785 if (obj2) {
49786 ecode3 = SWIG_AsVal_int(obj2, &val3);
49787 if (!SWIG_IsOK(ecode3)) {
49788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49789 }
49790 arg3 = static_cast< int >(val3);
49791 }
49792 {
49793 PyThreadState* __tstate = wxPyBeginAllowThreads();
49794 {
49795 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49796 result = (wxSizerFlags *) &_result_ref;
49797 }
49798 wxPyEndAllowThreads(__tstate);
49799 if (PyErr_Occurred()) SWIG_fail;
49800 }
49801 {
49802 resultobj = obj0; Py_INCREF(resultobj);
49803 }
49804 return resultobj;
49805 fail:
49806 return NULL;
49807 }
49808
49809
49810 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49811 PyObject *resultobj = 0;
49812 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49813 int arg2 = (int) wxALL ;
49814 wxSizerFlags *result = 0 ;
49815 void *argp1 = 0 ;
49816 int res1 = 0 ;
49817 int val2 ;
49818 int ecode2 = 0 ;
49819 PyObject * obj0 = 0 ;
49820 PyObject * obj1 = 0 ;
49821 char * kwnames[] = {
49822 (char *) "self",(char *) "direction", NULL
49823 };
49824
49825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49827 if (!SWIG_IsOK(res1)) {
49828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49829 }
49830 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49831 if (obj1) {
49832 ecode2 = SWIG_AsVal_int(obj1, &val2);
49833 if (!SWIG_IsOK(ecode2)) {
49834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49835 }
49836 arg2 = static_cast< int >(val2);
49837 }
49838 {
49839 PyThreadState* __tstate = wxPyBeginAllowThreads();
49840 {
49841 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49842 result = (wxSizerFlags *) &_result_ref;
49843 }
49844 wxPyEndAllowThreads(__tstate);
49845 if (PyErr_Occurred()) SWIG_fail;
49846 }
49847 {
49848 resultobj = obj0; Py_INCREF(resultobj);
49849 }
49850 return resultobj;
49851 fail:
49852 return NULL;
49853 }
49854
49855
49856 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49857 PyObject *resultobj = 0;
49858 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49859 int arg2 = (int) wxALL ;
49860 wxSizerFlags *result = 0 ;
49861 void *argp1 = 0 ;
49862 int res1 = 0 ;
49863 int val2 ;
49864 int ecode2 = 0 ;
49865 PyObject * obj0 = 0 ;
49866 PyObject * obj1 = 0 ;
49867 char * kwnames[] = {
49868 (char *) "self",(char *) "direction", NULL
49869 };
49870
49871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49873 if (!SWIG_IsOK(res1)) {
49874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49875 }
49876 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49877 if (obj1) {
49878 ecode2 = SWIG_AsVal_int(obj1, &val2);
49879 if (!SWIG_IsOK(ecode2)) {
49880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49881 }
49882 arg2 = static_cast< int >(val2);
49883 }
49884 {
49885 PyThreadState* __tstate = wxPyBeginAllowThreads();
49886 {
49887 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49888 result = (wxSizerFlags *) &_result_ref;
49889 }
49890 wxPyEndAllowThreads(__tstate);
49891 if (PyErr_Occurred()) SWIG_fail;
49892 }
49893 {
49894 resultobj = obj0; Py_INCREF(resultobj);
49895 }
49896 return resultobj;
49897 fail:
49898 return NULL;
49899 }
49900
49901
49902 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49903 PyObject *resultobj = 0;
49904 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49905 wxSizerFlags *result = 0 ;
49906 void *argp1 = 0 ;
49907 int res1 = 0 ;
49908 PyObject *swig_obj[1] ;
49909
49910 if (!args) SWIG_fail;
49911 swig_obj[0] = args;
49912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49913 if (!SWIG_IsOK(res1)) {
49914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49915 }
49916 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49917 {
49918 PyThreadState* __tstate = wxPyBeginAllowThreads();
49919 {
49920 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49921 result = (wxSizerFlags *) &_result_ref;
49922 }
49923 wxPyEndAllowThreads(__tstate);
49924 if (PyErr_Occurred()) SWIG_fail;
49925 }
49926 {
49927 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49928 }
49929 return resultobj;
49930 fail:
49931 return NULL;
49932 }
49933
49934
49935 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49936 PyObject *resultobj = 0;
49937 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49938 wxSizerFlags *result = 0 ;
49939 void *argp1 = 0 ;
49940 int res1 = 0 ;
49941 PyObject *swig_obj[1] ;
49942
49943 if (!args) SWIG_fail;
49944 swig_obj[0] = args;
49945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49946 if (!SWIG_IsOK(res1)) {
49947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49948 }
49949 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49950 {
49951 PyThreadState* __tstate = wxPyBeginAllowThreads();
49952 {
49953 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49954 result = (wxSizerFlags *) &_result_ref;
49955 }
49956 wxPyEndAllowThreads(__tstate);
49957 if (PyErr_Occurred()) SWIG_fail;
49958 }
49959 {
49960 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49961 }
49962 return resultobj;
49963 fail:
49964 return NULL;
49965 }
49966
49967
49968 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49969 PyObject *resultobj = 0;
49970 int result;
49971
49972 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49973 {
49974 PyThreadState* __tstate = wxPyBeginAllowThreads();
49975 result = (int)wxSizerFlags::GetDefaultBorder();
49976 wxPyEndAllowThreads(__tstate);
49977 if (PyErr_Occurred()) SWIG_fail;
49978 }
49979 resultobj = SWIG_From_int(static_cast< int >(result));
49980 return resultobj;
49981 fail:
49982 return NULL;
49983 }
49984
49985
49986 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49987 PyObject *resultobj = 0;
49988 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49989 int result;
49990 void *argp1 = 0 ;
49991 int res1 = 0 ;
49992 PyObject *swig_obj[1] ;
49993
49994 if (!args) SWIG_fail;
49995 swig_obj[0] = args;
49996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49997 if (!SWIG_IsOK(res1)) {
49998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49999 }
50000 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50001 {
50002 PyThreadState* __tstate = wxPyBeginAllowThreads();
50003 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
50004 wxPyEndAllowThreads(__tstate);
50005 if (PyErr_Occurred()) SWIG_fail;
50006 }
50007 resultobj = SWIG_From_int(static_cast< int >(result));
50008 return resultobj;
50009 fail:
50010 return NULL;
50011 }
50012
50013
50014 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50015 PyObject *resultobj = 0;
50016 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50017 int result;
50018 void *argp1 = 0 ;
50019 int res1 = 0 ;
50020 PyObject *swig_obj[1] ;
50021
50022 if (!args) SWIG_fail;
50023 swig_obj[0] = args;
50024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50025 if (!SWIG_IsOK(res1)) {
50026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50027 }
50028 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50029 {
50030 PyThreadState* __tstate = wxPyBeginAllowThreads();
50031 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
50032 wxPyEndAllowThreads(__tstate);
50033 if (PyErr_Occurred()) SWIG_fail;
50034 }
50035 resultobj = SWIG_From_int(static_cast< int >(result));
50036 return resultobj;
50037 fail:
50038 return NULL;
50039 }
50040
50041
50042 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50043 PyObject *resultobj = 0;
50044 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50045 int result;
50046 void *argp1 = 0 ;
50047 int res1 = 0 ;
50048 PyObject *swig_obj[1] ;
50049
50050 if (!args) SWIG_fail;
50051 swig_obj[0] = args;
50052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50053 if (!SWIG_IsOK(res1)) {
50054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50055 }
50056 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 resultobj = SWIG_From_int(static_cast< int >(result));
50064 return resultobj;
50065 fail:
50066 return NULL;
50067 }
50068
50069
50070 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50071 PyObject *obj;
50072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50073 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
50074 return SWIG_Py_Void();
50075 }
50076
50077 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50078 return SWIG_Python_InitShadowInstance(args);
50079 }
50080
50081 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50082 PyObject *resultobj = 0;
50083 wxSizerItem *result = 0 ;
50084
50085 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
50086 {
50087 PyThreadState* __tstate = wxPyBeginAllowThreads();
50088 result = (wxSizerItem *)new wxSizerItem();
50089 wxPyEndAllowThreads(__tstate);
50090 if (PyErr_Occurred()) SWIG_fail;
50091 }
50092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
50093 return resultobj;
50094 fail:
50095 return NULL;
50096 }
50097
50098
50099 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50100 PyObject *resultobj = 0;
50101 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50102 void *argp1 = 0 ;
50103 int res1 = 0 ;
50104 PyObject *swig_obj[1] ;
50105
50106 if (!args) SWIG_fail;
50107 swig_obj[0] = args;
50108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50109 if (!SWIG_IsOK(res1)) {
50110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50111 }
50112 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50113 {
50114 PyThreadState* __tstate = wxPyBeginAllowThreads();
50115 delete arg1;
50116
50117 wxPyEndAllowThreads(__tstate);
50118 if (PyErr_Occurred()) SWIG_fail;
50119 }
50120 resultobj = SWIG_Py_Void();
50121 return resultobj;
50122 fail:
50123 return NULL;
50124 }
50125
50126
50127 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50128 PyObject *resultobj = 0;
50129 wxWindow *arg1 = (wxWindow *) 0 ;
50130 int arg2 ;
50131 int arg3 ;
50132 int arg4 ;
50133 PyObject *arg5 = (PyObject *) NULL ;
50134 wxSizerItem *result = 0 ;
50135 void *argp1 = 0 ;
50136 int res1 = 0 ;
50137 int val2 ;
50138 int ecode2 = 0 ;
50139 int val3 ;
50140 int ecode3 = 0 ;
50141 int val4 ;
50142 int ecode4 = 0 ;
50143 PyObject * obj0 = 0 ;
50144 PyObject * obj1 = 0 ;
50145 PyObject * obj2 = 0 ;
50146 PyObject * obj3 = 0 ;
50147 PyObject * obj4 = 0 ;
50148 char * kwnames[] = {
50149 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50150 };
50151
50152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50154 if (!SWIG_IsOK(res1)) {
50155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50156 }
50157 arg1 = reinterpret_cast< wxWindow * >(argp1);
50158 ecode2 = SWIG_AsVal_int(obj1, &val2);
50159 if (!SWIG_IsOK(ecode2)) {
50160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
50161 }
50162 arg2 = static_cast< int >(val2);
50163 ecode3 = SWIG_AsVal_int(obj2, &val3);
50164 if (!SWIG_IsOK(ecode3)) {
50165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
50166 }
50167 arg3 = static_cast< int >(val3);
50168 ecode4 = SWIG_AsVal_int(obj3, &val4);
50169 if (!SWIG_IsOK(ecode4)) {
50170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50171 }
50172 arg4 = static_cast< int >(val4);
50173 if (obj4) {
50174 arg5 = obj4;
50175 }
50176 {
50177 PyThreadState* __tstate = wxPyBeginAllowThreads();
50178 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50179 wxPyEndAllowThreads(__tstate);
50180 if (PyErr_Occurred()) SWIG_fail;
50181 }
50182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50183 return resultobj;
50184 fail:
50185 return NULL;
50186 }
50187
50188
50189 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50190 PyObject *resultobj = 0;
50191 int arg1 ;
50192 int arg2 ;
50193 int arg3 ;
50194 int arg4 ;
50195 int arg5 ;
50196 PyObject *arg6 = (PyObject *) NULL ;
50197 wxSizerItem *result = 0 ;
50198 int val1 ;
50199 int ecode1 = 0 ;
50200 int val2 ;
50201 int ecode2 = 0 ;
50202 int val3 ;
50203 int ecode3 = 0 ;
50204 int val4 ;
50205 int ecode4 = 0 ;
50206 int val5 ;
50207 int ecode5 = 0 ;
50208 PyObject * obj0 = 0 ;
50209 PyObject * obj1 = 0 ;
50210 PyObject * obj2 = 0 ;
50211 PyObject * obj3 = 0 ;
50212 PyObject * obj4 = 0 ;
50213 PyObject * obj5 = 0 ;
50214 char * kwnames[] = {
50215 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50216 };
50217
50218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50219 ecode1 = SWIG_AsVal_int(obj0, &val1);
50220 if (!SWIG_IsOK(ecode1)) {
50221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50222 }
50223 arg1 = static_cast< int >(val1);
50224 ecode2 = SWIG_AsVal_int(obj1, &val2);
50225 if (!SWIG_IsOK(ecode2)) {
50226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50227 }
50228 arg2 = static_cast< int >(val2);
50229 ecode3 = SWIG_AsVal_int(obj2, &val3);
50230 if (!SWIG_IsOK(ecode3)) {
50231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
50232 }
50233 arg3 = static_cast< int >(val3);
50234 ecode4 = SWIG_AsVal_int(obj3, &val4);
50235 if (!SWIG_IsOK(ecode4)) {
50236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
50237 }
50238 arg4 = static_cast< int >(val4);
50239 ecode5 = SWIG_AsVal_int(obj4, &val5);
50240 if (!SWIG_IsOK(ecode5)) {
50241 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50242 }
50243 arg5 = static_cast< int >(val5);
50244 if (obj5) {
50245 arg6 = obj5;
50246 }
50247 {
50248 PyThreadState* __tstate = wxPyBeginAllowThreads();
50249 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
50250 wxPyEndAllowThreads(__tstate);
50251 if (PyErr_Occurred()) SWIG_fail;
50252 }
50253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50254 return resultobj;
50255 fail:
50256 return NULL;
50257 }
50258
50259
50260 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50261 PyObject *resultobj = 0;
50262 wxSizer *arg1 = (wxSizer *) 0 ;
50263 int arg2 ;
50264 int arg3 ;
50265 int arg4 ;
50266 PyObject *arg5 = (PyObject *) NULL ;
50267 wxSizerItem *result = 0 ;
50268 int res1 = 0 ;
50269 int val2 ;
50270 int ecode2 = 0 ;
50271 int val3 ;
50272 int ecode3 = 0 ;
50273 int val4 ;
50274 int ecode4 = 0 ;
50275 PyObject * obj0 = 0 ;
50276 PyObject * obj1 = 0 ;
50277 PyObject * obj2 = 0 ;
50278 PyObject * obj3 = 0 ;
50279 PyObject * obj4 = 0 ;
50280 char * kwnames[] = {
50281 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50282 };
50283
50284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50285 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50286 if (!SWIG_IsOK(res1)) {
50287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50288 }
50289 ecode2 = SWIG_AsVal_int(obj1, &val2);
50290 if (!SWIG_IsOK(ecode2)) {
50291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
50292 }
50293 arg2 = static_cast< int >(val2);
50294 ecode3 = SWIG_AsVal_int(obj2, &val3);
50295 if (!SWIG_IsOK(ecode3)) {
50296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
50297 }
50298 arg3 = static_cast< int >(val3);
50299 ecode4 = SWIG_AsVal_int(obj3, &val4);
50300 if (!SWIG_IsOK(ecode4)) {
50301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50302 }
50303 arg4 = static_cast< int >(val4);
50304 if (obj4) {
50305 arg5 = obj4;
50306 }
50307 {
50308 PyThreadState* __tstate = wxPyBeginAllowThreads();
50309 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50310 wxPyEndAllowThreads(__tstate);
50311 if (PyErr_Occurred()) SWIG_fail;
50312 }
50313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50314 return resultobj;
50315 fail:
50316 return NULL;
50317 }
50318
50319
50320 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50321 PyObject *resultobj = 0;
50322 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50323 void *argp1 = 0 ;
50324 int res1 = 0 ;
50325 PyObject *swig_obj[1] ;
50326
50327 if (!args) SWIG_fail;
50328 swig_obj[0] = args;
50329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50330 if (!SWIG_IsOK(res1)) {
50331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50332 }
50333 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50334 {
50335 PyThreadState* __tstate = wxPyBeginAllowThreads();
50336 (arg1)->DeleteWindows();
50337 wxPyEndAllowThreads(__tstate);
50338 if (PyErr_Occurred()) SWIG_fail;
50339 }
50340 resultobj = SWIG_Py_Void();
50341 return resultobj;
50342 fail:
50343 return NULL;
50344 }
50345
50346
50347 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50348 PyObject *resultobj = 0;
50349 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50350 void *argp1 = 0 ;
50351 int res1 = 0 ;
50352 PyObject *swig_obj[1] ;
50353
50354 if (!args) SWIG_fail;
50355 swig_obj[0] = args;
50356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50357 if (!SWIG_IsOK(res1)) {
50358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50359 }
50360 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50361 {
50362 PyThreadState* __tstate = wxPyBeginAllowThreads();
50363 (arg1)->DetachSizer();
50364 wxPyEndAllowThreads(__tstate);
50365 if (PyErr_Occurred()) SWIG_fail;
50366 }
50367 resultobj = SWIG_Py_Void();
50368 return resultobj;
50369 fail:
50370 return NULL;
50371 }
50372
50373
50374 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50375 PyObject *resultobj = 0;
50376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50377 wxSize result;
50378 void *argp1 = 0 ;
50379 int res1 = 0 ;
50380 PyObject *swig_obj[1] ;
50381
50382 if (!args) SWIG_fail;
50383 swig_obj[0] = args;
50384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50385 if (!SWIG_IsOK(res1)) {
50386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50387 }
50388 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50389 {
50390 PyThreadState* __tstate = wxPyBeginAllowThreads();
50391 result = (arg1)->GetSize();
50392 wxPyEndAllowThreads(__tstate);
50393 if (PyErr_Occurred()) SWIG_fail;
50394 }
50395 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50396 return resultobj;
50397 fail:
50398 return NULL;
50399 }
50400
50401
50402 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50403 PyObject *resultobj = 0;
50404 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50405 wxSize result;
50406 void *argp1 = 0 ;
50407 int res1 = 0 ;
50408 PyObject *swig_obj[1] ;
50409
50410 if (!args) SWIG_fail;
50411 swig_obj[0] = args;
50412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50413 if (!SWIG_IsOK(res1)) {
50414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50415 }
50416 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50417 {
50418 PyThreadState* __tstate = wxPyBeginAllowThreads();
50419 result = (arg1)->CalcMin();
50420 wxPyEndAllowThreads(__tstate);
50421 if (PyErr_Occurred()) SWIG_fail;
50422 }
50423 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50424 return resultobj;
50425 fail:
50426 return NULL;
50427 }
50428
50429
50430 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50431 PyObject *resultobj = 0;
50432 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50433 wxPoint *arg2 = 0 ;
50434 wxSize *arg3 = 0 ;
50435 void *argp1 = 0 ;
50436 int res1 = 0 ;
50437 wxPoint temp2 ;
50438 wxSize temp3 ;
50439 PyObject * obj0 = 0 ;
50440 PyObject * obj1 = 0 ;
50441 PyObject * obj2 = 0 ;
50442 char * kwnames[] = {
50443 (char *) "self",(char *) "pos",(char *) "size", NULL
50444 };
50445
50446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50448 if (!SWIG_IsOK(res1)) {
50449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50450 }
50451 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50452 {
50453 arg2 = &temp2;
50454 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50455 }
50456 {
50457 arg3 = &temp3;
50458 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50459 }
50460 {
50461 PyThreadState* __tstate = wxPyBeginAllowThreads();
50462 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
50463 wxPyEndAllowThreads(__tstate);
50464 if (PyErr_Occurred()) SWIG_fail;
50465 }
50466 resultobj = SWIG_Py_Void();
50467 return resultobj;
50468 fail:
50469 return NULL;
50470 }
50471
50472
50473 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50474 PyObject *resultobj = 0;
50475 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50476 wxSize result;
50477 void *argp1 = 0 ;
50478 int res1 = 0 ;
50479 PyObject *swig_obj[1] ;
50480
50481 if (!args) SWIG_fail;
50482 swig_obj[0] = args;
50483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50484 if (!SWIG_IsOK(res1)) {
50485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50486 }
50487 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50488 {
50489 PyThreadState* __tstate = wxPyBeginAllowThreads();
50490 result = (arg1)->GetMinSize();
50491 wxPyEndAllowThreads(__tstate);
50492 if (PyErr_Occurred()) SWIG_fail;
50493 }
50494 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50495 return resultobj;
50496 fail:
50497 return NULL;
50498 }
50499
50500
50501 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50502 PyObject *resultobj = 0;
50503 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50504 wxSize result;
50505 void *argp1 = 0 ;
50506 int res1 = 0 ;
50507 PyObject *swig_obj[1] ;
50508
50509 if (!args) SWIG_fail;
50510 swig_obj[0] = args;
50511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50512 if (!SWIG_IsOK(res1)) {
50513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50514 }
50515 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50516 {
50517 PyThreadState* __tstate = wxPyBeginAllowThreads();
50518 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50519 wxPyEndAllowThreads(__tstate);
50520 if (PyErr_Occurred()) SWIG_fail;
50521 }
50522 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50523 return resultobj;
50524 fail:
50525 return NULL;
50526 }
50527
50528
50529 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50530 PyObject *resultobj = 0;
50531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50532 int arg2 ;
50533 int arg3 ;
50534 void *argp1 = 0 ;
50535 int res1 = 0 ;
50536 int val2 ;
50537 int ecode2 = 0 ;
50538 int val3 ;
50539 int ecode3 = 0 ;
50540 PyObject * obj0 = 0 ;
50541 PyObject * obj1 = 0 ;
50542 PyObject * obj2 = 0 ;
50543 char * kwnames[] = {
50544 (char *) "self",(char *) "x",(char *) "y", NULL
50545 };
50546
50547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50549 if (!SWIG_IsOK(res1)) {
50550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50551 }
50552 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50553 ecode2 = SWIG_AsVal_int(obj1, &val2);
50554 if (!SWIG_IsOK(ecode2)) {
50555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50556 }
50557 arg2 = static_cast< int >(val2);
50558 ecode3 = SWIG_AsVal_int(obj2, &val3);
50559 if (!SWIG_IsOK(ecode3)) {
50560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50561 }
50562 arg3 = static_cast< int >(val3);
50563 {
50564 PyThreadState* __tstate = wxPyBeginAllowThreads();
50565 (arg1)->SetInitSize(arg2,arg3);
50566 wxPyEndAllowThreads(__tstate);
50567 if (PyErr_Occurred()) SWIG_fail;
50568 }
50569 resultobj = SWIG_Py_Void();
50570 return resultobj;
50571 fail:
50572 return NULL;
50573 }
50574
50575
50576 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50577 PyObject *resultobj = 0;
50578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50579 int arg2 ;
50580 int arg3 ;
50581 void *argp1 = 0 ;
50582 int res1 = 0 ;
50583 int val2 ;
50584 int ecode2 = 0 ;
50585 int val3 ;
50586 int ecode3 = 0 ;
50587 PyObject * obj0 = 0 ;
50588 PyObject * obj1 = 0 ;
50589 PyObject * obj2 = 0 ;
50590 char * kwnames[] = {
50591 (char *) "self",(char *) "width",(char *) "height", NULL
50592 };
50593
50594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50596 if (!SWIG_IsOK(res1)) {
50597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50598 }
50599 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50600 ecode2 = SWIG_AsVal_int(obj1, &val2);
50601 if (!SWIG_IsOK(ecode2)) {
50602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50603 }
50604 arg2 = static_cast< int >(val2);
50605 ecode3 = SWIG_AsVal_int(obj2, &val3);
50606 if (!SWIG_IsOK(ecode3)) {
50607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50608 }
50609 arg3 = static_cast< int >(val3);
50610 {
50611 PyThreadState* __tstate = wxPyBeginAllowThreads();
50612 (arg1)->SetRatio(arg2,arg3);
50613 wxPyEndAllowThreads(__tstate);
50614 if (PyErr_Occurred()) SWIG_fail;
50615 }
50616 resultobj = SWIG_Py_Void();
50617 return resultobj;
50618 fail:
50619 return NULL;
50620 }
50621
50622
50623 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50624 PyObject *resultobj = 0;
50625 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50626 wxSize *arg2 = 0 ;
50627 void *argp1 = 0 ;
50628 int res1 = 0 ;
50629 wxSize temp2 ;
50630 PyObject * obj0 = 0 ;
50631 PyObject * obj1 = 0 ;
50632 char * kwnames[] = {
50633 (char *) "self",(char *) "size", NULL
50634 };
50635
50636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50638 if (!SWIG_IsOK(res1)) {
50639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50640 }
50641 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50642 {
50643 arg2 = &temp2;
50644 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50645 }
50646 {
50647 PyThreadState* __tstate = wxPyBeginAllowThreads();
50648 (arg1)->SetRatio((wxSize const &)*arg2);
50649 wxPyEndAllowThreads(__tstate);
50650 if (PyErr_Occurred()) SWIG_fail;
50651 }
50652 resultobj = SWIG_Py_Void();
50653 return resultobj;
50654 fail:
50655 return NULL;
50656 }
50657
50658
50659 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50660 PyObject *resultobj = 0;
50661 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50662 float arg2 ;
50663 void *argp1 = 0 ;
50664 int res1 = 0 ;
50665 float val2 ;
50666 int ecode2 = 0 ;
50667 PyObject * obj0 = 0 ;
50668 PyObject * obj1 = 0 ;
50669 char * kwnames[] = {
50670 (char *) "self",(char *) "ratio", NULL
50671 };
50672
50673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50675 if (!SWIG_IsOK(res1)) {
50676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50677 }
50678 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50679 ecode2 = SWIG_AsVal_float(obj1, &val2);
50680 if (!SWIG_IsOK(ecode2)) {
50681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50682 }
50683 arg2 = static_cast< float >(val2);
50684 {
50685 PyThreadState* __tstate = wxPyBeginAllowThreads();
50686 (arg1)->SetRatio(arg2);
50687 wxPyEndAllowThreads(__tstate);
50688 if (PyErr_Occurred()) SWIG_fail;
50689 }
50690 resultobj = SWIG_Py_Void();
50691 return resultobj;
50692 fail:
50693 return NULL;
50694 }
50695
50696
50697 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50698 PyObject *resultobj = 0;
50699 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50700 float result;
50701 void *argp1 = 0 ;
50702 int res1 = 0 ;
50703 PyObject *swig_obj[1] ;
50704
50705 if (!args) SWIG_fail;
50706 swig_obj[0] = args;
50707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50708 if (!SWIG_IsOK(res1)) {
50709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50710 }
50711 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50712 {
50713 PyThreadState* __tstate = wxPyBeginAllowThreads();
50714 result = (float)(arg1)->GetRatio();
50715 wxPyEndAllowThreads(__tstate);
50716 if (PyErr_Occurred()) SWIG_fail;
50717 }
50718 resultobj = SWIG_From_float(static_cast< float >(result));
50719 return resultobj;
50720 fail:
50721 return NULL;
50722 }
50723
50724
50725 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50726 PyObject *resultobj = 0;
50727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50728 wxRect result;
50729 void *argp1 = 0 ;
50730 int res1 = 0 ;
50731 PyObject *swig_obj[1] ;
50732
50733 if (!args) SWIG_fail;
50734 swig_obj[0] = args;
50735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50736 if (!SWIG_IsOK(res1)) {
50737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50738 }
50739 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50740 {
50741 PyThreadState* __tstate = wxPyBeginAllowThreads();
50742 result = (arg1)->GetRect();
50743 wxPyEndAllowThreads(__tstate);
50744 if (PyErr_Occurred()) SWIG_fail;
50745 }
50746 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50747 return resultobj;
50748 fail:
50749 return NULL;
50750 }
50751
50752
50753 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50754 PyObject *resultobj = 0;
50755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50756 bool result;
50757 void *argp1 = 0 ;
50758 int res1 = 0 ;
50759 PyObject *swig_obj[1] ;
50760
50761 if (!args) SWIG_fail;
50762 swig_obj[0] = args;
50763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50764 if (!SWIG_IsOK(res1)) {
50765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50766 }
50767 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50768 {
50769 PyThreadState* __tstate = wxPyBeginAllowThreads();
50770 result = (bool)(arg1)->IsWindow();
50771 wxPyEndAllowThreads(__tstate);
50772 if (PyErr_Occurred()) SWIG_fail;
50773 }
50774 {
50775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50776 }
50777 return resultobj;
50778 fail:
50779 return NULL;
50780 }
50781
50782
50783 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50784 PyObject *resultobj = 0;
50785 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50786 bool result;
50787 void *argp1 = 0 ;
50788 int res1 = 0 ;
50789 PyObject *swig_obj[1] ;
50790
50791 if (!args) SWIG_fail;
50792 swig_obj[0] = args;
50793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50794 if (!SWIG_IsOK(res1)) {
50795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50796 }
50797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50798 {
50799 PyThreadState* __tstate = wxPyBeginAllowThreads();
50800 result = (bool)(arg1)->IsSizer();
50801 wxPyEndAllowThreads(__tstate);
50802 if (PyErr_Occurred()) SWIG_fail;
50803 }
50804 {
50805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50806 }
50807 return resultobj;
50808 fail:
50809 return NULL;
50810 }
50811
50812
50813 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50814 PyObject *resultobj = 0;
50815 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50816 bool result;
50817 void *argp1 = 0 ;
50818 int res1 = 0 ;
50819 PyObject *swig_obj[1] ;
50820
50821 if (!args) SWIG_fail;
50822 swig_obj[0] = args;
50823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50824 if (!SWIG_IsOK(res1)) {
50825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50826 }
50827 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50828 {
50829 PyThreadState* __tstate = wxPyBeginAllowThreads();
50830 result = (bool)(arg1)->IsSpacer();
50831 wxPyEndAllowThreads(__tstate);
50832 if (PyErr_Occurred()) SWIG_fail;
50833 }
50834 {
50835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50836 }
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50844 PyObject *resultobj = 0;
50845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50846 int arg2 ;
50847 void *argp1 = 0 ;
50848 int res1 = 0 ;
50849 int val2 ;
50850 int ecode2 = 0 ;
50851 PyObject * obj0 = 0 ;
50852 PyObject * obj1 = 0 ;
50853 char * kwnames[] = {
50854 (char *) "self",(char *) "proportion", NULL
50855 };
50856
50857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50859 if (!SWIG_IsOK(res1)) {
50860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50861 }
50862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50863 ecode2 = SWIG_AsVal_int(obj1, &val2);
50864 if (!SWIG_IsOK(ecode2)) {
50865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50866 }
50867 arg2 = static_cast< int >(val2);
50868 {
50869 PyThreadState* __tstate = wxPyBeginAllowThreads();
50870 (arg1)->SetProportion(arg2);
50871 wxPyEndAllowThreads(__tstate);
50872 if (PyErr_Occurred()) SWIG_fail;
50873 }
50874 resultobj = SWIG_Py_Void();
50875 return resultobj;
50876 fail:
50877 return NULL;
50878 }
50879
50880
50881 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50882 PyObject *resultobj = 0;
50883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50884 int result;
50885 void *argp1 = 0 ;
50886 int res1 = 0 ;
50887 PyObject *swig_obj[1] ;
50888
50889 if (!args) SWIG_fail;
50890 swig_obj[0] = args;
50891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50892 if (!SWIG_IsOK(res1)) {
50893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50894 }
50895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50896 {
50897 PyThreadState* __tstate = wxPyBeginAllowThreads();
50898 result = (int)(arg1)->GetProportion();
50899 wxPyEndAllowThreads(__tstate);
50900 if (PyErr_Occurred()) SWIG_fail;
50901 }
50902 resultobj = SWIG_From_int(static_cast< int >(result));
50903 return resultobj;
50904 fail:
50905 return NULL;
50906 }
50907
50908
50909 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50910 PyObject *resultobj = 0;
50911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50912 int arg2 ;
50913 void *argp1 = 0 ;
50914 int res1 = 0 ;
50915 int val2 ;
50916 int ecode2 = 0 ;
50917 PyObject * obj0 = 0 ;
50918 PyObject * obj1 = 0 ;
50919 char * kwnames[] = {
50920 (char *) "self",(char *) "flag", NULL
50921 };
50922
50923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50925 if (!SWIG_IsOK(res1)) {
50926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50927 }
50928 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50929 ecode2 = SWIG_AsVal_int(obj1, &val2);
50930 if (!SWIG_IsOK(ecode2)) {
50931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50932 }
50933 arg2 = static_cast< int >(val2);
50934 {
50935 PyThreadState* __tstate = wxPyBeginAllowThreads();
50936 (arg1)->SetFlag(arg2);
50937 wxPyEndAllowThreads(__tstate);
50938 if (PyErr_Occurred()) SWIG_fail;
50939 }
50940 resultobj = SWIG_Py_Void();
50941 return resultobj;
50942 fail:
50943 return NULL;
50944 }
50945
50946
50947 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50948 PyObject *resultobj = 0;
50949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50950 int result;
50951 void *argp1 = 0 ;
50952 int res1 = 0 ;
50953 PyObject *swig_obj[1] ;
50954
50955 if (!args) SWIG_fail;
50956 swig_obj[0] = args;
50957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50958 if (!SWIG_IsOK(res1)) {
50959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50960 }
50961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50962 {
50963 PyThreadState* __tstate = wxPyBeginAllowThreads();
50964 result = (int)(arg1)->GetFlag();
50965 wxPyEndAllowThreads(__tstate);
50966 if (PyErr_Occurred()) SWIG_fail;
50967 }
50968 resultobj = SWIG_From_int(static_cast< int >(result));
50969 return resultobj;
50970 fail:
50971 return NULL;
50972 }
50973
50974
50975 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50976 PyObject *resultobj = 0;
50977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50978 int arg2 ;
50979 void *argp1 = 0 ;
50980 int res1 = 0 ;
50981 int val2 ;
50982 int ecode2 = 0 ;
50983 PyObject * obj0 = 0 ;
50984 PyObject * obj1 = 0 ;
50985 char * kwnames[] = {
50986 (char *) "self",(char *) "border", NULL
50987 };
50988
50989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50991 if (!SWIG_IsOK(res1)) {
50992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50993 }
50994 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50995 ecode2 = SWIG_AsVal_int(obj1, &val2);
50996 if (!SWIG_IsOK(ecode2)) {
50997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50998 }
50999 arg2 = static_cast< int >(val2);
51000 {
51001 PyThreadState* __tstate = wxPyBeginAllowThreads();
51002 (arg1)->SetBorder(arg2);
51003 wxPyEndAllowThreads(__tstate);
51004 if (PyErr_Occurred()) SWIG_fail;
51005 }
51006 resultobj = SWIG_Py_Void();
51007 return resultobj;
51008 fail:
51009 return NULL;
51010 }
51011
51012
51013 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51014 PyObject *resultobj = 0;
51015 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51016 int result;
51017 void *argp1 = 0 ;
51018 int res1 = 0 ;
51019 PyObject *swig_obj[1] ;
51020
51021 if (!args) SWIG_fail;
51022 swig_obj[0] = args;
51023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51024 if (!SWIG_IsOK(res1)) {
51025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51026 }
51027 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51028 {
51029 PyThreadState* __tstate = wxPyBeginAllowThreads();
51030 result = (int)(arg1)->GetBorder();
51031 wxPyEndAllowThreads(__tstate);
51032 if (PyErr_Occurred()) SWIG_fail;
51033 }
51034 resultobj = SWIG_From_int(static_cast< int >(result));
51035 return resultobj;
51036 fail:
51037 return NULL;
51038 }
51039
51040
51041 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51042 PyObject *resultobj = 0;
51043 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51044 wxWindow *result = 0 ;
51045 void *argp1 = 0 ;
51046 int res1 = 0 ;
51047 PyObject *swig_obj[1] ;
51048
51049 if (!args) SWIG_fail;
51050 swig_obj[0] = args;
51051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51052 if (!SWIG_IsOK(res1)) {
51053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51054 }
51055 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51056 {
51057 PyThreadState* __tstate = wxPyBeginAllowThreads();
51058 result = (wxWindow *)(arg1)->GetWindow();
51059 wxPyEndAllowThreads(__tstate);
51060 if (PyErr_Occurred()) SWIG_fail;
51061 }
51062 {
51063 resultobj = wxPyMake_wxObject(result, 0);
51064 }
51065 return resultobj;
51066 fail:
51067 return NULL;
51068 }
51069
51070
51071 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51072 PyObject *resultobj = 0;
51073 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51074 wxSizer *result = 0 ;
51075 void *argp1 = 0 ;
51076 int res1 = 0 ;
51077 PyObject *swig_obj[1] ;
51078
51079 if (!args) SWIG_fail;
51080 swig_obj[0] = args;
51081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51082 if (!SWIG_IsOK(res1)) {
51083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51084 }
51085 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51086 {
51087 PyThreadState* __tstate = wxPyBeginAllowThreads();
51088 result = (wxSizer *)(arg1)->GetSizer();
51089 wxPyEndAllowThreads(__tstate);
51090 if (PyErr_Occurred()) SWIG_fail;
51091 }
51092 {
51093 resultobj = wxPyMake_wxObject(result, (bool)0);
51094 }
51095 return resultobj;
51096 fail:
51097 return NULL;
51098 }
51099
51100
51101 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51102 PyObject *resultobj = 0;
51103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51104 wxSize result;
51105 void *argp1 = 0 ;
51106 int res1 = 0 ;
51107 PyObject *swig_obj[1] ;
51108
51109 if (!args) SWIG_fail;
51110 swig_obj[0] = args;
51111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51112 if (!SWIG_IsOK(res1)) {
51113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51114 }
51115 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51116 {
51117 PyThreadState* __tstate = wxPyBeginAllowThreads();
51118 result = (arg1)->GetSpacer();
51119 wxPyEndAllowThreads(__tstate);
51120 if (PyErr_Occurred()) SWIG_fail;
51121 }
51122 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51123 return resultobj;
51124 fail:
51125 return NULL;
51126 }
51127
51128
51129 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51130 PyObject *resultobj = 0;
51131 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51132 wxWindow *arg2 = (wxWindow *) 0 ;
51133 void *argp1 = 0 ;
51134 int res1 = 0 ;
51135 void *argp2 = 0 ;
51136 int res2 = 0 ;
51137 PyObject * obj0 = 0 ;
51138 PyObject * obj1 = 0 ;
51139 char * kwnames[] = {
51140 (char *) "self",(char *) "window", NULL
51141 };
51142
51143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51145 if (!SWIG_IsOK(res1)) {
51146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51147 }
51148 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51150 if (!SWIG_IsOK(res2)) {
51151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51152 }
51153 arg2 = reinterpret_cast< wxWindow * >(argp2);
51154 {
51155 PyThreadState* __tstate = wxPyBeginAllowThreads();
51156 (arg1)->SetWindow(arg2);
51157 wxPyEndAllowThreads(__tstate);
51158 if (PyErr_Occurred()) SWIG_fail;
51159 }
51160 resultobj = SWIG_Py_Void();
51161 return resultobj;
51162 fail:
51163 return NULL;
51164 }
51165
51166
51167 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51168 PyObject *resultobj = 0;
51169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51170 wxSizer *arg2 = (wxSizer *) 0 ;
51171 void *argp1 = 0 ;
51172 int res1 = 0 ;
51173 int res2 = 0 ;
51174 PyObject * obj0 = 0 ;
51175 PyObject * obj1 = 0 ;
51176 char * kwnames[] = {
51177 (char *) "self",(char *) "sizer", NULL
51178 };
51179
51180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51182 if (!SWIG_IsOK(res1)) {
51183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51184 }
51185 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51186 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51187 if (!SWIG_IsOK(res2)) {
51188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51189 }
51190 {
51191 PyThreadState* __tstate = wxPyBeginAllowThreads();
51192 (arg1)->SetSizer(arg2);
51193 wxPyEndAllowThreads(__tstate);
51194 if (PyErr_Occurred()) SWIG_fail;
51195 }
51196 resultobj = SWIG_Py_Void();
51197 return resultobj;
51198 fail:
51199 return NULL;
51200 }
51201
51202
51203 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51204 PyObject *resultobj = 0;
51205 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51206 wxSize *arg2 = 0 ;
51207 void *argp1 = 0 ;
51208 int res1 = 0 ;
51209 wxSize temp2 ;
51210 PyObject * obj0 = 0 ;
51211 PyObject * obj1 = 0 ;
51212 char * kwnames[] = {
51213 (char *) "self",(char *) "size", NULL
51214 };
51215
51216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51218 if (!SWIG_IsOK(res1)) {
51219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51220 }
51221 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51222 {
51223 arg2 = &temp2;
51224 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51225 }
51226 {
51227 PyThreadState* __tstate = wxPyBeginAllowThreads();
51228 (arg1)->SetSpacer((wxSize const &)*arg2);
51229 wxPyEndAllowThreads(__tstate);
51230 if (PyErr_Occurred()) SWIG_fail;
51231 }
51232 resultobj = SWIG_Py_Void();
51233 return resultobj;
51234 fail:
51235 return NULL;
51236 }
51237
51238
51239 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51240 PyObject *resultobj = 0;
51241 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51242 wxWindow *arg2 = (wxWindow *) 0 ;
51243 void *argp1 = 0 ;
51244 int res1 = 0 ;
51245 void *argp2 = 0 ;
51246 int res2 = 0 ;
51247 PyObject * obj0 = 0 ;
51248 PyObject * obj1 = 0 ;
51249 char * kwnames[] = {
51250 (char *) "self",(char *) "window", NULL
51251 };
51252
51253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51255 if (!SWIG_IsOK(res1)) {
51256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51257 }
51258 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51260 if (!SWIG_IsOK(res2)) {
51261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51262 }
51263 arg2 = reinterpret_cast< wxWindow * >(argp2);
51264 {
51265 PyThreadState* __tstate = wxPyBeginAllowThreads();
51266 (arg1)->AssignWindow(arg2);
51267 wxPyEndAllowThreads(__tstate);
51268 if (PyErr_Occurred()) SWIG_fail;
51269 }
51270 resultobj = SWIG_Py_Void();
51271 return resultobj;
51272 fail:
51273 return NULL;
51274 }
51275
51276
51277 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51278 PyObject *resultobj = 0;
51279 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51280 wxSizer *arg2 = (wxSizer *) 0 ;
51281 void *argp1 = 0 ;
51282 int res1 = 0 ;
51283 void *argp2 = 0 ;
51284 int res2 = 0 ;
51285 PyObject * obj0 = 0 ;
51286 PyObject * obj1 = 0 ;
51287 char * kwnames[] = {
51288 (char *) "self",(char *) "sizer", NULL
51289 };
51290
51291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51293 if (!SWIG_IsOK(res1)) {
51294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51295 }
51296 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51298 if (!SWIG_IsOK(res2)) {
51299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51300 }
51301 arg2 = reinterpret_cast< wxSizer * >(argp2);
51302 {
51303 PyThreadState* __tstate = wxPyBeginAllowThreads();
51304 (arg1)->AssignSizer(arg2);
51305 wxPyEndAllowThreads(__tstate);
51306 if (PyErr_Occurred()) SWIG_fail;
51307 }
51308 resultobj = SWIG_Py_Void();
51309 return resultobj;
51310 fail:
51311 return NULL;
51312 }
51313
51314
51315 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51316 PyObject *resultobj = 0;
51317 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51318 wxSize *arg2 = 0 ;
51319 void *argp1 = 0 ;
51320 int res1 = 0 ;
51321 wxSize temp2 ;
51322 PyObject * obj0 = 0 ;
51323 PyObject * obj1 = 0 ;
51324 char * kwnames[] = {
51325 (char *) "self",(char *) "size", NULL
51326 };
51327
51328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51330 if (!SWIG_IsOK(res1)) {
51331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51332 }
51333 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51334 {
51335 arg2 = &temp2;
51336 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51337 }
51338 {
51339 PyThreadState* __tstate = wxPyBeginAllowThreads();
51340 (arg1)->AssignSpacer((wxSize const &)*arg2);
51341 wxPyEndAllowThreads(__tstate);
51342 if (PyErr_Occurred()) SWIG_fail;
51343 }
51344 resultobj = SWIG_Py_Void();
51345 return resultobj;
51346 fail:
51347 return NULL;
51348 }
51349
51350
51351 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51352 PyObject *resultobj = 0;
51353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51354 bool arg2 ;
51355 void *argp1 = 0 ;
51356 int res1 = 0 ;
51357 bool val2 ;
51358 int ecode2 = 0 ;
51359 PyObject * obj0 = 0 ;
51360 PyObject * obj1 = 0 ;
51361 char * kwnames[] = {
51362 (char *) "self",(char *) "show", NULL
51363 };
51364
51365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
51366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51367 if (!SWIG_IsOK(res1)) {
51368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51369 }
51370 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51371 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51372 if (!SWIG_IsOK(ecode2)) {
51373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
51374 }
51375 arg2 = static_cast< bool >(val2);
51376 {
51377 PyThreadState* __tstate = wxPyBeginAllowThreads();
51378 (arg1)->Show(arg2);
51379 wxPyEndAllowThreads(__tstate);
51380 if (PyErr_Occurred()) SWIG_fail;
51381 }
51382 resultobj = SWIG_Py_Void();
51383 return resultobj;
51384 fail:
51385 return NULL;
51386 }
51387
51388
51389 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51390 PyObject *resultobj = 0;
51391 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51392 bool result;
51393 void *argp1 = 0 ;
51394 int res1 = 0 ;
51395 PyObject *swig_obj[1] ;
51396
51397 if (!args) SWIG_fail;
51398 swig_obj[0] = args;
51399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51400 if (!SWIG_IsOK(res1)) {
51401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51402 }
51403 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51404 {
51405 PyThreadState* __tstate = wxPyBeginAllowThreads();
51406 result = (bool)(arg1)->IsShown();
51407 wxPyEndAllowThreads(__tstate);
51408 if (PyErr_Occurred()) SWIG_fail;
51409 }
51410 {
51411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51412 }
51413 return resultobj;
51414 fail:
51415 return NULL;
51416 }
51417
51418
51419 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51420 PyObject *resultobj = 0;
51421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51422 wxPoint result;
51423 void *argp1 = 0 ;
51424 int res1 = 0 ;
51425 PyObject *swig_obj[1] ;
51426
51427 if (!args) SWIG_fail;
51428 swig_obj[0] = args;
51429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51430 if (!SWIG_IsOK(res1)) {
51431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51432 }
51433 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51434 {
51435 PyThreadState* __tstate = wxPyBeginAllowThreads();
51436 result = (arg1)->GetPosition();
51437 wxPyEndAllowThreads(__tstate);
51438 if (PyErr_Occurred()) SWIG_fail;
51439 }
51440 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51441 return resultobj;
51442 fail:
51443 return NULL;
51444 }
51445
51446
51447 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51448 PyObject *resultobj = 0;
51449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51450 PyObject *result = 0 ;
51451 void *argp1 = 0 ;
51452 int res1 = 0 ;
51453 PyObject *swig_obj[1] ;
51454
51455 if (!args) SWIG_fail;
51456 swig_obj[0] = args;
51457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51458 if (!SWIG_IsOK(res1)) {
51459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51460 }
51461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51462 {
51463 PyThreadState* __tstate = wxPyBeginAllowThreads();
51464 result = (PyObject *)wxSizerItem_GetUserData(arg1);
51465 wxPyEndAllowThreads(__tstate);
51466 if (PyErr_Occurred()) SWIG_fail;
51467 }
51468 resultobj = result;
51469 return resultobj;
51470 fail:
51471 return NULL;
51472 }
51473
51474
51475 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51476 PyObject *resultobj = 0;
51477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51478 PyObject *arg2 = (PyObject *) 0 ;
51479 void *argp1 = 0 ;
51480 int res1 = 0 ;
51481 PyObject * obj0 = 0 ;
51482 PyObject * obj1 = 0 ;
51483 char * kwnames[] = {
51484 (char *) "self",(char *) "userData", NULL
51485 };
51486
51487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
51488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51489 if (!SWIG_IsOK(res1)) {
51490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51491 }
51492 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51493 arg2 = obj1;
51494 {
51495 PyThreadState* __tstate = wxPyBeginAllowThreads();
51496 wxSizerItem_SetUserData(arg1,arg2);
51497 wxPyEndAllowThreads(__tstate);
51498 if (PyErr_Occurred()) SWIG_fail;
51499 }
51500 resultobj = SWIG_Py_Void();
51501 return resultobj;
51502 fail:
51503 return NULL;
51504 }
51505
51506
51507 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51508 PyObject *obj;
51509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51510 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51511 return SWIG_Py_Void();
51512 }
51513
51514 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51515 return SWIG_Python_InitShadowInstance(args);
51516 }
51517
51518 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51519 PyObject *resultobj = 0;
51520 wxSizer *arg1 = (wxSizer *) 0 ;
51521 void *argp1 = 0 ;
51522 int res1 = 0 ;
51523 PyObject *swig_obj[1] ;
51524
51525 if (!args) SWIG_fail;
51526 swig_obj[0] = args;
51527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51528 if (!SWIG_IsOK(res1)) {
51529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51530 }
51531 arg1 = reinterpret_cast< wxSizer * >(argp1);
51532 {
51533 PyThreadState* __tstate = wxPyBeginAllowThreads();
51534 delete arg1;
51535
51536 wxPyEndAllowThreads(__tstate);
51537 if (PyErr_Occurred()) SWIG_fail;
51538 }
51539 resultobj = SWIG_Py_Void();
51540 return resultobj;
51541 fail:
51542 return NULL;
51543 }
51544
51545
51546 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51547 PyObject *resultobj = 0;
51548 wxSizer *arg1 = (wxSizer *) 0 ;
51549 PyObject *arg2 = (PyObject *) 0 ;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 PyObject * obj0 = 0 ;
51553 PyObject * obj1 = 0 ;
51554 char * kwnames[] = {
51555 (char *) "self",(char *) "_self", NULL
51556 };
51557
51558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51560 if (!SWIG_IsOK(res1)) {
51561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51562 }
51563 arg1 = reinterpret_cast< wxSizer * >(argp1);
51564 arg2 = obj1;
51565 {
51566 PyThreadState* __tstate = wxPyBeginAllowThreads();
51567 wxSizer__setOORInfo(arg1,arg2);
51568 wxPyEndAllowThreads(__tstate);
51569 if (PyErr_Occurred()) SWIG_fail;
51570 }
51571 resultobj = SWIG_Py_Void();
51572 return resultobj;
51573 fail:
51574 return NULL;
51575 }
51576
51577
51578 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51579 PyObject *resultobj = 0;
51580 wxSizer *arg1 = (wxSizer *) 0 ;
51581 PyObject *arg2 = (PyObject *) 0 ;
51582 int arg3 = (int) 0 ;
51583 int arg4 = (int) 0 ;
51584 int arg5 = (int) 0 ;
51585 PyObject *arg6 = (PyObject *) NULL ;
51586 wxSizerItem *result = 0 ;
51587 void *argp1 = 0 ;
51588 int res1 = 0 ;
51589 int val3 ;
51590 int ecode3 = 0 ;
51591 int val4 ;
51592 int ecode4 = 0 ;
51593 int val5 ;
51594 int ecode5 = 0 ;
51595 PyObject * obj0 = 0 ;
51596 PyObject * obj1 = 0 ;
51597 PyObject * obj2 = 0 ;
51598 PyObject * obj3 = 0 ;
51599 PyObject * obj4 = 0 ;
51600 PyObject * obj5 = 0 ;
51601 char * kwnames[] = {
51602 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51603 };
51604
51605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51607 if (!SWIG_IsOK(res1)) {
51608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51609 }
51610 arg1 = reinterpret_cast< wxSizer * >(argp1);
51611 arg2 = obj1;
51612 if (obj2) {
51613 ecode3 = SWIG_AsVal_int(obj2, &val3);
51614 if (!SWIG_IsOK(ecode3)) {
51615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51616 }
51617 arg3 = static_cast< int >(val3);
51618 }
51619 if (obj3) {
51620 ecode4 = SWIG_AsVal_int(obj3, &val4);
51621 if (!SWIG_IsOK(ecode4)) {
51622 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51623 }
51624 arg4 = static_cast< int >(val4);
51625 }
51626 if (obj4) {
51627 ecode5 = SWIG_AsVal_int(obj4, &val5);
51628 if (!SWIG_IsOK(ecode5)) {
51629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51630 }
51631 arg5 = static_cast< int >(val5);
51632 }
51633 if (obj5) {
51634 arg6 = obj5;
51635 }
51636 {
51637 PyThreadState* __tstate = wxPyBeginAllowThreads();
51638 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51639 wxPyEndAllowThreads(__tstate);
51640 if (PyErr_Occurred()) SWIG_fail;
51641 }
51642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51643 return resultobj;
51644 fail:
51645 return NULL;
51646 }
51647
51648
51649 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51650 PyObject *resultobj = 0;
51651 wxSizer *arg1 = (wxSizer *) 0 ;
51652 PyObject *arg2 = (PyObject *) 0 ;
51653 wxSizerFlags *arg3 = 0 ;
51654 wxSizerItem *result = 0 ;
51655 void *argp1 = 0 ;
51656 int res1 = 0 ;
51657 void *argp3 = 0 ;
51658 int res3 = 0 ;
51659 PyObject * obj0 = 0 ;
51660 PyObject * obj1 = 0 ;
51661 PyObject * obj2 = 0 ;
51662 char * kwnames[] = {
51663 (char *) "self",(char *) "item",(char *) "flags", NULL
51664 };
51665
51666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51668 if (!SWIG_IsOK(res1)) {
51669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51670 }
51671 arg1 = reinterpret_cast< wxSizer * >(argp1);
51672 arg2 = obj1;
51673 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51674 if (!SWIG_IsOK(res3)) {
51675 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51676 }
51677 if (!argp3) {
51678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51679 }
51680 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51681 {
51682 PyThreadState* __tstate = wxPyBeginAllowThreads();
51683 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51684 wxPyEndAllowThreads(__tstate);
51685 if (PyErr_Occurred()) SWIG_fail;
51686 }
51687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51688 return resultobj;
51689 fail:
51690 return NULL;
51691 }
51692
51693
51694 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51695 PyObject *resultobj = 0;
51696 wxSizer *arg1 = (wxSizer *) 0 ;
51697 int arg2 ;
51698 PyObject *arg3 = (PyObject *) 0 ;
51699 int arg4 = (int) 0 ;
51700 int arg5 = (int) 0 ;
51701 int arg6 = (int) 0 ;
51702 PyObject *arg7 = (PyObject *) NULL ;
51703 wxSizerItem *result = 0 ;
51704 void *argp1 = 0 ;
51705 int res1 = 0 ;
51706 int val2 ;
51707 int ecode2 = 0 ;
51708 int val4 ;
51709 int ecode4 = 0 ;
51710 int val5 ;
51711 int ecode5 = 0 ;
51712 int val6 ;
51713 int ecode6 = 0 ;
51714 PyObject * obj0 = 0 ;
51715 PyObject * obj1 = 0 ;
51716 PyObject * obj2 = 0 ;
51717 PyObject * obj3 = 0 ;
51718 PyObject * obj4 = 0 ;
51719 PyObject * obj5 = 0 ;
51720 PyObject * obj6 = 0 ;
51721 char * kwnames[] = {
51722 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51723 };
51724
51725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51727 if (!SWIG_IsOK(res1)) {
51728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51729 }
51730 arg1 = reinterpret_cast< wxSizer * >(argp1);
51731 ecode2 = SWIG_AsVal_int(obj1, &val2);
51732 if (!SWIG_IsOK(ecode2)) {
51733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51734 }
51735 arg2 = static_cast< int >(val2);
51736 arg3 = obj2;
51737 if (obj3) {
51738 ecode4 = SWIG_AsVal_int(obj3, &val4);
51739 if (!SWIG_IsOK(ecode4)) {
51740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51741 }
51742 arg4 = static_cast< int >(val4);
51743 }
51744 if (obj4) {
51745 ecode5 = SWIG_AsVal_int(obj4, &val5);
51746 if (!SWIG_IsOK(ecode5)) {
51747 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51748 }
51749 arg5 = static_cast< int >(val5);
51750 }
51751 if (obj5) {
51752 ecode6 = SWIG_AsVal_int(obj5, &val6);
51753 if (!SWIG_IsOK(ecode6)) {
51754 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51755 }
51756 arg6 = static_cast< int >(val6);
51757 }
51758 if (obj6) {
51759 arg7 = obj6;
51760 }
51761 {
51762 PyThreadState* __tstate = wxPyBeginAllowThreads();
51763 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51764 wxPyEndAllowThreads(__tstate);
51765 if (PyErr_Occurred()) SWIG_fail;
51766 }
51767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51768 return resultobj;
51769 fail:
51770 return NULL;
51771 }
51772
51773
51774 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51775 PyObject *resultobj = 0;
51776 wxSizer *arg1 = (wxSizer *) 0 ;
51777 int arg2 ;
51778 PyObject *arg3 = (PyObject *) 0 ;
51779 wxSizerFlags *arg4 = 0 ;
51780 wxSizerItem *result = 0 ;
51781 void *argp1 = 0 ;
51782 int res1 = 0 ;
51783 int val2 ;
51784 int ecode2 = 0 ;
51785 void *argp4 = 0 ;
51786 int res4 = 0 ;
51787 PyObject * obj0 = 0 ;
51788 PyObject * obj1 = 0 ;
51789 PyObject * obj2 = 0 ;
51790 PyObject * obj3 = 0 ;
51791 char * kwnames[] = {
51792 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51793 };
51794
51795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51797 if (!SWIG_IsOK(res1)) {
51798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51799 }
51800 arg1 = reinterpret_cast< wxSizer * >(argp1);
51801 ecode2 = SWIG_AsVal_int(obj1, &val2);
51802 if (!SWIG_IsOK(ecode2)) {
51803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51804 }
51805 arg2 = static_cast< int >(val2);
51806 arg3 = obj2;
51807 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51808 if (!SWIG_IsOK(res4)) {
51809 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51810 }
51811 if (!argp4) {
51812 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51813 }
51814 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51815 {
51816 PyThreadState* __tstate = wxPyBeginAllowThreads();
51817 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51818 wxPyEndAllowThreads(__tstate);
51819 if (PyErr_Occurred()) SWIG_fail;
51820 }
51821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51822 return resultobj;
51823 fail:
51824 return NULL;
51825 }
51826
51827
51828 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51829 PyObject *resultobj = 0;
51830 wxSizer *arg1 = (wxSizer *) 0 ;
51831 PyObject *arg2 = (PyObject *) 0 ;
51832 int arg3 = (int) 0 ;
51833 int arg4 = (int) 0 ;
51834 int arg5 = (int) 0 ;
51835 PyObject *arg6 = (PyObject *) NULL ;
51836 wxSizerItem *result = 0 ;
51837 void *argp1 = 0 ;
51838 int res1 = 0 ;
51839 int val3 ;
51840 int ecode3 = 0 ;
51841 int val4 ;
51842 int ecode4 = 0 ;
51843 int val5 ;
51844 int ecode5 = 0 ;
51845 PyObject * obj0 = 0 ;
51846 PyObject * obj1 = 0 ;
51847 PyObject * obj2 = 0 ;
51848 PyObject * obj3 = 0 ;
51849 PyObject * obj4 = 0 ;
51850 PyObject * obj5 = 0 ;
51851 char * kwnames[] = {
51852 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51853 };
51854
51855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51857 if (!SWIG_IsOK(res1)) {
51858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51859 }
51860 arg1 = reinterpret_cast< wxSizer * >(argp1);
51861 arg2 = obj1;
51862 if (obj2) {
51863 ecode3 = SWIG_AsVal_int(obj2, &val3);
51864 if (!SWIG_IsOK(ecode3)) {
51865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51866 }
51867 arg3 = static_cast< int >(val3);
51868 }
51869 if (obj3) {
51870 ecode4 = SWIG_AsVal_int(obj3, &val4);
51871 if (!SWIG_IsOK(ecode4)) {
51872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51873 }
51874 arg4 = static_cast< int >(val4);
51875 }
51876 if (obj4) {
51877 ecode5 = SWIG_AsVal_int(obj4, &val5);
51878 if (!SWIG_IsOK(ecode5)) {
51879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51880 }
51881 arg5 = static_cast< int >(val5);
51882 }
51883 if (obj5) {
51884 arg6 = obj5;
51885 }
51886 {
51887 PyThreadState* __tstate = wxPyBeginAllowThreads();
51888 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51889 wxPyEndAllowThreads(__tstate);
51890 if (PyErr_Occurred()) SWIG_fail;
51891 }
51892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51893 return resultobj;
51894 fail:
51895 return NULL;
51896 }
51897
51898
51899 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51900 PyObject *resultobj = 0;
51901 wxSizer *arg1 = (wxSizer *) 0 ;
51902 PyObject *arg2 = (PyObject *) 0 ;
51903 wxSizerFlags *arg3 = 0 ;
51904 wxSizerItem *result = 0 ;
51905 void *argp1 = 0 ;
51906 int res1 = 0 ;
51907 void *argp3 = 0 ;
51908 int res3 = 0 ;
51909 PyObject * obj0 = 0 ;
51910 PyObject * obj1 = 0 ;
51911 PyObject * obj2 = 0 ;
51912 char * kwnames[] = {
51913 (char *) "self",(char *) "item",(char *) "flags", NULL
51914 };
51915
51916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51918 if (!SWIG_IsOK(res1)) {
51919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51920 }
51921 arg1 = reinterpret_cast< wxSizer * >(argp1);
51922 arg2 = obj1;
51923 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51924 if (!SWIG_IsOK(res3)) {
51925 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51926 }
51927 if (!argp3) {
51928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51929 }
51930 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51931 {
51932 PyThreadState* __tstate = wxPyBeginAllowThreads();
51933 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51934 wxPyEndAllowThreads(__tstate);
51935 if (PyErr_Occurred()) SWIG_fail;
51936 }
51937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51938 return resultobj;
51939 fail:
51940 return NULL;
51941 }
51942
51943
51944 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51945 PyObject *resultobj = 0;
51946 wxSizer *arg1 = (wxSizer *) 0 ;
51947 PyObject *arg2 = (PyObject *) 0 ;
51948 bool result;
51949 void *argp1 = 0 ;
51950 int res1 = 0 ;
51951 PyObject * obj0 = 0 ;
51952 PyObject * obj1 = 0 ;
51953 char * kwnames[] = {
51954 (char *) "self",(char *) "item", NULL
51955 };
51956
51957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51959 if (!SWIG_IsOK(res1)) {
51960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51961 }
51962 arg1 = reinterpret_cast< wxSizer * >(argp1);
51963 arg2 = obj1;
51964 {
51965 PyThreadState* __tstate = wxPyBeginAllowThreads();
51966 result = (bool)wxSizer_Remove(arg1,arg2);
51967 wxPyEndAllowThreads(__tstate);
51968 if (PyErr_Occurred()) SWIG_fail;
51969 }
51970 {
51971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51972 }
51973 return resultobj;
51974 fail:
51975 return NULL;
51976 }
51977
51978
51979 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51980 PyObject *resultobj = 0;
51981 wxSizer *arg1 = (wxSizer *) 0 ;
51982 PyObject *arg2 = (PyObject *) 0 ;
51983 bool result;
51984 void *argp1 = 0 ;
51985 int res1 = 0 ;
51986 PyObject * obj0 = 0 ;
51987 PyObject * obj1 = 0 ;
51988 char * kwnames[] = {
51989 (char *) "self",(char *) "item", NULL
51990 };
51991
51992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51994 if (!SWIG_IsOK(res1)) {
51995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51996 }
51997 arg1 = reinterpret_cast< wxSizer * >(argp1);
51998 arg2 = obj1;
51999 {
52000 PyThreadState* __tstate = wxPyBeginAllowThreads();
52001 result = (bool)wxSizer_Detach(arg1,arg2);
52002 wxPyEndAllowThreads(__tstate);
52003 if (PyErr_Occurred()) SWIG_fail;
52004 }
52005 {
52006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52007 }
52008 return resultobj;
52009 fail:
52010 return NULL;
52011 }
52012
52013
52014 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52015 PyObject *resultobj = 0;
52016 wxSizer *arg1 = (wxSizer *) 0 ;
52017 PyObject *arg2 = (PyObject *) 0 ;
52018 bool arg3 = (bool) false ;
52019 wxSizerItem *result = 0 ;
52020 void *argp1 = 0 ;
52021 int res1 = 0 ;
52022 bool val3 ;
52023 int ecode3 = 0 ;
52024 PyObject * obj0 = 0 ;
52025 PyObject * obj1 = 0 ;
52026 PyObject * obj2 = 0 ;
52027 char * kwnames[] = {
52028 (char *) "self",(char *) "item",(char *) "recursive", NULL
52029 };
52030
52031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52033 if (!SWIG_IsOK(res1)) {
52034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52035 }
52036 arg1 = reinterpret_cast< wxSizer * >(argp1);
52037 arg2 = obj1;
52038 if (obj2) {
52039 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52040 if (!SWIG_IsOK(ecode3)) {
52041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
52042 }
52043 arg3 = static_cast< bool >(val3);
52044 }
52045 {
52046 PyThreadState* __tstate = wxPyBeginAllowThreads();
52047 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
52048 wxPyEndAllowThreads(__tstate);
52049 if (PyErr_Occurred()) SWIG_fail;
52050 }
52051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52052 return resultobj;
52053 fail:
52054 return NULL;
52055 }
52056
52057
52058 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52059 PyObject *resultobj = 0;
52060 wxSizer *arg1 = (wxSizer *) 0 ;
52061 PyObject *arg2 = (PyObject *) 0 ;
52062 wxSize *arg3 = 0 ;
52063 void *argp1 = 0 ;
52064 int res1 = 0 ;
52065 wxSize temp3 ;
52066 PyObject * obj0 = 0 ;
52067 PyObject * obj1 = 0 ;
52068 PyObject * obj2 = 0 ;
52069 char * kwnames[] = {
52070 (char *) "self",(char *) "item",(char *) "size", NULL
52071 };
52072
52073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52075 if (!SWIG_IsOK(res1)) {
52076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52077 }
52078 arg1 = reinterpret_cast< wxSizer * >(argp1);
52079 arg2 = obj1;
52080 {
52081 arg3 = &temp3;
52082 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
52083 }
52084 {
52085 PyThreadState* __tstate = wxPyBeginAllowThreads();
52086 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
52087 wxPyEndAllowThreads(__tstate);
52088 if (PyErr_Occurred()) SWIG_fail;
52089 }
52090 resultobj = SWIG_Py_Void();
52091 return resultobj;
52092 fail:
52093 return NULL;
52094 }
52095
52096
52097 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52098 PyObject *resultobj = 0;
52099 wxSizer *arg1 = (wxSizer *) 0 ;
52100 wxWindow *arg2 = (wxWindow *) 0 ;
52101 wxWindow *arg3 = (wxWindow *) 0 ;
52102 bool arg4 = (bool) false ;
52103 bool result;
52104 void *argp1 = 0 ;
52105 int res1 = 0 ;
52106 void *argp2 = 0 ;
52107 int res2 = 0 ;
52108 void *argp3 = 0 ;
52109 int res3 = 0 ;
52110 bool val4 ;
52111 int ecode4 = 0 ;
52112 PyObject * obj0 = 0 ;
52113 PyObject * obj1 = 0 ;
52114 PyObject * obj2 = 0 ;
52115 PyObject * obj3 = 0 ;
52116 char * kwnames[] = {
52117 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
52118 };
52119
52120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52122 if (!SWIG_IsOK(res1)) {
52123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
52124 }
52125 arg1 = reinterpret_cast< wxSizer * >(argp1);
52126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52127 if (!SWIG_IsOK(res2)) {
52128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52129 }
52130 arg2 = reinterpret_cast< wxWindow * >(argp2);
52131 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52132 if (!SWIG_IsOK(res3)) {
52133 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
52134 }
52135 arg3 = reinterpret_cast< wxWindow * >(argp3);
52136 if (obj3) {
52137 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52138 if (!SWIG_IsOK(ecode4)) {
52139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
52140 }
52141 arg4 = static_cast< bool >(val4);
52142 }
52143 {
52144 PyThreadState* __tstate = wxPyBeginAllowThreads();
52145 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52146 wxPyEndAllowThreads(__tstate);
52147 if (PyErr_Occurred()) SWIG_fail;
52148 }
52149 {
52150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52151 }
52152 return resultobj;
52153 fail:
52154 return NULL;
52155 }
52156
52157
52158 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52159 PyObject *resultobj = 0;
52160 wxSizer *arg1 = (wxSizer *) 0 ;
52161 wxSizer *arg2 = (wxSizer *) 0 ;
52162 wxSizer *arg3 = (wxSizer *) 0 ;
52163 bool arg4 = (bool) false ;
52164 bool result;
52165 void *argp1 = 0 ;
52166 int res1 = 0 ;
52167 void *argp2 = 0 ;
52168 int res2 = 0 ;
52169 void *argp3 = 0 ;
52170 int res3 = 0 ;
52171 bool val4 ;
52172 int ecode4 = 0 ;
52173 PyObject * obj0 = 0 ;
52174 PyObject * obj1 = 0 ;
52175 PyObject * obj2 = 0 ;
52176 PyObject * obj3 = 0 ;
52177 char * kwnames[] = {
52178 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
52179 };
52180
52181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52183 if (!SWIG_IsOK(res1)) {
52184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
52185 }
52186 arg1 = reinterpret_cast< wxSizer * >(argp1);
52187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52188 if (!SWIG_IsOK(res2)) {
52189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
52190 }
52191 arg2 = reinterpret_cast< wxSizer * >(argp2);
52192 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
52193 if (!SWIG_IsOK(res3)) {
52194 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
52195 }
52196 arg3 = reinterpret_cast< wxSizer * >(argp3);
52197 if (obj3) {
52198 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52199 if (!SWIG_IsOK(ecode4)) {
52200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
52201 }
52202 arg4 = static_cast< bool >(val4);
52203 }
52204 {
52205 PyThreadState* __tstate = wxPyBeginAllowThreads();
52206 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52207 wxPyEndAllowThreads(__tstate);
52208 if (PyErr_Occurred()) SWIG_fail;
52209 }
52210 {
52211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52212 }
52213 return resultobj;
52214 fail:
52215 return NULL;
52216 }
52217
52218
52219 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52220 PyObject *resultobj = 0;
52221 wxSizer *arg1 = (wxSizer *) 0 ;
52222 size_t arg2 ;
52223 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52224 bool result;
52225 void *argp1 = 0 ;
52226 int res1 = 0 ;
52227 size_t val2 ;
52228 int ecode2 = 0 ;
52229 void *argp3 = 0 ;
52230 int res3 = 0 ;
52231 PyObject * obj0 = 0 ;
52232 PyObject * obj1 = 0 ;
52233 PyObject * obj2 = 0 ;
52234 char * kwnames[] = {
52235 (char *) "self",(char *) "index",(char *) "newitem", NULL
52236 };
52237
52238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52240 if (!SWIG_IsOK(res1)) {
52241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52242 }
52243 arg1 = reinterpret_cast< wxSizer * >(argp1);
52244 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52245 if (!SWIG_IsOK(ecode2)) {
52246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
52247 }
52248 arg2 = static_cast< size_t >(val2);
52249 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
52250 if (!SWIG_IsOK(res3)) {
52251 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52252 }
52253 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
52254 {
52255 PyThreadState* __tstate = wxPyBeginAllowThreads();
52256 result = (bool)(arg1)->Replace(arg2,arg3);
52257 wxPyEndAllowThreads(__tstate);
52258 if (PyErr_Occurred()) SWIG_fail;
52259 }
52260 {
52261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52262 }
52263 return resultobj;
52264 fail:
52265 return NULL;
52266 }
52267
52268
52269 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52270 PyObject *resultobj = 0;
52271 wxSizer *arg1 = (wxSizer *) 0 ;
52272 wxWindow *arg2 = (wxWindow *) 0 ;
52273 void *argp1 = 0 ;
52274 int res1 = 0 ;
52275 void *argp2 = 0 ;
52276 int res2 = 0 ;
52277 PyObject * obj0 = 0 ;
52278 PyObject * obj1 = 0 ;
52279 char * kwnames[] = {
52280 (char *) "self",(char *) "window", NULL
52281 };
52282
52283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
52284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52285 if (!SWIG_IsOK(res1)) {
52286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
52287 }
52288 arg1 = reinterpret_cast< wxSizer * >(argp1);
52289 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52290 if (!SWIG_IsOK(res2)) {
52291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
52292 }
52293 arg2 = reinterpret_cast< wxWindow * >(argp2);
52294 {
52295 PyThreadState* __tstate = wxPyBeginAllowThreads();
52296 (arg1)->SetContainingWindow(arg2);
52297 wxPyEndAllowThreads(__tstate);
52298 if (PyErr_Occurred()) SWIG_fail;
52299 }
52300 resultobj = SWIG_Py_Void();
52301 return resultobj;
52302 fail:
52303 return NULL;
52304 }
52305
52306
52307 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52308 PyObject *resultobj = 0;
52309 wxSizer *arg1 = (wxSizer *) 0 ;
52310 wxWindow *result = 0 ;
52311 void *argp1 = 0 ;
52312 int res1 = 0 ;
52313 PyObject *swig_obj[1] ;
52314
52315 if (!args) SWIG_fail;
52316 swig_obj[0] = args;
52317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52318 if (!SWIG_IsOK(res1)) {
52319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
52320 }
52321 arg1 = reinterpret_cast< wxSizer * >(argp1);
52322 {
52323 PyThreadState* __tstate = wxPyBeginAllowThreads();
52324 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
52325 wxPyEndAllowThreads(__tstate);
52326 if (PyErr_Occurred()) SWIG_fail;
52327 }
52328 {
52329 resultobj = wxPyMake_wxObject(result, 0);
52330 }
52331 return resultobj;
52332 fail:
52333 return NULL;
52334 }
52335
52336
52337 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52338 PyObject *resultobj = 0;
52339 wxSizer *arg1 = (wxSizer *) 0 ;
52340 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52341 wxSizerItem *result = 0 ;
52342 void *argp1 = 0 ;
52343 int res1 = 0 ;
52344 int res2 = 0 ;
52345 PyObject * obj0 = 0 ;
52346 PyObject * obj1 = 0 ;
52347 char * kwnames[] = {
52348 (char *) "self",(char *) "item", NULL
52349 };
52350
52351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
52352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52353 if (!SWIG_IsOK(res1)) {
52354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52355 }
52356 arg1 = reinterpret_cast< wxSizer * >(argp1);
52357 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52358 if (!SWIG_IsOK(res2)) {
52359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52360 }
52361 {
52362 PyThreadState* __tstate = wxPyBeginAllowThreads();
52363 result = (wxSizerItem *)(arg1)->Add(arg2);
52364 wxPyEndAllowThreads(__tstate);
52365 if (PyErr_Occurred()) SWIG_fail;
52366 }
52367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52368 return resultobj;
52369 fail:
52370 return NULL;
52371 }
52372
52373
52374 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52375 PyObject *resultobj = 0;
52376 wxSizer *arg1 = (wxSizer *) 0 ;
52377 size_t arg2 ;
52378 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52379 wxSizerItem *result = 0 ;
52380 void *argp1 = 0 ;
52381 int res1 = 0 ;
52382 size_t val2 ;
52383 int ecode2 = 0 ;
52384 int res3 = 0 ;
52385 PyObject * obj0 = 0 ;
52386 PyObject * obj1 = 0 ;
52387 PyObject * obj2 = 0 ;
52388 char * kwnames[] = {
52389 (char *) "self",(char *) "index",(char *) "item", NULL
52390 };
52391
52392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52394 if (!SWIG_IsOK(res1)) {
52395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52396 }
52397 arg1 = reinterpret_cast< wxSizer * >(argp1);
52398 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52399 if (!SWIG_IsOK(ecode2)) {
52400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
52401 }
52402 arg2 = static_cast< size_t >(val2);
52403 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52404 if (!SWIG_IsOK(res3)) {
52405 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52406 }
52407 {
52408 PyThreadState* __tstate = wxPyBeginAllowThreads();
52409 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
52410 wxPyEndAllowThreads(__tstate);
52411 if (PyErr_Occurred()) SWIG_fail;
52412 }
52413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52414 return resultobj;
52415 fail:
52416 return NULL;
52417 }
52418
52419
52420 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52421 PyObject *resultobj = 0;
52422 wxSizer *arg1 = (wxSizer *) 0 ;
52423 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52424 wxSizerItem *result = 0 ;
52425 void *argp1 = 0 ;
52426 int res1 = 0 ;
52427 int res2 = 0 ;
52428 PyObject * obj0 = 0 ;
52429 PyObject * obj1 = 0 ;
52430 char * kwnames[] = {
52431 (char *) "self",(char *) "item", NULL
52432 };
52433
52434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
52435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52436 if (!SWIG_IsOK(res1)) {
52437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52438 }
52439 arg1 = reinterpret_cast< wxSizer * >(argp1);
52440 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52441 if (!SWIG_IsOK(res2)) {
52442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52443 }
52444 {
52445 PyThreadState* __tstate = wxPyBeginAllowThreads();
52446 result = (wxSizerItem *)(arg1)->Prepend(arg2);
52447 wxPyEndAllowThreads(__tstate);
52448 if (PyErr_Occurred()) SWIG_fail;
52449 }
52450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52451 return resultobj;
52452 fail:
52453 return NULL;
52454 }
52455
52456
52457 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52458 PyObject *resultobj = 0;
52459 wxSizer *arg1 = (wxSizer *) 0 ;
52460 int arg2 ;
52461 int arg3 ;
52462 int arg4 ;
52463 int arg5 ;
52464 void *argp1 = 0 ;
52465 int res1 = 0 ;
52466 int val2 ;
52467 int ecode2 = 0 ;
52468 int val3 ;
52469 int ecode3 = 0 ;
52470 int val4 ;
52471 int ecode4 = 0 ;
52472 int val5 ;
52473 int ecode5 = 0 ;
52474 PyObject * obj0 = 0 ;
52475 PyObject * obj1 = 0 ;
52476 PyObject * obj2 = 0 ;
52477 PyObject * obj3 = 0 ;
52478 PyObject * obj4 = 0 ;
52479 char * kwnames[] = {
52480 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
52481 };
52482
52483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
52484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52485 if (!SWIG_IsOK(res1)) {
52486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
52487 }
52488 arg1 = reinterpret_cast< wxSizer * >(argp1);
52489 ecode2 = SWIG_AsVal_int(obj1, &val2);
52490 if (!SWIG_IsOK(ecode2)) {
52491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
52492 }
52493 arg2 = static_cast< int >(val2);
52494 ecode3 = SWIG_AsVal_int(obj2, &val3);
52495 if (!SWIG_IsOK(ecode3)) {
52496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
52497 }
52498 arg3 = static_cast< int >(val3);
52499 ecode4 = SWIG_AsVal_int(obj3, &val4);
52500 if (!SWIG_IsOK(ecode4)) {
52501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52502 }
52503 arg4 = static_cast< int >(val4);
52504 ecode5 = SWIG_AsVal_int(obj4, &val5);
52505 if (!SWIG_IsOK(ecode5)) {
52506 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52507 }
52508 arg5 = static_cast< int >(val5);
52509 {
52510 PyThreadState* __tstate = wxPyBeginAllowThreads();
52511 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52512 wxPyEndAllowThreads(__tstate);
52513 if (PyErr_Occurred()) SWIG_fail;
52514 }
52515 resultobj = SWIG_Py_Void();
52516 return resultobj;
52517 fail:
52518 return NULL;
52519 }
52520
52521
52522 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52523 PyObject *resultobj = 0;
52524 wxSizer *arg1 = (wxSizer *) 0 ;
52525 wxSize *arg2 = 0 ;
52526 void *argp1 = 0 ;
52527 int res1 = 0 ;
52528 wxSize temp2 ;
52529 PyObject * obj0 = 0 ;
52530 PyObject * obj1 = 0 ;
52531 char * kwnames[] = {
52532 (char *) "self",(char *) "size", NULL
52533 };
52534
52535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52537 if (!SWIG_IsOK(res1)) {
52538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52539 }
52540 arg1 = reinterpret_cast< wxSizer * >(argp1);
52541 {
52542 arg2 = &temp2;
52543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52544 }
52545 {
52546 PyThreadState* __tstate = wxPyBeginAllowThreads();
52547 (arg1)->SetMinSize((wxSize const &)*arg2);
52548 wxPyEndAllowThreads(__tstate);
52549 if (PyErr_Occurred()) SWIG_fail;
52550 }
52551 resultobj = SWIG_Py_Void();
52552 return resultobj;
52553 fail:
52554 return NULL;
52555 }
52556
52557
52558 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52559 PyObject *resultobj = 0;
52560 wxSizer *arg1 = (wxSizer *) 0 ;
52561 wxSize result;
52562 void *argp1 = 0 ;
52563 int res1 = 0 ;
52564 PyObject *swig_obj[1] ;
52565
52566 if (!args) SWIG_fail;
52567 swig_obj[0] = args;
52568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52569 if (!SWIG_IsOK(res1)) {
52570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52571 }
52572 arg1 = reinterpret_cast< wxSizer * >(argp1);
52573 {
52574 PyThreadState* __tstate = wxPyBeginAllowThreads();
52575 result = (arg1)->GetSize();
52576 wxPyEndAllowThreads(__tstate);
52577 if (PyErr_Occurred()) SWIG_fail;
52578 }
52579 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52580 return resultobj;
52581 fail:
52582 return NULL;
52583 }
52584
52585
52586 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52587 PyObject *resultobj = 0;
52588 wxSizer *arg1 = (wxSizer *) 0 ;
52589 wxPoint result;
52590 void *argp1 = 0 ;
52591 int res1 = 0 ;
52592 PyObject *swig_obj[1] ;
52593
52594 if (!args) SWIG_fail;
52595 swig_obj[0] = args;
52596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52597 if (!SWIG_IsOK(res1)) {
52598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52599 }
52600 arg1 = reinterpret_cast< wxSizer * >(argp1);
52601 {
52602 PyThreadState* __tstate = wxPyBeginAllowThreads();
52603 result = (arg1)->GetPosition();
52604 wxPyEndAllowThreads(__tstate);
52605 if (PyErr_Occurred()) SWIG_fail;
52606 }
52607 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52608 return resultobj;
52609 fail:
52610 return NULL;
52611 }
52612
52613
52614 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52615 PyObject *resultobj = 0;
52616 wxSizer *arg1 = (wxSizer *) 0 ;
52617 wxSize result;
52618 void *argp1 = 0 ;
52619 int res1 = 0 ;
52620 PyObject *swig_obj[1] ;
52621
52622 if (!args) SWIG_fail;
52623 swig_obj[0] = args;
52624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52625 if (!SWIG_IsOK(res1)) {
52626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52627 }
52628 arg1 = reinterpret_cast< wxSizer * >(argp1);
52629 {
52630 PyThreadState* __tstate = wxPyBeginAllowThreads();
52631 result = (arg1)->GetMinSize();
52632 wxPyEndAllowThreads(__tstate);
52633 if (PyErr_Occurred()) SWIG_fail;
52634 }
52635 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52636 return resultobj;
52637 fail:
52638 return NULL;
52639 }
52640
52641
52642 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52643 PyObject *resultobj = 0;
52644 wxSizer *arg1 = (wxSizer *) 0 ;
52645 void *argp1 = 0 ;
52646 int res1 = 0 ;
52647 PyObject *swig_obj[1] ;
52648
52649 if (!args) SWIG_fail;
52650 swig_obj[0] = args;
52651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52652 if (!SWIG_IsOK(res1)) {
52653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52654 }
52655 arg1 = reinterpret_cast< wxSizer * >(argp1);
52656 {
52657 PyThreadState* __tstate = wxPyBeginAllowThreads();
52658 (arg1)->RecalcSizes();
52659 wxPyEndAllowThreads(__tstate);
52660 if (PyErr_Occurred()) SWIG_fail;
52661 }
52662 resultobj = SWIG_Py_Void();
52663 return resultobj;
52664 fail:
52665 return NULL;
52666 }
52667
52668
52669 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52670 PyObject *resultobj = 0;
52671 wxSizer *arg1 = (wxSizer *) 0 ;
52672 wxSize result;
52673 void *argp1 = 0 ;
52674 int res1 = 0 ;
52675 PyObject *swig_obj[1] ;
52676
52677 if (!args) SWIG_fail;
52678 swig_obj[0] = args;
52679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52680 if (!SWIG_IsOK(res1)) {
52681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52682 }
52683 arg1 = reinterpret_cast< wxSizer * >(argp1);
52684 {
52685 PyThreadState* __tstate = wxPyBeginAllowThreads();
52686 result = (arg1)->CalcMin();
52687 wxPyEndAllowThreads(__tstate);
52688 if (PyErr_Occurred()) SWIG_fail;
52689 }
52690 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52691 return resultobj;
52692 fail:
52693 return NULL;
52694 }
52695
52696
52697 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52698 PyObject *resultobj = 0;
52699 wxSizer *arg1 = (wxSizer *) 0 ;
52700 void *argp1 = 0 ;
52701 int res1 = 0 ;
52702 PyObject *swig_obj[1] ;
52703
52704 if (!args) SWIG_fail;
52705 swig_obj[0] = args;
52706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52707 if (!SWIG_IsOK(res1)) {
52708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52709 }
52710 arg1 = reinterpret_cast< wxSizer * >(argp1);
52711 {
52712 PyThreadState* __tstate = wxPyBeginAllowThreads();
52713 (arg1)->Layout();
52714 wxPyEndAllowThreads(__tstate);
52715 if (PyErr_Occurred()) SWIG_fail;
52716 }
52717 resultobj = SWIG_Py_Void();
52718 return resultobj;
52719 fail:
52720 return NULL;
52721 }
52722
52723
52724 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52725 PyObject *resultobj = 0;
52726 wxSizer *arg1 = (wxSizer *) 0 ;
52727 wxWindow *arg2 = (wxWindow *) 0 ;
52728 wxSize result;
52729 void *argp1 = 0 ;
52730 int res1 = 0 ;
52731 void *argp2 = 0 ;
52732 int res2 = 0 ;
52733 PyObject * obj0 = 0 ;
52734 PyObject * obj1 = 0 ;
52735 char * kwnames[] = {
52736 (char *) "self",(char *) "window", NULL
52737 };
52738
52739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52741 if (!SWIG_IsOK(res1)) {
52742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52743 }
52744 arg1 = reinterpret_cast< wxSizer * >(argp1);
52745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52746 if (!SWIG_IsOK(res2)) {
52747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52748 }
52749 arg2 = reinterpret_cast< wxWindow * >(argp2);
52750 {
52751 PyThreadState* __tstate = wxPyBeginAllowThreads();
52752 result = (arg1)->Fit(arg2);
52753 wxPyEndAllowThreads(__tstate);
52754 if (PyErr_Occurred()) SWIG_fail;
52755 }
52756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52757 return resultobj;
52758 fail:
52759 return NULL;
52760 }
52761
52762
52763 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52764 PyObject *resultobj = 0;
52765 wxSizer *arg1 = (wxSizer *) 0 ;
52766 wxWindow *arg2 = (wxWindow *) 0 ;
52767 void *argp1 = 0 ;
52768 int res1 = 0 ;
52769 void *argp2 = 0 ;
52770 int res2 = 0 ;
52771 PyObject * obj0 = 0 ;
52772 PyObject * obj1 = 0 ;
52773 char * kwnames[] = {
52774 (char *) "self",(char *) "window", NULL
52775 };
52776
52777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52779 if (!SWIG_IsOK(res1)) {
52780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52781 }
52782 arg1 = reinterpret_cast< wxSizer * >(argp1);
52783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52784 if (!SWIG_IsOK(res2)) {
52785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52786 }
52787 arg2 = reinterpret_cast< wxWindow * >(argp2);
52788 {
52789 PyThreadState* __tstate = wxPyBeginAllowThreads();
52790 (arg1)->FitInside(arg2);
52791 wxPyEndAllowThreads(__tstate);
52792 if (PyErr_Occurred()) SWIG_fail;
52793 }
52794 resultobj = SWIG_Py_Void();
52795 return resultobj;
52796 fail:
52797 return NULL;
52798 }
52799
52800
52801 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52802 PyObject *resultobj = 0;
52803 wxSizer *arg1 = (wxSizer *) 0 ;
52804 wxWindow *arg2 = (wxWindow *) 0 ;
52805 void *argp1 = 0 ;
52806 int res1 = 0 ;
52807 void *argp2 = 0 ;
52808 int res2 = 0 ;
52809 PyObject * obj0 = 0 ;
52810 PyObject * obj1 = 0 ;
52811 char * kwnames[] = {
52812 (char *) "self",(char *) "window", NULL
52813 };
52814
52815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52817 if (!SWIG_IsOK(res1)) {
52818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52819 }
52820 arg1 = reinterpret_cast< wxSizer * >(argp1);
52821 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52822 if (!SWIG_IsOK(res2)) {
52823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52824 }
52825 arg2 = reinterpret_cast< wxWindow * >(argp2);
52826 {
52827 PyThreadState* __tstate = wxPyBeginAllowThreads();
52828 (arg1)->SetSizeHints(arg2);
52829 wxPyEndAllowThreads(__tstate);
52830 if (PyErr_Occurred()) SWIG_fail;
52831 }
52832 resultobj = SWIG_Py_Void();
52833 return resultobj;
52834 fail:
52835 return NULL;
52836 }
52837
52838
52839 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52840 PyObject *resultobj = 0;
52841 wxSizer *arg1 = (wxSizer *) 0 ;
52842 wxWindow *arg2 = (wxWindow *) 0 ;
52843 void *argp1 = 0 ;
52844 int res1 = 0 ;
52845 void *argp2 = 0 ;
52846 int res2 = 0 ;
52847 PyObject * obj0 = 0 ;
52848 PyObject * obj1 = 0 ;
52849 char * kwnames[] = {
52850 (char *) "self",(char *) "window", NULL
52851 };
52852
52853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52855 if (!SWIG_IsOK(res1)) {
52856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52857 }
52858 arg1 = reinterpret_cast< wxSizer * >(argp1);
52859 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52860 if (!SWIG_IsOK(res2)) {
52861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52862 }
52863 arg2 = reinterpret_cast< wxWindow * >(argp2);
52864 {
52865 PyThreadState* __tstate = wxPyBeginAllowThreads();
52866 (arg1)->SetVirtualSizeHints(arg2);
52867 wxPyEndAllowThreads(__tstate);
52868 if (PyErr_Occurred()) SWIG_fail;
52869 }
52870 resultobj = SWIG_Py_Void();
52871 return resultobj;
52872 fail:
52873 return NULL;
52874 }
52875
52876
52877 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52878 PyObject *resultobj = 0;
52879 wxSizer *arg1 = (wxSizer *) 0 ;
52880 bool arg2 = (bool) false ;
52881 void *argp1 = 0 ;
52882 int res1 = 0 ;
52883 bool val2 ;
52884 int ecode2 = 0 ;
52885 PyObject * obj0 = 0 ;
52886 PyObject * obj1 = 0 ;
52887 char * kwnames[] = {
52888 (char *) "self",(char *) "deleteWindows", NULL
52889 };
52890
52891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52893 if (!SWIG_IsOK(res1)) {
52894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52895 }
52896 arg1 = reinterpret_cast< wxSizer * >(argp1);
52897 if (obj1) {
52898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52899 if (!SWIG_IsOK(ecode2)) {
52900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52901 }
52902 arg2 = static_cast< bool >(val2);
52903 }
52904 {
52905 PyThreadState* __tstate = wxPyBeginAllowThreads();
52906 (arg1)->Clear(arg2);
52907 wxPyEndAllowThreads(__tstate);
52908 if (PyErr_Occurred()) SWIG_fail;
52909 }
52910 resultobj = SWIG_Py_Void();
52911 return resultobj;
52912 fail:
52913 return NULL;
52914 }
52915
52916
52917 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52918 PyObject *resultobj = 0;
52919 wxSizer *arg1 = (wxSizer *) 0 ;
52920 void *argp1 = 0 ;
52921 int res1 = 0 ;
52922 PyObject *swig_obj[1] ;
52923
52924 if (!args) SWIG_fail;
52925 swig_obj[0] = args;
52926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52927 if (!SWIG_IsOK(res1)) {
52928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52929 }
52930 arg1 = reinterpret_cast< wxSizer * >(argp1);
52931 {
52932 PyThreadState* __tstate = wxPyBeginAllowThreads();
52933 (arg1)->DeleteWindows();
52934 wxPyEndAllowThreads(__tstate);
52935 if (PyErr_Occurred()) SWIG_fail;
52936 }
52937 resultobj = SWIG_Py_Void();
52938 return resultobj;
52939 fail:
52940 return NULL;
52941 }
52942
52943
52944 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52945 PyObject *resultobj = 0;
52946 wxSizer *arg1 = (wxSizer *) 0 ;
52947 PyObject *result = 0 ;
52948 void *argp1 = 0 ;
52949 int res1 = 0 ;
52950 PyObject *swig_obj[1] ;
52951
52952 if (!args) SWIG_fail;
52953 swig_obj[0] = args;
52954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52955 if (!SWIG_IsOK(res1)) {
52956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52957 }
52958 arg1 = reinterpret_cast< wxSizer * >(argp1);
52959 {
52960 PyThreadState* __tstate = wxPyBeginAllowThreads();
52961 result = (PyObject *)wxSizer_GetChildren(arg1);
52962 wxPyEndAllowThreads(__tstate);
52963 if (PyErr_Occurred()) SWIG_fail;
52964 }
52965 resultobj = result;
52966 return resultobj;
52967 fail:
52968 return NULL;
52969 }
52970
52971
52972 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52973 PyObject *resultobj = 0;
52974 wxSizer *arg1 = (wxSizer *) 0 ;
52975 PyObject *arg2 = (PyObject *) 0 ;
52976 bool arg3 = (bool) true ;
52977 bool arg4 = (bool) false ;
52978 bool result;
52979 void *argp1 = 0 ;
52980 int res1 = 0 ;
52981 bool val3 ;
52982 int ecode3 = 0 ;
52983 bool val4 ;
52984 int ecode4 = 0 ;
52985 PyObject * obj0 = 0 ;
52986 PyObject * obj1 = 0 ;
52987 PyObject * obj2 = 0 ;
52988 PyObject * obj3 = 0 ;
52989 char * kwnames[] = {
52990 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52991 };
52992
52993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52995 if (!SWIG_IsOK(res1)) {
52996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52997 }
52998 arg1 = reinterpret_cast< wxSizer * >(argp1);
52999 arg2 = obj1;
53000 if (obj2) {
53001 ecode3 = SWIG_AsVal_bool(obj2, &val3);
53002 if (!SWIG_IsOK(ecode3)) {
53003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
53004 }
53005 arg3 = static_cast< bool >(val3);
53006 }
53007 if (obj3) {
53008 ecode4 = SWIG_AsVal_bool(obj3, &val4);
53009 if (!SWIG_IsOK(ecode4)) {
53010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
53011 }
53012 arg4 = static_cast< bool >(val4);
53013 }
53014 {
53015 PyThreadState* __tstate = wxPyBeginAllowThreads();
53016 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
53017 wxPyEndAllowThreads(__tstate);
53018 if (PyErr_Occurred()) SWIG_fail;
53019 }
53020 {
53021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53022 }
53023 return resultobj;
53024 fail:
53025 return NULL;
53026 }
53027
53028
53029 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53030 PyObject *resultobj = 0;
53031 wxSizer *arg1 = (wxSizer *) 0 ;
53032 PyObject *arg2 = (PyObject *) 0 ;
53033 bool result;
53034 void *argp1 = 0 ;
53035 int res1 = 0 ;
53036 PyObject * obj0 = 0 ;
53037 PyObject * obj1 = 0 ;
53038 char * kwnames[] = {
53039 (char *) "self",(char *) "item", NULL
53040 };
53041
53042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
53043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53044 if (!SWIG_IsOK(res1)) {
53045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
53046 }
53047 arg1 = reinterpret_cast< wxSizer * >(argp1);
53048 arg2 = obj1;
53049 {
53050 PyThreadState* __tstate = wxPyBeginAllowThreads();
53051 result = (bool)wxSizer_IsShown(arg1,arg2);
53052 wxPyEndAllowThreads(__tstate);
53053 if (PyErr_Occurred()) SWIG_fail;
53054 }
53055 {
53056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53057 }
53058 return resultobj;
53059 fail:
53060 return NULL;
53061 }
53062
53063
53064 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53065 PyObject *resultobj = 0;
53066 wxSizer *arg1 = (wxSizer *) 0 ;
53067 bool arg2 ;
53068 void *argp1 = 0 ;
53069 int res1 = 0 ;
53070 bool val2 ;
53071 int ecode2 = 0 ;
53072 PyObject * obj0 = 0 ;
53073 PyObject * obj1 = 0 ;
53074 char * kwnames[] = {
53075 (char *) "self",(char *) "show", NULL
53076 };
53077
53078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
53079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53080 if (!SWIG_IsOK(res1)) {
53081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
53082 }
53083 arg1 = reinterpret_cast< wxSizer * >(argp1);
53084 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53085 if (!SWIG_IsOK(ecode2)) {
53086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
53087 }
53088 arg2 = static_cast< bool >(val2);
53089 {
53090 PyThreadState* __tstate = wxPyBeginAllowThreads();
53091 (arg1)->ShowItems(arg2);
53092 wxPyEndAllowThreads(__tstate);
53093 if (PyErr_Occurred()) SWIG_fail;
53094 }
53095 resultobj = SWIG_Py_Void();
53096 return resultobj;
53097 fail:
53098 return NULL;
53099 }
53100
53101
53102 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53103 PyObject *obj;
53104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53105 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
53106 return SWIG_Py_Void();
53107 }
53108
53109 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53110 PyObject *resultobj = 0;
53111 wxPySizer *result = 0 ;
53112
53113 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
53114 {
53115 PyThreadState* __tstate = wxPyBeginAllowThreads();
53116 result = (wxPySizer *)new wxPySizer();
53117 wxPyEndAllowThreads(__tstate);
53118 if (PyErr_Occurred()) SWIG_fail;
53119 }
53120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
53121 return resultobj;
53122 fail:
53123 return NULL;
53124 }
53125
53126
53127 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53128 PyObject *resultobj = 0;
53129 wxPySizer *arg1 = (wxPySizer *) 0 ;
53130 PyObject *arg2 = (PyObject *) 0 ;
53131 PyObject *arg3 = (PyObject *) 0 ;
53132 void *argp1 = 0 ;
53133 int res1 = 0 ;
53134 PyObject * obj0 = 0 ;
53135 PyObject * obj1 = 0 ;
53136 PyObject * obj2 = 0 ;
53137 char * kwnames[] = {
53138 (char *) "self",(char *) "self",(char *) "_class", NULL
53139 };
53140
53141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
53143 if (!SWIG_IsOK(res1)) {
53144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
53145 }
53146 arg1 = reinterpret_cast< wxPySizer * >(argp1);
53147 arg2 = obj1;
53148 arg3 = obj2;
53149 {
53150 PyThreadState* __tstate = wxPyBeginAllowThreads();
53151 (arg1)->_setCallbackInfo(arg2,arg3);
53152 wxPyEndAllowThreads(__tstate);
53153 if (PyErr_Occurred()) SWIG_fail;
53154 }
53155 resultobj = SWIG_Py_Void();
53156 return resultobj;
53157 fail:
53158 return NULL;
53159 }
53160
53161
53162 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53163 PyObject *obj;
53164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53165 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
53166 return SWIG_Py_Void();
53167 }
53168
53169 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53170 return SWIG_Python_InitShadowInstance(args);
53171 }
53172
53173 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53174 PyObject *resultobj = 0;
53175 int arg1 = (int) wxHORIZONTAL ;
53176 wxBoxSizer *result = 0 ;
53177 int val1 ;
53178 int ecode1 = 0 ;
53179 PyObject * obj0 = 0 ;
53180 char * kwnames[] = {
53181 (char *) "orient", NULL
53182 };
53183
53184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
53185 if (obj0) {
53186 ecode1 = SWIG_AsVal_int(obj0, &val1);
53187 if (!SWIG_IsOK(ecode1)) {
53188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
53189 }
53190 arg1 = static_cast< int >(val1);
53191 }
53192 {
53193 PyThreadState* __tstate = wxPyBeginAllowThreads();
53194 result = (wxBoxSizer *)new wxBoxSizer(arg1);
53195 wxPyEndAllowThreads(__tstate);
53196 if (PyErr_Occurred()) SWIG_fail;
53197 }
53198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
53199 return resultobj;
53200 fail:
53201 return NULL;
53202 }
53203
53204
53205 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53206 PyObject *resultobj = 0;
53207 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53208 int result;
53209 void *argp1 = 0 ;
53210 int res1 = 0 ;
53211 PyObject *swig_obj[1] ;
53212
53213 if (!args) SWIG_fail;
53214 swig_obj[0] = args;
53215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53216 if (!SWIG_IsOK(res1)) {
53217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53218 }
53219 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53220 {
53221 PyThreadState* __tstate = wxPyBeginAllowThreads();
53222 result = (int)(arg1)->GetOrientation();
53223 wxPyEndAllowThreads(__tstate);
53224 if (PyErr_Occurred()) SWIG_fail;
53225 }
53226 resultobj = SWIG_From_int(static_cast< int >(result));
53227 return resultobj;
53228 fail:
53229 return NULL;
53230 }
53231
53232
53233 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53234 PyObject *resultobj = 0;
53235 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53236 int arg2 ;
53237 void *argp1 = 0 ;
53238 int res1 = 0 ;
53239 int val2 ;
53240 int ecode2 = 0 ;
53241 PyObject * obj0 = 0 ;
53242 PyObject * obj1 = 0 ;
53243 char * kwnames[] = {
53244 (char *) "self",(char *) "orient", NULL
53245 };
53246
53247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
53248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53249 if (!SWIG_IsOK(res1)) {
53250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53251 }
53252 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53253 ecode2 = SWIG_AsVal_int(obj1, &val2);
53254 if (!SWIG_IsOK(ecode2)) {
53255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
53256 }
53257 arg2 = static_cast< int >(val2);
53258 {
53259 PyThreadState* __tstate = wxPyBeginAllowThreads();
53260 (arg1)->SetOrientation(arg2);
53261 wxPyEndAllowThreads(__tstate);
53262 if (PyErr_Occurred()) SWIG_fail;
53263 }
53264 resultobj = SWIG_Py_Void();
53265 return resultobj;
53266 fail:
53267 return NULL;
53268 }
53269
53270
53271 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53272 PyObject *obj;
53273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53274 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
53275 return SWIG_Py_Void();
53276 }
53277
53278 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53279 return SWIG_Python_InitShadowInstance(args);
53280 }
53281
53282 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53283 PyObject *resultobj = 0;
53284 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
53285 int arg2 = (int) wxHORIZONTAL ;
53286 wxStaticBoxSizer *result = 0 ;
53287 void *argp1 = 0 ;
53288 int res1 = 0 ;
53289 int val2 ;
53290 int ecode2 = 0 ;
53291 PyObject * obj0 = 0 ;
53292 PyObject * obj1 = 0 ;
53293 char * kwnames[] = {
53294 (char *) "box",(char *) "orient", NULL
53295 };
53296
53297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
53299 if (!SWIG_IsOK(res1)) {
53300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
53301 }
53302 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
53303 if (obj1) {
53304 ecode2 = SWIG_AsVal_int(obj1, &val2);
53305 if (!SWIG_IsOK(ecode2)) {
53306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
53307 }
53308 arg2 = static_cast< int >(val2);
53309 }
53310 {
53311 PyThreadState* __tstate = wxPyBeginAllowThreads();
53312 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
53313 wxPyEndAllowThreads(__tstate);
53314 if (PyErr_Occurred()) SWIG_fail;
53315 }
53316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
53317 return resultobj;
53318 fail:
53319 return NULL;
53320 }
53321
53322
53323 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53324 PyObject *resultobj = 0;
53325 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
53326 wxStaticBox *result = 0 ;
53327 void *argp1 = 0 ;
53328 int res1 = 0 ;
53329 PyObject *swig_obj[1] ;
53330
53331 if (!args) SWIG_fail;
53332 swig_obj[0] = args;
53333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
53334 if (!SWIG_IsOK(res1)) {
53335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
53336 }
53337 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
53338 {
53339 PyThreadState* __tstate = wxPyBeginAllowThreads();
53340 result = (wxStaticBox *)(arg1)->GetStaticBox();
53341 wxPyEndAllowThreads(__tstate);
53342 if (PyErr_Occurred()) SWIG_fail;
53343 }
53344 {
53345 resultobj = wxPyMake_wxObject(result, (bool)0);
53346 }
53347 return resultobj;
53348 fail:
53349 return NULL;
53350 }
53351
53352
53353 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53354 PyObject *obj;
53355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53356 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
53357 return SWIG_Py_Void();
53358 }
53359
53360 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53361 return SWIG_Python_InitShadowInstance(args);
53362 }
53363
53364 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53365 PyObject *resultobj = 0;
53366 int arg1 = (int) 1 ;
53367 int arg2 = (int) 0 ;
53368 int arg3 = (int) 0 ;
53369 int arg4 = (int) 0 ;
53370 wxGridSizer *result = 0 ;
53371 int val1 ;
53372 int ecode1 = 0 ;
53373 int val2 ;
53374 int ecode2 = 0 ;
53375 int val3 ;
53376 int ecode3 = 0 ;
53377 int val4 ;
53378 int ecode4 = 0 ;
53379 PyObject * obj0 = 0 ;
53380 PyObject * obj1 = 0 ;
53381 PyObject * obj2 = 0 ;
53382 PyObject * obj3 = 0 ;
53383 char * kwnames[] = {
53384 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53385 };
53386
53387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53388 if (obj0) {
53389 ecode1 = SWIG_AsVal_int(obj0, &val1);
53390 if (!SWIG_IsOK(ecode1)) {
53391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
53392 }
53393 arg1 = static_cast< int >(val1);
53394 }
53395 if (obj1) {
53396 ecode2 = SWIG_AsVal_int(obj1, &val2);
53397 if (!SWIG_IsOK(ecode2)) {
53398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
53399 }
53400 arg2 = static_cast< int >(val2);
53401 }
53402 if (obj2) {
53403 ecode3 = SWIG_AsVal_int(obj2, &val3);
53404 if (!SWIG_IsOK(ecode3)) {
53405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
53406 }
53407 arg3 = static_cast< int >(val3);
53408 }
53409 if (obj3) {
53410 ecode4 = SWIG_AsVal_int(obj3, &val4);
53411 if (!SWIG_IsOK(ecode4)) {
53412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
53413 }
53414 arg4 = static_cast< int >(val4);
53415 }
53416 {
53417 PyThreadState* __tstate = wxPyBeginAllowThreads();
53418 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
53419 wxPyEndAllowThreads(__tstate);
53420 if (PyErr_Occurred()) SWIG_fail;
53421 }
53422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
53423 return resultobj;
53424 fail:
53425 return NULL;
53426 }
53427
53428
53429 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53430 PyObject *resultobj = 0;
53431 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53432 int arg2 ;
53433 void *argp1 = 0 ;
53434 int res1 = 0 ;
53435 int val2 ;
53436 int ecode2 = 0 ;
53437 PyObject * obj0 = 0 ;
53438 PyObject * obj1 = 0 ;
53439 char * kwnames[] = {
53440 (char *) "self",(char *) "cols", NULL
53441 };
53442
53443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
53444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53445 if (!SWIG_IsOK(res1)) {
53446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53447 }
53448 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53449 ecode2 = SWIG_AsVal_int(obj1, &val2);
53450 if (!SWIG_IsOK(ecode2)) {
53451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
53452 }
53453 arg2 = static_cast< int >(val2);
53454 {
53455 PyThreadState* __tstate = wxPyBeginAllowThreads();
53456 (arg1)->SetCols(arg2);
53457 wxPyEndAllowThreads(__tstate);
53458 if (PyErr_Occurred()) SWIG_fail;
53459 }
53460 resultobj = SWIG_Py_Void();
53461 return resultobj;
53462 fail:
53463 return NULL;
53464 }
53465
53466
53467 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53468 PyObject *resultobj = 0;
53469 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53470 int arg2 ;
53471 void *argp1 = 0 ;
53472 int res1 = 0 ;
53473 int val2 ;
53474 int ecode2 = 0 ;
53475 PyObject * obj0 = 0 ;
53476 PyObject * obj1 = 0 ;
53477 char * kwnames[] = {
53478 (char *) "self",(char *) "rows", NULL
53479 };
53480
53481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
53482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53483 if (!SWIG_IsOK(res1)) {
53484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53485 }
53486 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53487 ecode2 = SWIG_AsVal_int(obj1, &val2);
53488 if (!SWIG_IsOK(ecode2)) {
53489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
53490 }
53491 arg2 = static_cast< int >(val2);
53492 {
53493 PyThreadState* __tstate = wxPyBeginAllowThreads();
53494 (arg1)->SetRows(arg2);
53495 wxPyEndAllowThreads(__tstate);
53496 if (PyErr_Occurred()) SWIG_fail;
53497 }
53498 resultobj = SWIG_Py_Void();
53499 return resultobj;
53500 fail:
53501 return NULL;
53502 }
53503
53504
53505 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53506 PyObject *resultobj = 0;
53507 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53508 int arg2 ;
53509 void *argp1 = 0 ;
53510 int res1 = 0 ;
53511 int val2 ;
53512 int ecode2 = 0 ;
53513 PyObject * obj0 = 0 ;
53514 PyObject * obj1 = 0 ;
53515 char * kwnames[] = {
53516 (char *) "self",(char *) "gap", NULL
53517 };
53518
53519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53521 if (!SWIG_IsOK(res1)) {
53522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53523 }
53524 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53525 ecode2 = SWIG_AsVal_int(obj1, &val2);
53526 if (!SWIG_IsOK(ecode2)) {
53527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53528 }
53529 arg2 = static_cast< int >(val2);
53530 {
53531 PyThreadState* __tstate = wxPyBeginAllowThreads();
53532 (arg1)->SetVGap(arg2);
53533 wxPyEndAllowThreads(__tstate);
53534 if (PyErr_Occurred()) SWIG_fail;
53535 }
53536 resultobj = SWIG_Py_Void();
53537 return resultobj;
53538 fail:
53539 return NULL;
53540 }
53541
53542
53543 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53544 PyObject *resultobj = 0;
53545 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53546 int arg2 ;
53547 void *argp1 = 0 ;
53548 int res1 = 0 ;
53549 int val2 ;
53550 int ecode2 = 0 ;
53551 PyObject * obj0 = 0 ;
53552 PyObject * obj1 = 0 ;
53553 char * kwnames[] = {
53554 (char *) "self",(char *) "gap", NULL
53555 };
53556
53557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53559 if (!SWIG_IsOK(res1)) {
53560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53561 }
53562 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53563 ecode2 = SWIG_AsVal_int(obj1, &val2);
53564 if (!SWIG_IsOK(ecode2)) {
53565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53566 }
53567 arg2 = static_cast< int >(val2);
53568 {
53569 PyThreadState* __tstate = wxPyBeginAllowThreads();
53570 (arg1)->SetHGap(arg2);
53571 wxPyEndAllowThreads(__tstate);
53572 if (PyErr_Occurred()) SWIG_fail;
53573 }
53574 resultobj = SWIG_Py_Void();
53575 return resultobj;
53576 fail:
53577 return NULL;
53578 }
53579
53580
53581 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53582 PyObject *resultobj = 0;
53583 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53584 int result;
53585 void *argp1 = 0 ;
53586 int res1 = 0 ;
53587 PyObject *swig_obj[1] ;
53588
53589 if (!args) SWIG_fail;
53590 swig_obj[0] = args;
53591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53592 if (!SWIG_IsOK(res1)) {
53593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53594 }
53595 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53596 {
53597 PyThreadState* __tstate = wxPyBeginAllowThreads();
53598 result = (int)(arg1)->GetCols();
53599 wxPyEndAllowThreads(__tstate);
53600 if (PyErr_Occurred()) SWIG_fail;
53601 }
53602 resultobj = SWIG_From_int(static_cast< int >(result));
53603 return resultobj;
53604 fail:
53605 return NULL;
53606 }
53607
53608
53609 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53610 PyObject *resultobj = 0;
53611 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53612 int result;
53613 void *argp1 = 0 ;
53614 int res1 = 0 ;
53615 PyObject *swig_obj[1] ;
53616
53617 if (!args) SWIG_fail;
53618 swig_obj[0] = args;
53619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53620 if (!SWIG_IsOK(res1)) {
53621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53622 }
53623 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53624 {
53625 PyThreadState* __tstate = wxPyBeginAllowThreads();
53626 result = (int)(arg1)->GetRows();
53627 wxPyEndAllowThreads(__tstate);
53628 if (PyErr_Occurred()) SWIG_fail;
53629 }
53630 resultobj = SWIG_From_int(static_cast< int >(result));
53631 return resultobj;
53632 fail:
53633 return NULL;
53634 }
53635
53636
53637 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53638 PyObject *resultobj = 0;
53639 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53640 int result;
53641 void *argp1 = 0 ;
53642 int res1 = 0 ;
53643 PyObject *swig_obj[1] ;
53644
53645 if (!args) SWIG_fail;
53646 swig_obj[0] = args;
53647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53648 if (!SWIG_IsOK(res1)) {
53649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53650 }
53651 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53652 {
53653 PyThreadState* __tstate = wxPyBeginAllowThreads();
53654 result = (int)(arg1)->GetVGap();
53655 wxPyEndAllowThreads(__tstate);
53656 if (PyErr_Occurred()) SWIG_fail;
53657 }
53658 resultobj = SWIG_From_int(static_cast< int >(result));
53659 return resultobj;
53660 fail:
53661 return NULL;
53662 }
53663
53664
53665 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53666 PyObject *resultobj = 0;
53667 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53668 int result;
53669 void *argp1 = 0 ;
53670 int res1 = 0 ;
53671 PyObject *swig_obj[1] ;
53672
53673 if (!args) SWIG_fail;
53674 swig_obj[0] = args;
53675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53676 if (!SWIG_IsOK(res1)) {
53677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53678 }
53679 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53680 {
53681 PyThreadState* __tstate = wxPyBeginAllowThreads();
53682 result = (int)(arg1)->GetHGap();
53683 wxPyEndAllowThreads(__tstate);
53684 if (PyErr_Occurred()) SWIG_fail;
53685 }
53686 resultobj = SWIG_From_int(static_cast< int >(result));
53687 return resultobj;
53688 fail:
53689 return NULL;
53690 }
53691
53692
53693 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53694 PyObject *obj;
53695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53696 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53697 return SWIG_Py_Void();
53698 }
53699
53700 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53701 return SWIG_Python_InitShadowInstance(args);
53702 }
53703
53704 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53705 PyObject *resultobj = 0;
53706 int arg1 = (int) 1 ;
53707 int arg2 = (int) 0 ;
53708 int arg3 = (int) 0 ;
53709 int arg4 = (int) 0 ;
53710 wxFlexGridSizer *result = 0 ;
53711 int val1 ;
53712 int ecode1 = 0 ;
53713 int val2 ;
53714 int ecode2 = 0 ;
53715 int val3 ;
53716 int ecode3 = 0 ;
53717 int val4 ;
53718 int ecode4 = 0 ;
53719 PyObject * obj0 = 0 ;
53720 PyObject * obj1 = 0 ;
53721 PyObject * obj2 = 0 ;
53722 PyObject * obj3 = 0 ;
53723 char * kwnames[] = {
53724 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53725 };
53726
53727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53728 if (obj0) {
53729 ecode1 = SWIG_AsVal_int(obj0, &val1);
53730 if (!SWIG_IsOK(ecode1)) {
53731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53732 }
53733 arg1 = static_cast< int >(val1);
53734 }
53735 if (obj1) {
53736 ecode2 = SWIG_AsVal_int(obj1, &val2);
53737 if (!SWIG_IsOK(ecode2)) {
53738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53739 }
53740 arg2 = static_cast< int >(val2);
53741 }
53742 if (obj2) {
53743 ecode3 = SWIG_AsVal_int(obj2, &val3);
53744 if (!SWIG_IsOK(ecode3)) {
53745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53746 }
53747 arg3 = static_cast< int >(val3);
53748 }
53749 if (obj3) {
53750 ecode4 = SWIG_AsVal_int(obj3, &val4);
53751 if (!SWIG_IsOK(ecode4)) {
53752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53753 }
53754 arg4 = static_cast< int >(val4);
53755 }
53756 {
53757 PyThreadState* __tstate = wxPyBeginAllowThreads();
53758 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53759 wxPyEndAllowThreads(__tstate);
53760 if (PyErr_Occurred()) SWIG_fail;
53761 }
53762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53763 return resultobj;
53764 fail:
53765 return NULL;
53766 }
53767
53768
53769 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53770 PyObject *resultobj = 0;
53771 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53772 size_t arg2 ;
53773 int arg3 = (int) 0 ;
53774 void *argp1 = 0 ;
53775 int res1 = 0 ;
53776 size_t val2 ;
53777 int ecode2 = 0 ;
53778 int val3 ;
53779 int ecode3 = 0 ;
53780 PyObject * obj0 = 0 ;
53781 PyObject * obj1 = 0 ;
53782 PyObject * obj2 = 0 ;
53783 char * kwnames[] = {
53784 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53785 };
53786
53787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53789 if (!SWIG_IsOK(res1)) {
53790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53791 }
53792 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53793 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53794 if (!SWIG_IsOK(ecode2)) {
53795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53796 }
53797 arg2 = static_cast< size_t >(val2);
53798 if (obj2) {
53799 ecode3 = SWIG_AsVal_int(obj2, &val3);
53800 if (!SWIG_IsOK(ecode3)) {
53801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53802 }
53803 arg3 = static_cast< int >(val3);
53804 }
53805 {
53806 PyThreadState* __tstate = wxPyBeginAllowThreads();
53807 (arg1)->AddGrowableRow(arg2,arg3);
53808 wxPyEndAllowThreads(__tstate);
53809 if (PyErr_Occurred()) SWIG_fail;
53810 }
53811 resultobj = SWIG_Py_Void();
53812 return resultobj;
53813 fail:
53814 return NULL;
53815 }
53816
53817
53818 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53819 PyObject *resultobj = 0;
53820 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53821 size_t arg2 ;
53822 void *argp1 = 0 ;
53823 int res1 = 0 ;
53824 size_t val2 ;
53825 int ecode2 = 0 ;
53826 PyObject * obj0 = 0 ;
53827 PyObject * obj1 = 0 ;
53828 char * kwnames[] = {
53829 (char *) "self",(char *) "idx", NULL
53830 };
53831
53832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53834 if (!SWIG_IsOK(res1)) {
53835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53836 }
53837 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53838 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53839 if (!SWIG_IsOK(ecode2)) {
53840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53841 }
53842 arg2 = static_cast< size_t >(val2);
53843 {
53844 PyThreadState* __tstate = wxPyBeginAllowThreads();
53845 (arg1)->RemoveGrowableRow(arg2);
53846 wxPyEndAllowThreads(__tstate);
53847 if (PyErr_Occurred()) SWIG_fail;
53848 }
53849 resultobj = SWIG_Py_Void();
53850 return resultobj;
53851 fail:
53852 return NULL;
53853 }
53854
53855
53856 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53857 PyObject *resultobj = 0;
53858 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53859 size_t arg2 ;
53860 int arg3 = (int) 0 ;
53861 void *argp1 = 0 ;
53862 int res1 = 0 ;
53863 size_t val2 ;
53864 int ecode2 = 0 ;
53865 int val3 ;
53866 int ecode3 = 0 ;
53867 PyObject * obj0 = 0 ;
53868 PyObject * obj1 = 0 ;
53869 PyObject * obj2 = 0 ;
53870 char * kwnames[] = {
53871 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53872 };
53873
53874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53876 if (!SWIG_IsOK(res1)) {
53877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53878 }
53879 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53880 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53881 if (!SWIG_IsOK(ecode2)) {
53882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53883 }
53884 arg2 = static_cast< size_t >(val2);
53885 if (obj2) {
53886 ecode3 = SWIG_AsVal_int(obj2, &val3);
53887 if (!SWIG_IsOK(ecode3)) {
53888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53889 }
53890 arg3 = static_cast< int >(val3);
53891 }
53892 {
53893 PyThreadState* __tstate = wxPyBeginAllowThreads();
53894 (arg1)->AddGrowableCol(arg2,arg3);
53895 wxPyEndAllowThreads(__tstate);
53896 if (PyErr_Occurred()) SWIG_fail;
53897 }
53898 resultobj = SWIG_Py_Void();
53899 return resultobj;
53900 fail:
53901 return NULL;
53902 }
53903
53904
53905 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53906 PyObject *resultobj = 0;
53907 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53908 size_t arg2 ;
53909 void *argp1 = 0 ;
53910 int res1 = 0 ;
53911 size_t val2 ;
53912 int ecode2 = 0 ;
53913 PyObject * obj0 = 0 ;
53914 PyObject * obj1 = 0 ;
53915 char * kwnames[] = {
53916 (char *) "self",(char *) "idx", NULL
53917 };
53918
53919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53921 if (!SWIG_IsOK(res1)) {
53922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53923 }
53924 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53925 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53926 if (!SWIG_IsOK(ecode2)) {
53927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53928 }
53929 arg2 = static_cast< size_t >(val2);
53930 {
53931 PyThreadState* __tstate = wxPyBeginAllowThreads();
53932 (arg1)->RemoveGrowableCol(arg2);
53933 wxPyEndAllowThreads(__tstate);
53934 if (PyErr_Occurred()) SWIG_fail;
53935 }
53936 resultobj = SWIG_Py_Void();
53937 return resultobj;
53938 fail:
53939 return NULL;
53940 }
53941
53942
53943 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53944 PyObject *resultobj = 0;
53945 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53946 int arg2 ;
53947 void *argp1 = 0 ;
53948 int res1 = 0 ;
53949 int val2 ;
53950 int ecode2 = 0 ;
53951 PyObject * obj0 = 0 ;
53952 PyObject * obj1 = 0 ;
53953 char * kwnames[] = {
53954 (char *) "self",(char *) "direction", NULL
53955 };
53956
53957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53959 if (!SWIG_IsOK(res1)) {
53960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53961 }
53962 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53963 ecode2 = SWIG_AsVal_int(obj1, &val2);
53964 if (!SWIG_IsOK(ecode2)) {
53965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53966 }
53967 arg2 = static_cast< int >(val2);
53968 {
53969 PyThreadState* __tstate = wxPyBeginAllowThreads();
53970 (arg1)->SetFlexibleDirection(arg2);
53971 wxPyEndAllowThreads(__tstate);
53972 if (PyErr_Occurred()) SWIG_fail;
53973 }
53974 resultobj = SWIG_Py_Void();
53975 return resultobj;
53976 fail:
53977 return NULL;
53978 }
53979
53980
53981 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53982 PyObject *resultobj = 0;
53983 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53984 int result;
53985 void *argp1 = 0 ;
53986 int res1 = 0 ;
53987 PyObject *swig_obj[1] ;
53988
53989 if (!args) SWIG_fail;
53990 swig_obj[0] = args;
53991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53992 if (!SWIG_IsOK(res1)) {
53993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53994 }
53995 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53996 {
53997 PyThreadState* __tstate = wxPyBeginAllowThreads();
53998 result = (int)(arg1)->GetFlexibleDirection();
53999 wxPyEndAllowThreads(__tstate);
54000 if (PyErr_Occurred()) SWIG_fail;
54001 }
54002 resultobj = SWIG_From_int(static_cast< int >(result));
54003 return resultobj;
54004 fail:
54005 return NULL;
54006 }
54007
54008
54009 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54010 PyObject *resultobj = 0;
54011 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54012 wxFlexSizerGrowMode arg2 ;
54013 void *argp1 = 0 ;
54014 int res1 = 0 ;
54015 int val2 ;
54016 int ecode2 = 0 ;
54017 PyObject * obj0 = 0 ;
54018 PyObject * obj1 = 0 ;
54019 char * kwnames[] = {
54020 (char *) "self",(char *) "mode", NULL
54021 };
54022
54023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
54024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54025 if (!SWIG_IsOK(res1)) {
54026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54027 }
54028 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54029 ecode2 = SWIG_AsVal_int(obj1, &val2);
54030 if (!SWIG_IsOK(ecode2)) {
54031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
54032 }
54033 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
54034 {
54035 PyThreadState* __tstate = wxPyBeginAllowThreads();
54036 (arg1)->SetNonFlexibleGrowMode(arg2);
54037 wxPyEndAllowThreads(__tstate);
54038 if (PyErr_Occurred()) SWIG_fail;
54039 }
54040 resultobj = SWIG_Py_Void();
54041 return resultobj;
54042 fail:
54043 return NULL;
54044 }
54045
54046
54047 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54048 PyObject *resultobj = 0;
54049 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54050 wxFlexSizerGrowMode result;
54051 void *argp1 = 0 ;
54052 int res1 = 0 ;
54053 PyObject *swig_obj[1] ;
54054
54055 if (!args) SWIG_fail;
54056 swig_obj[0] = args;
54057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54058 if (!SWIG_IsOK(res1)) {
54059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54060 }
54061 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54062 {
54063 PyThreadState* __tstate = wxPyBeginAllowThreads();
54064 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
54065 wxPyEndAllowThreads(__tstate);
54066 if (PyErr_Occurred()) SWIG_fail;
54067 }
54068 resultobj = SWIG_From_int(static_cast< int >(result));
54069 return resultobj;
54070 fail:
54071 return NULL;
54072 }
54073
54074
54075 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54076 PyObject *resultobj = 0;
54077 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54078 wxArrayInt *result = 0 ;
54079 void *argp1 = 0 ;
54080 int res1 = 0 ;
54081 PyObject *swig_obj[1] ;
54082
54083 if (!args) SWIG_fail;
54084 swig_obj[0] = args;
54085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54086 if (!SWIG_IsOK(res1)) {
54087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54088 }
54089 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54090 {
54091 PyThreadState* __tstate = wxPyBeginAllowThreads();
54092 {
54093 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
54094 result = (wxArrayInt *) &_result_ref;
54095 }
54096 wxPyEndAllowThreads(__tstate);
54097 if (PyErr_Occurred()) SWIG_fail;
54098 }
54099 {
54100 resultobj = wxArrayInt2PyList_helper(*result);
54101 }
54102 return resultobj;
54103 fail:
54104 return NULL;
54105 }
54106
54107
54108 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54109 PyObject *resultobj = 0;
54110 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54111 wxArrayInt *result = 0 ;
54112 void *argp1 = 0 ;
54113 int res1 = 0 ;
54114 PyObject *swig_obj[1] ;
54115
54116 if (!args) SWIG_fail;
54117 swig_obj[0] = args;
54118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54119 if (!SWIG_IsOK(res1)) {
54120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54121 }
54122 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54123 {
54124 PyThreadState* __tstate = wxPyBeginAllowThreads();
54125 {
54126 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
54127 result = (wxArrayInt *) &_result_ref;
54128 }
54129 wxPyEndAllowThreads(__tstate);
54130 if (PyErr_Occurred()) SWIG_fail;
54131 }
54132 {
54133 resultobj = wxArrayInt2PyList_helper(*result);
54134 }
54135 return resultobj;
54136 fail:
54137 return NULL;
54138 }
54139
54140
54141 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54142 PyObject *obj;
54143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54144 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
54145 return SWIG_Py_Void();
54146 }
54147
54148 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54149 return SWIG_Python_InitShadowInstance(args);
54150 }
54151
54152 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54153 PyObject *resultobj = 0;
54154 wxStdDialogButtonSizer *result = 0 ;
54155
54156 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
54157 {
54158 PyThreadState* __tstate = wxPyBeginAllowThreads();
54159 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
54160 wxPyEndAllowThreads(__tstate);
54161 if (PyErr_Occurred()) SWIG_fail;
54162 }
54163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
54164 return resultobj;
54165 fail:
54166 return NULL;
54167 }
54168
54169
54170 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54171 PyObject *resultobj = 0;
54172 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54173 wxButton *arg2 = (wxButton *) 0 ;
54174 void *argp1 = 0 ;
54175 int res1 = 0 ;
54176 void *argp2 = 0 ;
54177 int res2 = 0 ;
54178 PyObject * obj0 = 0 ;
54179 PyObject * obj1 = 0 ;
54180 char * kwnames[] = {
54181 (char *) "self",(char *) "button", NULL
54182 };
54183
54184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
54185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54186 if (!SWIG_IsOK(res1)) {
54187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54188 }
54189 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54191 if (!SWIG_IsOK(res2)) {
54192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
54193 }
54194 arg2 = reinterpret_cast< wxButton * >(argp2);
54195 {
54196 PyThreadState* __tstate = wxPyBeginAllowThreads();
54197 (arg1)->AddButton(arg2);
54198 wxPyEndAllowThreads(__tstate);
54199 if (PyErr_Occurred()) SWIG_fail;
54200 }
54201 resultobj = SWIG_Py_Void();
54202 return resultobj;
54203 fail:
54204 return NULL;
54205 }
54206
54207
54208 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54209 PyObject *resultobj = 0;
54210 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54211 void *argp1 = 0 ;
54212 int res1 = 0 ;
54213 PyObject *swig_obj[1] ;
54214
54215 if (!args) SWIG_fail;
54216 swig_obj[0] = args;
54217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54218 if (!SWIG_IsOK(res1)) {
54219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54220 }
54221 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54222 {
54223 PyThreadState* __tstate = wxPyBeginAllowThreads();
54224 (arg1)->Realize();
54225 wxPyEndAllowThreads(__tstate);
54226 if (PyErr_Occurred()) SWIG_fail;
54227 }
54228 resultobj = SWIG_Py_Void();
54229 return resultobj;
54230 fail:
54231 return NULL;
54232 }
54233
54234
54235 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54236 PyObject *resultobj = 0;
54237 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54238 wxButton *arg2 = (wxButton *) 0 ;
54239 void *argp1 = 0 ;
54240 int res1 = 0 ;
54241 void *argp2 = 0 ;
54242 int res2 = 0 ;
54243 PyObject * obj0 = 0 ;
54244 PyObject * obj1 = 0 ;
54245 char * kwnames[] = {
54246 (char *) "self",(char *) "button", NULL
54247 };
54248
54249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54251 if (!SWIG_IsOK(res1)) {
54252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54253 }
54254 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54256 if (!SWIG_IsOK(res2)) {
54257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54258 }
54259 arg2 = reinterpret_cast< wxButton * >(argp2);
54260 {
54261 PyThreadState* __tstate = wxPyBeginAllowThreads();
54262 (arg1)->SetAffirmativeButton(arg2);
54263 wxPyEndAllowThreads(__tstate);
54264 if (PyErr_Occurred()) SWIG_fail;
54265 }
54266 resultobj = SWIG_Py_Void();
54267 return resultobj;
54268 fail:
54269 return NULL;
54270 }
54271
54272
54273 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54274 PyObject *resultobj = 0;
54275 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54276 wxButton *arg2 = (wxButton *) 0 ;
54277 void *argp1 = 0 ;
54278 int res1 = 0 ;
54279 void *argp2 = 0 ;
54280 int res2 = 0 ;
54281 PyObject * obj0 = 0 ;
54282 PyObject * obj1 = 0 ;
54283 char * kwnames[] = {
54284 (char *) "self",(char *) "button", NULL
54285 };
54286
54287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54289 if (!SWIG_IsOK(res1)) {
54290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54291 }
54292 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54294 if (!SWIG_IsOK(res2)) {
54295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54296 }
54297 arg2 = reinterpret_cast< wxButton * >(argp2);
54298 {
54299 PyThreadState* __tstate = wxPyBeginAllowThreads();
54300 (arg1)->SetNegativeButton(arg2);
54301 wxPyEndAllowThreads(__tstate);
54302 if (PyErr_Occurred()) SWIG_fail;
54303 }
54304 resultobj = SWIG_Py_Void();
54305 return resultobj;
54306 fail:
54307 return NULL;
54308 }
54309
54310
54311 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54312 PyObject *resultobj = 0;
54313 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54314 wxButton *arg2 = (wxButton *) 0 ;
54315 void *argp1 = 0 ;
54316 int res1 = 0 ;
54317 void *argp2 = 0 ;
54318 int res2 = 0 ;
54319 PyObject * obj0 = 0 ;
54320 PyObject * obj1 = 0 ;
54321 char * kwnames[] = {
54322 (char *) "self",(char *) "button", NULL
54323 };
54324
54325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
54326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54327 if (!SWIG_IsOK(res1)) {
54328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54329 }
54330 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54332 if (!SWIG_IsOK(res2)) {
54333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
54334 }
54335 arg2 = reinterpret_cast< wxButton * >(argp2);
54336 {
54337 PyThreadState* __tstate = wxPyBeginAllowThreads();
54338 (arg1)->SetCancelButton(arg2);
54339 wxPyEndAllowThreads(__tstate);
54340 if (PyErr_Occurred()) SWIG_fail;
54341 }
54342 resultobj = SWIG_Py_Void();
54343 return resultobj;
54344 fail:
54345 return NULL;
54346 }
54347
54348
54349 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54350 PyObject *resultobj = 0;
54351 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54352 wxButton *result = 0 ;
54353 void *argp1 = 0 ;
54354 int res1 = 0 ;
54355 PyObject *swig_obj[1] ;
54356
54357 if (!args) SWIG_fail;
54358 swig_obj[0] = args;
54359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54360 if (!SWIG_IsOK(res1)) {
54361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54362 }
54363 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54364 {
54365 PyThreadState* __tstate = wxPyBeginAllowThreads();
54366 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
54367 wxPyEndAllowThreads(__tstate);
54368 if (PyErr_Occurred()) SWIG_fail;
54369 }
54370 {
54371 resultobj = wxPyMake_wxObject(result, (bool)0);
54372 }
54373 return resultobj;
54374 fail:
54375 return NULL;
54376 }
54377
54378
54379 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54380 PyObject *resultobj = 0;
54381 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54382 wxButton *result = 0 ;
54383 void *argp1 = 0 ;
54384 int res1 = 0 ;
54385 PyObject *swig_obj[1] ;
54386
54387 if (!args) SWIG_fail;
54388 swig_obj[0] = args;
54389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54390 if (!SWIG_IsOK(res1)) {
54391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54392 }
54393 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54394 {
54395 PyThreadState* __tstate = wxPyBeginAllowThreads();
54396 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
54397 wxPyEndAllowThreads(__tstate);
54398 if (PyErr_Occurred()) SWIG_fail;
54399 }
54400 {
54401 resultobj = wxPyMake_wxObject(result, (bool)0);
54402 }
54403 return resultobj;
54404 fail:
54405 return NULL;
54406 }
54407
54408
54409 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54410 PyObject *resultobj = 0;
54411 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54412 wxButton *result = 0 ;
54413 void *argp1 = 0 ;
54414 int res1 = 0 ;
54415 PyObject *swig_obj[1] ;
54416
54417 if (!args) SWIG_fail;
54418 swig_obj[0] = args;
54419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54420 if (!SWIG_IsOK(res1)) {
54421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54422 }
54423 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54424 {
54425 PyThreadState* __tstate = wxPyBeginAllowThreads();
54426 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
54427 wxPyEndAllowThreads(__tstate);
54428 if (PyErr_Occurred()) SWIG_fail;
54429 }
54430 {
54431 resultobj = wxPyMake_wxObject(result, (bool)0);
54432 }
54433 return resultobj;
54434 fail:
54435 return NULL;
54436 }
54437
54438
54439 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54440 PyObject *resultobj = 0;
54441 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54442 wxButton *result = 0 ;
54443 void *argp1 = 0 ;
54444 int res1 = 0 ;
54445 PyObject *swig_obj[1] ;
54446
54447 if (!args) SWIG_fail;
54448 swig_obj[0] = args;
54449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54450 if (!SWIG_IsOK(res1)) {
54451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54452 }
54453 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54454 {
54455 PyThreadState* __tstate = wxPyBeginAllowThreads();
54456 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
54457 wxPyEndAllowThreads(__tstate);
54458 if (PyErr_Occurred()) SWIG_fail;
54459 }
54460 {
54461 resultobj = wxPyMake_wxObject(result, (bool)0);
54462 }
54463 return resultobj;
54464 fail:
54465 return NULL;
54466 }
54467
54468
54469 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54470 PyObject *resultobj = 0;
54471 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54472 wxButton *result = 0 ;
54473 void *argp1 = 0 ;
54474 int res1 = 0 ;
54475 PyObject *swig_obj[1] ;
54476
54477 if (!args) SWIG_fail;
54478 swig_obj[0] = args;
54479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54480 if (!SWIG_IsOK(res1)) {
54481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54482 }
54483 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54484 {
54485 PyThreadState* __tstate = wxPyBeginAllowThreads();
54486 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
54487 wxPyEndAllowThreads(__tstate);
54488 if (PyErr_Occurred()) SWIG_fail;
54489 }
54490 {
54491 resultobj = wxPyMake_wxObject(result, (bool)0);
54492 }
54493 return resultobj;
54494 fail:
54495 return NULL;
54496 }
54497
54498
54499 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54500 PyObject *obj;
54501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54502 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54503 return SWIG_Py_Void();
54504 }
54505
54506 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54507 return SWIG_Python_InitShadowInstance(args);
54508 }
54509
54510 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54511 PyObject *resultobj = 0;
54512 int arg1 = (int) 0 ;
54513 int arg2 = (int) 0 ;
54514 wxGBPosition *result = 0 ;
54515 int val1 ;
54516 int ecode1 = 0 ;
54517 int val2 ;
54518 int ecode2 = 0 ;
54519 PyObject * obj0 = 0 ;
54520 PyObject * obj1 = 0 ;
54521 char * kwnames[] = {
54522 (char *) "row",(char *) "col", NULL
54523 };
54524
54525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54526 if (obj0) {
54527 ecode1 = SWIG_AsVal_int(obj0, &val1);
54528 if (!SWIG_IsOK(ecode1)) {
54529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54530 }
54531 arg1 = static_cast< int >(val1);
54532 }
54533 if (obj1) {
54534 ecode2 = SWIG_AsVal_int(obj1, &val2);
54535 if (!SWIG_IsOK(ecode2)) {
54536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54537 }
54538 arg2 = static_cast< int >(val2);
54539 }
54540 {
54541 PyThreadState* __tstate = wxPyBeginAllowThreads();
54542 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54543 wxPyEndAllowThreads(__tstate);
54544 if (PyErr_Occurred()) SWIG_fail;
54545 }
54546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54547 return resultobj;
54548 fail:
54549 return NULL;
54550 }
54551
54552
54553 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54554 PyObject *resultobj = 0;
54555 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54556 void *argp1 = 0 ;
54557 int res1 = 0 ;
54558 PyObject *swig_obj[1] ;
54559
54560 if (!args) SWIG_fail;
54561 swig_obj[0] = args;
54562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54563 if (!SWIG_IsOK(res1)) {
54564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54565 }
54566 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54567 {
54568 PyThreadState* __tstate = wxPyBeginAllowThreads();
54569 delete arg1;
54570
54571 wxPyEndAllowThreads(__tstate);
54572 if (PyErr_Occurred()) SWIG_fail;
54573 }
54574 resultobj = SWIG_Py_Void();
54575 return resultobj;
54576 fail:
54577 return NULL;
54578 }
54579
54580
54581 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54582 PyObject *resultobj = 0;
54583 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54584 int result;
54585 void *argp1 = 0 ;
54586 int res1 = 0 ;
54587 PyObject *swig_obj[1] ;
54588
54589 if (!args) SWIG_fail;
54590 swig_obj[0] = args;
54591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54592 if (!SWIG_IsOK(res1)) {
54593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54594 }
54595 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54596 {
54597 PyThreadState* __tstate = wxPyBeginAllowThreads();
54598 result = (int)((wxGBPosition const *)arg1)->GetRow();
54599 wxPyEndAllowThreads(__tstate);
54600 if (PyErr_Occurred()) SWIG_fail;
54601 }
54602 resultobj = SWIG_From_int(static_cast< int >(result));
54603 return resultobj;
54604 fail:
54605 return NULL;
54606 }
54607
54608
54609 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54610 PyObject *resultobj = 0;
54611 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54612 int result;
54613 void *argp1 = 0 ;
54614 int res1 = 0 ;
54615 PyObject *swig_obj[1] ;
54616
54617 if (!args) SWIG_fail;
54618 swig_obj[0] = args;
54619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54620 if (!SWIG_IsOK(res1)) {
54621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54622 }
54623 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54624 {
54625 PyThreadState* __tstate = wxPyBeginAllowThreads();
54626 result = (int)((wxGBPosition const *)arg1)->GetCol();
54627 wxPyEndAllowThreads(__tstate);
54628 if (PyErr_Occurred()) SWIG_fail;
54629 }
54630 resultobj = SWIG_From_int(static_cast< int >(result));
54631 return resultobj;
54632 fail:
54633 return NULL;
54634 }
54635
54636
54637 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54638 PyObject *resultobj = 0;
54639 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54640 int arg2 ;
54641 void *argp1 = 0 ;
54642 int res1 = 0 ;
54643 int val2 ;
54644 int ecode2 = 0 ;
54645 PyObject * obj0 = 0 ;
54646 PyObject * obj1 = 0 ;
54647 char * kwnames[] = {
54648 (char *) "self",(char *) "row", NULL
54649 };
54650
54651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54653 if (!SWIG_IsOK(res1)) {
54654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54655 }
54656 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54657 ecode2 = SWIG_AsVal_int(obj1, &val2);
54658 if (!SWIG_IsOK(ecode2)) {
54659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54660 }
54661 arg2 = static_cast< int >(val2);
54662 {
54663 PyThreadState* __tstate = wxPyBeginAllowThreads();
54664 (arg1)->SetRow(arg2);
54665 wxPyEndAllowThreads(__tstate);
54666 if (PyErr_Occurred()) SWIG_fail;
54667 }
54668 resultobj = SWIG_Py_Void();
54669 return resultobj;
54670 fail:
54671 return NULL;
54672 }
54673
54674
54675 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54676 PyObject *resultobj = 0;
54677 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54678 int arg2 ;
54679 void *argp1 = 0 ;
54680 int res1 = 0 ;
54681 int val2 ;
54682 int ecode2 = 0 ;
54683 PyObject * obj0 = 0 ;
54684 PyObject * obj1 = 0 ;
54685 char * kwnames[] = {
54686 (char *) "self",(char *) "col", NULL
54687 };
54688
54689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54691 if (!SWIG_IsOK(res1)) {
54692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54693 }
54694 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54695 ecode2 = SWIG_AsVal_int(obj1, &val2);
54696 if (!SWIG_IsOK(ecode2)) {
54697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54698 }
54699 arg2 = static_cast< int >(val2);
54700 {
54701 PyThreadState* __tstate = wxPyBeginAllowThreads();
54702 (arg1)->SetCol(arg2);
54703 wxPyEndAllowThreads(__tstate);
54704 if (PyErr_Occurred()) SWIG_fail;
54705 }
54706 resultobj = SWIG_Py_Void();
54707 return resultobj;
54708 fail:
54709 return NULL;
54710 }
54711
54712
54713 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54714 PyObject *resultobj = 0;
54715 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54716 PyObject *arg2 = (PyObject *) 0 ;
54717 bool result;
54718 void *argp1 = 0 ;
54719 int res1 = 0 ;
54720 PyObject * obj0 = 0 ;
54721 PyObject * obj1 = 0 ;
54722 char * kwnames[] = {
54723 (char *) "self",(char *) "other", NULL
54724 };
54725
54726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54728 if (!SWIG_IsOK(res1)) {
54729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54730 }
54731 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54732 arg2 = obj1;
54733 {
54734 result = (bool)wxGBPosition___eq__(arg1,arg2);
54735 if (PyErr_Occurred()) SWIG_fail;
54736 }
54737 {
54738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54739 }
54740 return resultobj;
54741 fail:
54742 return NULL;
54743 }
54744
54745
54746 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54747 PyObject *resultobj = 0;
54748 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54749 PyObject *arg2 = (PyObject *) 0 ;
54750 bool result;
54751 void *argp1 = 0 ;
54752 int res1 = 0 ;
54753 PyObject * obj0 = 0 ;
54754 PyObject * obj1 = 0 ;
54755 char * kwnames[] = {
54756 (char *) "self",(char *) "other", NULL
54757 };
54758
54759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54761 if (!SWIG_IsOK(res1)) {
54762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54763 }
54764 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54765 arg2 = obj1;
54766 {
54767 result = (bool)wxGBPosition___ne__(arg1,arg2);
54768 if (PyErr_Occurred()) SWIG_fail;
54769 }
54770 {
54771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54772 }
54773 return resultobj;
54774 fail:
54775 return NULL;
54776 }
54777
54778
54779 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54780 PyObject *resultobj = 0;
54781 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54782 int arg2 = (int) 0 ;
54783 int arg3 = (int) 0 ;
54784 void *argp1 = 0 ;
54785 int res1 = 0 ;
54786 int val2 ;
54787 int ecode2 = 0 ;
54788 int val3 ;
54789 int ecode3 = 0 ;
54790 PyObject * obj0 = 0 ;
54791 PyObject * obj1 = 0 ;
54792 PyObject * obj2 = 0 ;
54793 char * kwnames[] = {
54794 (char *) "self",(char *) "row",(char *) "col", NULL
54795 };
54796
54797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54799 if (!SWIG_IsOK(res1)) {
54800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54801 }
54802 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54803 if (obj1) {
54804 ecode2 = SWIG_AsVal_int(obj1, &val2);
54805 if (!SWIG_IsOK(ecode2)) {
54806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54807 }
54808 arg2 = static_cast< int >(val2);
54809 }
54810 if (obj2) {
54811 ecode3 = SWIG_AsVal_int(obj2, &val3);
54812 if (!SWIG_IsOK(ecode3)) {
54813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54814 }
54815 arg3 = static_cast< int >(val3);
54816 }
54817 {
54818 PyThreadState* __tstate = wxPyBeginAllowThreads();
54819 wxGBPosition_Set(arg1,arg2,arg3);
54820 wxPyEndAllowThreads(__tstate);
54821 if (PyErr_Occurred()) SWIG_fail;
54822 }
54823 resultobj = SWIG_Py_Void();
54824 return resultobj;
54825 fail:
54826 return NULL;
54827 }
54828
54829
54830 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54831 PyObject *resultobj = 0;
54832 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54833 PyObject *result = 0 ;
54834 void *argp1 = 0 ;
54835 int res1 = 0 ;
54836 PyObject *swig_obj[1] ;
54837
54838 if (!args) SWIG_fail;
54839 swig_obj[0] = args;
54840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54841 if (!SWIG_IsOK(res1)) {
54842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54843 }
54844 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54845 {
54846 PyThreadState* __tstate = wxPyBeginAllowThreads();
54847 result = (PyObject *)wxGBPosition_Get(arg1);
54848 wxPyEndAllowThreads(__tstate);
54849 if (PyErr_Occurred()) SWIG_fail;
54850 }
54851 resultobj = result;
54852 return resultobj;
54853 fail:
54854 return NULL;
54855 }
54856
54857
54858 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54859 PyObject *obj;
54860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54861 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54862 return SWIG_Py_Void();
54863 }
54864
54865 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54866 return SWIG_Python_InitShadowInstance(args);
54867 }
54868
54869 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54870 PyObject *resultobj = 0;
54871 int arg1 = (int) 1 ;
54872 int arg2 = (int) 1 ;
54873 wxGBSpan *result = 0 ;
54874 int val1 ;
54875 int ecode1 = 0 ;
54876 int val2 ;
54877 int ecode2 = 0 ;
54878 PyObject * obj0 = 0 ;
54879 PyObject * obj1 = 0 ;
54880 char * kwnames[] = {
54881 (char *) "rowspan",(char *) "colspan", NULL
54882 };
54883
54884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54885 if (obj0) {
54886 ecode1 = SWIG_AsVal_int(obj0, &val1);
54887 if (!SWIG_IsOK(ecode1)) {
54888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54889 }
54890 arg1 = static_cast< int >(val1);
54891 }
54892 if (obj1) {
54893 ecode2 = SWIG_AsVal_int(obj1, &val2);
54894 if (!SWIG_IsOK(ecode2)) {
54895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54896 }
54897 arg2 = static_cast< int >(val2);
54898 }
54899 {
54900 PyThreadState* __tstate = wxPyBeginAllowThreads();
54901 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54902 wxPyEndAllowThreads(__tstate);
54903 if (PyErr_Occurred()) SWIG_fail;
54904 }
54905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54906 return resultobj;
54907 fail:
54908 return NULL;
54909 }
54910
54911
54912 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54913 PyObject *resultobj = 0;
54914 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54915 void *argp1 = 0 ;
54916 int res1 = 0 ;
54917 PyObject *swig_obj[1] ;
54918
54919 if (!args) SWIG_fail;
54920 swig_obj[0] = args;
54921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54922 if (!SWIG_IsOK(res1)) {
54923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54924 }
54925 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54926 {
54927 PyThreadState* __tstate = wxPyBeginAllowThreads();
54928 delete arg1;
54929
54930 wxPyEndAllowThreads(__tstate);
54931 if (PyErr_Occurred()) SWIG_fail;
54932 }
54933 resultobj = SWIG_Py_Void();
54934 return resultobj;
54935 fail:
54936 return NULL;
54937 }
54938
54939
54940 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54941 PyObject *resultobj = 0;
54942 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54943 int result;
54944 void *argp1 = 0 ;
54945 int res1 = 0 ;
54946 PyObject *swig_obj[1] ;
54947
54948 if (!args) SWIG_fail;
54949 swig_obj[0] = args;
54950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54951 if (!SWIG_IsOK(res1)) {
54952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54953 }
54954 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54955 {
54956 PyThreadState* __tstate = wxPyBeginAllowThreads();
54957 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54958 wxPyEndAllowThreads(__tstate);
54959 if (PyErr_Occurred()) SWIG_fail;
54960 }
54961 resultobj = SWIG_From_int(static_cast< int >(result));
54962 return resultobj;
54963 fail:
54964 return NULL;
54965 }
54966
54967
54968 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54969 PyObject *resultobj = 0;
54970 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54971 int result;
54972 void *argp1 = 0 ;
54973 int res1 = 0 ;
54974 PyObject *swig_obj[1] ;
54975
54976 if (!args) SWIG_fail;
54977 swig_obj[0] = args;
54978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54979 if (!SWIG_IsOK(res1)) {
54980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54981 }
54982 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54983 {
54984 PyThreadState* __tstate = wxPyBeginAllowThreads();
54985 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54986 wxPyEndAllowThreads(__tstate);
54987 if (PyErr_Occurred()) SWIG_fail;
54988 }
54989 resultobj = SWIG_From_int(static_cast< int >(result));
54990 return resultobj;
54991 fail:
54992 return NULL;
54993 }
54994
54995
54996 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54997 PyObject *resultobj = 0;
54998 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54999 int arg2 ;
55000 void *argp1 = 0 ;
55001 int res1 = 0 ;
55002 int val2 ;
55003 int ecode2 = 0 ;
55004 PyObject * obj0 = 0 ;
55005 PyObject * obj1 = 0 ;
55006 char * kwnames[] = {
55007 (char *) "self",(char *) "rowspan", NULL
55008 };
55009
55010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
55011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55012 if (!SWIG_IsOK(res1)) {
55013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55014 }
55015 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55016 ecode2 = SWIG_AsVal_int(obj1, &val2);
55017 if (!SWIG_IsOK(ecode2)) {
55018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
55019 }
55020 arg2 = static_cast< int >(val2);
55021 {
55022 PyThreadState* __tstate = wxPyBeginAllowThreads();
55023 (arg1)->SetRowspan(arg2);
55024 wxPyEndAllowThreads(__tstate);
55025 if (PyErr_Occurred()) SWIG_fail;
55026 }
55027 resultobj = SWIG_Py_Void();
55028 return resultobj;
55029 fail:
55030 return NULL;
55031 }
55032
55033
55034 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55035 PyObject *resultobj = 0;
55036 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55037 int arg2 ;
55038 void *argp1 = 0 ;
55039 int res1 = 0 ;
55040 int val2 ;
55041 int ecode2 = 0 ;
55042 PyObject * obj0 = 0 ;
55043 PyObject * obj1 = 0 ;
55044 char * kwnames[] = {
55045 (char *) "self",(char *) "colspan", NULL
55046 };
55047
55048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
55049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55050 if (!SWIG_IsOK(res1)) {
55051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55052 }
55053 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55054 ecode2 = SWIG_AsVal_int(obj1, &val2);
55055 if (!SWIG_IsOK(ecode2)) {
55056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
55057 }
55058 arg2 = static_cast< int >(val2);
55059 {
55060 PyThreadState* __tstate = wxPyBeginAllowThreads();
55061 (arg1)->SetColspan(arg2);
55062 wxPyEndAllowThreads(__tstate);
55063 if (PyErr_Occurred()) SWIG_fail;
55064 }
55065 resultobj = SWIG_Py_Void();
55066 return resultobj;
55067 fail:
55068 return NULL;
55069 }
55070
55071
55072 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55073 PyObject *resultobj = 0;
55074 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55075 PyObject *arg2 = (PyObject *) 0 ;
55076 bool result;
55077 void *argp1 = 0 ;
55078 int res1 = 0 ;
55079 PyObject * obj0 = 0 ;
55080 PyObject * obj1 = 0 ;
55081 char * kwnames[] = {
55082 (char *) "self",(char *) "other", NULL
55083 };
55084
55085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
55086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55087 if (!SWIG_IsOK(res1)) {
55088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55089 }
55090 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55091 arg2 = obj1;
55092 {
55093 result = (bool)wxGBSpan___eq__(arg1,arg2);
55094 if (PyErr_Occurred()) SWIG_fail;
55095 }
55096 {
55097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55098 }
55099 return resultobj;
55100 fail:
55101 return NULL;
55102 }
55103
55104
55105 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55106 PyObject *resultobj = 0;
55107 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55108 PyObject *arg2 = (PyObject *) 0 ;
55109 bool result;
55110 void *argp1 = 0 ;
55111 int res1 = 0 ;
55112 PyObject * obj0 = 0 ;
55113 PyObject * obj1 = 0 ;
55114 char * kwnames[] = {
55115 (char *) "self",(char *) "other", NULL
55116 };
55117
55118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
55119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55120 if (!SWIG_IsOK(res1)) {
55121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55122 }
55123 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55124 arg2 = obj1;
55125 {
55126 result = (bool)wxGBSpan___ne__(arg1,arg2);
55127 if (PyErr_Occurred()) SWIG_fail;
55128 }
55129 {
55130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55131 }
55132 return resultobj;
55133 fail:
55134 return NULL;
55135 }
55136
55137
55138 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55139 PyObject *resultobj = 0;
55140 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55141 int arg2 = (int) 1 ;
55142 int arg3 = (int) 1 ;
55143 void *argp1 = 0 ;
55144 int res1 = 0 ;
55145 int val2 ;
55146 int ecode2 = 0 ;
55147 int val3 ;
55148 int ecode3 = 0 ;
55149 PyObject * obj0 = 0 ;
55150 PyObject * obj1 = 0 ;
55151 PyObject * obj2 = 0 ;
55152 char * kwnames[] = {
55153 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
55154 };
55155
55156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55158 if (!SWIG_IsOK(res1)) {
55159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55160 }
55161 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55162 if (obj1) {
55163 ecode2 = SWIG_AsVal_int(obj1, &val2);
55164 if (!SWIG_IsOK(ecode2)) {
55165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
55166 }
55167 arg2 = static_cast< int >(val2);
55168 }
55169 if (obj2) {
55170 ecode3 = SWIG_AsVal_int(obj2, &val3);
55171 if (!SWIG_IsOK(ecode3)) {
55172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
55173 }
55174 arg3 = static_cast< int >(val3);
55175 }
55176 {
55177 PyThreadState* __tstate = wxPyBeginAllowThreads();
55178 wxGBSpan_Set(arg1,arg2,arg3);
55179 wxPyEndAllowThreads(__tstate);
55180 if (PyErr_Occurred()) SWIG_fail;
55181 }
55182 resultobj = SWIG_Py_Void();
55183 return resultobj;
55184 fail:
55185 return NULL;
55186 }
55187
55188
55189 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55190 PyObject *resultobj = 0;
55191 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55192 PyObject *result = 0 ;
55193 void *argp1 = 0 ;
55194 int res1 = 0 ;
55195 PyObject *swig_obj[1] ;
55196
55197 if (!args) SWIG_fail;
55198 swig_obj[0] = args;
55199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55200 if (!SWIG_IsOK(res1)) {
55201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55202 }
55203 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55204 {
55205 PyThreadState* __tstate = wxPyBeginAllowThreads();
55206 result = (PyObject *)wxGBSpan_Get(arg1);
55207 wxPyEndAllowThreads(__tstate);
55208 if (PyErr_Occurred()) SWIG_fail;
55209 }
55210 resultobj = result;
55211 return resultobj;
55212 fail:
55213 return NULL;
55214 }
55215
55216
55217 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55218 PyObject *obj;
55219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55220 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
55221 return SWIG_Py_Void();
55222 }
55223
55224 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55225 return SWIG_Python_InitShadowInstance(args);
55226 }
55227
55228 SWIGINTERN int DefaultSpan_set(PyObject *) {
55229 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
55230 return 1;
55231 }
55232
55233
55234 SWIGINTERN PyObject *DefaultSpan_get(void) {
55235 PyObject *pyobj = 0;
55236
55237 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
55238 return pyobj;
55239 }
55240
55241
55242 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55243 PyObject *resultobj = 0;
55244 wxGBSizerItem *result = 0 ;
55245
55246 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
55247 {
55248 PyThreadState* __tstate = wxPyBeginAllowThreads();
55249 result = (wxGBSizerItem *)new wxGBSizerItem();
55250 wxPyEndAllowThreads(__tstate);
55251 if (PyErr_Occurred()) SWIG_fail;
55252 }
55253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
55254 return resultobj;
55255 fail:
55256 return NULL;
55257 }
55258
55259
55260 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55261 PyObject *resultobj = 0;
55262 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55263 void *argp1 = 0 ;
55264 int res1 = 0 ;
55265 PyObject *swig_obj[1] ;
55266
55267 if (!args) SWIG_fail;
55268 swig_obj[0] = args;
55269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55270 if (!SWIG_IsOK(res1)) {
55271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55272 }
55273 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55274 {
55275 PyThreadState* __tstate = wxPyBeginAllowThreads();
55276 delete arg1;
55277
55278 wxPyEndAllowThreads(__tstate);
55279 if (PyErr_Occurred()) SWIG_fail;
55280 }
55281 resultobj = SWIG_Py_Void();
55282 return resultobj;
55283 fail:
55284 return NULL;
55285 }
55286
55287
55288 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55289 PyObject *resultobj = 0;
55290 wxWindow *arg1 = (wxWindow *) 0 ;
55291 wxGBPosition *arg2 = 0 ;
55292 wxGBSpan *arg3 = 0 ;
55293 int arg4 ;
55294 int arg5 ;
55295 PyObject *arg6 = (PyObject *) NULL ;
55296 wxGBSizerItem *result = 0 ;
55297 void *argp1 = 0 ;
55298 int res1 = 0 ;
55299 wxGBPosition temp2 ;
55300 wxGBSpan temp3 ;
55301 int val4 ;
55302 int ecode4 = 0 ;
55303 int val5 ;
55304 int ecode5 = 0 ;
55305 PyObject * obj0 = 0 ;
55306 PyObject * obj1 = 0 ;
55307 PyObject * obj2 = 0 ;
55308 PyObject * obj3 = 0 ;
55309 PyObject * obj4 = 0 ;
55310 PyObject * obj5 = 0 ;
55311 char * kwnames[] = {
55312 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55313 };
55314
55315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
55317 if (!SWIG_IsOK(res1)) {
55318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
55319 }
55320 arg1 = reinterpret_cast< wxWindow * >(argp1);
55321 {
55322 arg2 = &temp2;
55323 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55324 }
55325 {
55326 arg3 = &temp3;
55327 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55328 }
55329 ecode4 = SWIG_AsVal_int(obj3, &val4);
55330 if (!SWIG_IsOK(ecode4)) {
55331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
55332 }
55333 arg4 = static_cast< int >(val4);
55334 ecode5 = SWIG_AsVal_int(obj4, &val5);
55335 if (!SWIG_IsOK(ecode5)) {
55336 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
55337 }
55338 arg5 = static_cast< int >(val5);
55339 if (obj5) {
55340 arg6 = obj5;
55341 }
55342 {
55343 PyThreadState* __tstate = wxPyBeginAllowThreads();
55344 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55345 wxPyEndAllowThreads(__tstate);
55346 if (PyErr_Occurred()) SWIG_fail;
55347 }
55348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55349 return resultobj;
55350 fail:
55351 return NULL;
55352 }
55353
55354
55355 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55356 PyObject *resultobj = 0;
55357 wxSizer *arg1 = (wxSizer *) 0 ;
55358 wxGBPosition *arg2 = 0 ;
55359 wxGBSpan *arg3 = 0 ;
55360 int arg4 ;
55361 int arg5 ;
55362 PyObject *arg6 = (PyObject *) NULL ;
55363 wxGBSizerItem *result = 0 ;
55364 int res1 = 0 ;
55365 wxGBPosition temp2 ;
55366 wxGBSpan temp3 ;
55367 int val4 ;
55368 int ecode4 = 0 ;
55369 int val5 ;
55370 int ecode5 = 0 ;
55371 PyObject * obj0 = 0 ;
55372 PyObject * obj1 = 0 ;
55373 PyObject * obj2 = 0 ;
55374 PyObject * obj3 = 0 ;
55375 PyObject * obj4 = 0 ;
55376 PyObject * obj5 = 0 ;
55377 char * kwnames[] = {
55378 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55379 };
55380
55381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55382 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
55383 if (!SWIG_IsOK(res1)) {
55384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
55385 }
55386 {
55387 arg2 = &temp2;
55388 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55389 }
55390 {
55391 arg3 = &temp3;
55392 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55393 }
55394 ecode4 = SWIG_AsVal_int(obj3, &val4);
55395 if (!SWIG_IsOK(ecode4)) {
55396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
55397 }
55398 arg4 = static_cast< int >(val4);
55399 ecode5 = SWIG_AsVal_int(obj4, &val5);
55400 if (!SWIG_IsOK(ecode5)) {
55401 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
55402 }
55403 arg5 = static_cast< int >(val5);
55404 if (obj5) {
55405 arg6 = obj5;
55406 }
55407 {
55408 PyThreadState* __tstate = wxPyBeginAllowThreads();
55409 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55410 wxPyEndAllowThreads(__tstate);
55411 if (PyErr_Occurred()) SWIG_fail;
55412 }
55413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55414 return resultobj;
55415 fail:
55416 return NULL;
55417 }
55418
55419
55420 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55421 PyObject *resultobj = 0;
55422 int arg1 ;
55423 int arg2 ;
55424 wxGBPosition *arg3 = 0 ;
55425 wxGBSpan *arg4 = 0 ;
55426 int arg5 ;
55427 int arg6 ;
55428 PyObject *arg7 = (PyObject *) NULL ;
55429 wxGBSizerItem *result = 0 ;
55430 int val1 ;
55431 int ecode1 = 0 ;
55432 int val2 ;
55433 int ecode2 = 0 ;
55434 wxGBPosition temp3 ;
55435 wxGBSpan temp4 ;
55436 int val5 ;
55437 int ecode5 = 0 ;
55438 int val6 ;
55439 int ecode6 = 0 ;
55440 PyObject * obj0 = 0 ;
55441 PyObject * obj1 = 0 ;
55442 PyObject * obj2 = 0 ;
55443 PyObject * obj3 = 0 ;
55444 PyObject * obj4 = 0 ;
55445 PyObject * obj5 = 0 ;
55446 PyObject * obj6 = 0 ;
55447 char * kwnames[] = {
55448 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55449 };
55450
55451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55452 ecode1 = SWIG_AsVal_int(obj0, &val1);
55453 if (!SWIG_IsOK(ecode1)) {
55454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
55455 }
55456 arg1 = static_cast< int >(val1);
55457 ecode2 = SWIG_AsVal_int(obj1, &val2);
55458 if (!SWIG_IsOK(ecode2)) {
55459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
55460 }
55461 arg2 = static_cast< int >(val2);
55462 {
55463 arg3 = &temp3;
55464 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55465 }
55466 {
55467 arg4 = &temp4;
55468 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55469 }
55470 ecode5 = SWIG_AsVal_int(obj4, &val5);
55471 if (!SWIG_IsOK(ecode5)) {
55472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
55473 }
55474 arg5 = static_cast< int >(val5);
55475 ecode6 = SWIG_AsVal_int(obj5, &val6);
55476 if (!SWIG_IsOK(ecode6)) {
55477 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
55478 }
55479 arg6 = static_cast< int >(val6);
55480 if (obj6) {
55481 arg7 = obj6;
55482 }
55483 {
55484 PyThreadState* __tstate = wxPyBeginAllowThreads();
55485 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55486 wxPyEndAllowThreads(__tstate);
55487 if (PyErr_Occurred()) SWIG_fail;
55488 }
55489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55490 return resultobj;
55491 fail:
55492 return NULL;
55493 }
55494
55495
55496 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55497 PyObject *resultobj = 0;
55498 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55499 wxGBPosition result;
55500 void *argp1 = 0 ;
55501 int res1 = 0 ;
55502 PyObject *swig_obj[1] ;
55503
55504 if (!args) SWIG_fail;
55505 swig_obj[0] = args;
55506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55507 if (!SWIG_IsOK(res1)) {
55508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55509 }
55510 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55511 {
55512 PyThreadState* __tstate = wxPyBeginAllowThreads();
55513 result = ((wxGBSizerItem const *)arg1)->GetPos();
55514 wxPyEndAllowThreads(__tstate);
55515 if (PyErr_Occurred()) SWIG_fail;
55516 }
55517 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55518 return resultobj;
55519 fail:
55520 return NULL;
55521 }
55522
55523
55524 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55525 PyObject *resultobj = 0;
55526 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55527 wxGBSpan result;
55528 void *argp1 = 0 ;
55529 int res1 = 0 ;
55530 PyObject *swig_obj[1] ;
55531
55532 if (!args) SWIG_fail;
55533 swig_obj[0] = args;
55534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55535 if (!SWIG_IsOK(res1)) {
55536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55537 }
55538 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55539 {
55540 PyThreadState* __tstate = wxPyBeginAllowThreads();
55541 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55542 wxPyEndAllowThreads(__tstate);
55543 if (PyErr_Occurred()) SWIG_fail;
55544 }
55545 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55546 return resultobj;
55547 fail:
55548 return NULL;
55549 }
55550
55551
55552 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55553 PyObject *resultobj = 0;
55554 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55555 wxGBPosition *arg2 = 0 ;
55556 bool result;
55557 void *argp1 = 0 ;
55558 int res1 = 0 ;
55559 wxGBPosition temp2 ;
55560 PyObject * obj0 = 0 ;
55561 PyObject * obj1 = 0 ;
55562 char * kwnames[] = {
55563 (char *) "self",(char *) "pos", NULL
55564 };
55565
55566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55568 if (!SWIG_IsOK(res1)) {
55569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55570 }
55571 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55572 {
55573 arg2 = &temp2;
55574 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55575 }
55576 {
55577 PyThreadState* __tstate = wxPyBeginAllowThreads();
55578 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55579 wxPyEndAllowThreads(__tstate);
55580 if (PyErr_Occurred()) SWIG_fail;
55581 }
55582 {
55583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55584 }
55585 return resultobj;
55586 fail:
55587 return NULL;
55588 }
55589
55590
55591 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55592 PyObject *resultobj = 0;
55593 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55594 wxGBSpan *arg2 = 0 ;
55595 bool result;
55596 void *argp1 = 0 ;
55597 int res1 = 0 ;
55598 wxGBSpan temp2 ;
55599 PyObject * obj0 = 0 ;
55600 PyObject * obj1 = 0 ;
55601 char * kwnames[] = {
55602 (char *) "self",(char *) "span", NULL
55603 };
55604
55605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55607 if (!SWIG_IsOK(res1)) {
55608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55609 }
55610 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55611 {
55612 arg2 = &temp2;
55613 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55614 }
55615 {
55616 PyThreadState* __tstate = wxPyBeginAllowThreads();
55617 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55618 wxPyEndAllowThreads(__tstate);
55619 if (PyErr_Occurred()) SWIG_fail;
55620 }
55621 {
55622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55623 }
55624 return resultobj;
55625 fail:
55626 return NULL;
55627 }
55628
55629
55630 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55631 PyObject *resultobj = 0;
55632 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55633 wxGBSizerItem *arg2 = 0 ;
55634 bool result;
55635 void *argp1 = 0 ;
55636 int res1 = 0 ;
55637 void *argp2 = 0 ;
55638 int res2 = 0 ;
55639 PyObject * obj0 = 0 ;
55640 PyObject * obj1 = 0 ;
55641 char * kwnames[] = {
55642 (char *) "self",(char *) "other", NULL
55643 };
55644
55645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55647 if (!SWIG_IsOK(res1)) {
55648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55649 }
55650 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55652 if (!SWIG_IsOK(res2)) {
55653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55654 }
55655 if (!argp2) {
55656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55657 }
55658 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55659 {
55660 PyThreadState* __tstate = wxPyBeginAllowThreads();
55661 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55662 wxPyEndAllowThreads(__tstate);
55663 if (PyErr_Occurred()) SWIG_fail;
55664 }
55665 {
55666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55667 }
55668 return resultobj;
55669 fail:
55670 return NULL;
55671 }
55672
55673
55674 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55675 PyObject *resultobj = 0;
55676 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55677 wxGBPosition *arg2 = 0 ;
55678 wxGBSpan *arg3 = 0 ;
55679 bool result;
55680 void *argp1 = 0 ;
55681 int res1 = 0 ;
55682 wxGBPosition temp2 ;
55683 wxGBSpan temp3 ;
55684 PyObject * obj0 = 0 ;
55685 PyObject * obj1 = 0 ;
55686 PyObject * obj2 = 0 ;
55687 char * kwnames[] = {
55688 (char *) "self",(char *) "pos",(char *) "span", NULL
55689 };
55690
55691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55693 if (!SWIG_IsOK(res1)) {
55694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55695 }
55696 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55697 {
55698 arg2 = &temp2;
55699 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55700 }
55701 {
55702 arg3 = &temp3;
55703 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55704 }
55705 {
55706 PyThreadState* __tstate = wxPyBeginAllowThreads();
55707 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55708 wxPyEndAllowThreads(__tstate);
55709 if (PyErr_Occurred()) SWIG_fail;
55710 }
55711 {
55712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55713 }
55714 return resultobj;
55715 fail:
55716 return NULL;
55717 }
55718
55719
55720 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55721 PyObject *resultobj = 0;
55722 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55723 wxGBPosition result;
55724 void *argp1 = 0 ;
55725 int res1 = 0 ;
55726 PyObject *swig_obj[1] ;
55727
55728 if (!args) SWIG_fail;
55729 swig_obj[0] = args;
55730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55731 if (!SWIG_IsOK(res1)) {
55732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55733 }
55734 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55735 {
55736 PyThreadState* __tstate = wxPyBeginAllowThreads();
55737 result = wxGBSizerItem_GetEndPos(arg1);
55738 wxPyEndAllowThreads(__tstate);
55739 if (PyErr_Occurred()) SWIG_fail;
55740 }
55741 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55742 return resultobj;
55743 fail:
55744 return NULL;
55745 }
55746
55747
55748 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55749 PyObject *resultobj = 0;
55750 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55751 wxGridBagSizer *result = 0 ;
55752 void *argp1 = 0 ;
55753 int res1 = 0 ;
55754 PyObject *swig_obj[1] ;
55755
55756 if (!args) SWIG_fail;
55757 swig_obj[0] = args;
55758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55759 if (!SWIG_IsOK(res1)) {
55760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55761 }
55762 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55763 {
55764 PyThreadState* __tstate = wxPyBeginAllowThreads();
55765 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55766 wxPyEndAllowThreads(__tstate);
55767 if (PyErr_Occurred()) SWIG_fail;
55768 }
55769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55770 return resultobj;
55771 fail:
55772 return NULL;
55773 }
55774
55775
55776 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55777 PyObject *resultobj = 0;
55778 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55779 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55780 void *argp1 = 0 ;
55781 int res1 = 0 ;
55782 void *argp2 = 0 ;
55783 int res2 = 0 ;
55784 PyObject * obj0 = 0 ;
55785 PyObject * obj1 = 0 ;
55786 char * kwnames[] = {
55787 (char *) "self",(char *) "sizer", NULL
55788 };
55789
55790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55792 if (!SWIG_IsOK(res1)) {
55793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55794 }
55795 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55797 if (!SWIG_IsOK(res2)) {
55798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55799 }
55800 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55801 {
55802 PyThreadState* __tstate = wxPyBeginAllowThreads();
55803 (arg1)->SetGBSizer(arg2);
55804 wxPyEndAllowThreads(__tstate);
55805 if (PyErr_Occurred()) SWIG_fail;
55806 }
55807 resultobj = SWIG_Py_Void();
55808 return resultobj;
55809 fail:
55810 return NULL;
55811 }
55812
55813
55814 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55815 PyObject *obj;
55816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55817 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55818 return SWIG_Py_Void();
55819 }
55820
55821 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55822 return SWIG_Python_InitShadowInstance(args);
55823 }
55824
55825 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55826 PyObject *resultobj = 0;
55827 int arg1 = (int) 0 ;
55828 int arg2 = (int) 0 ;
55829 wxGridBagSizer *result = 0 ;
55830 int val1 ;
55831 int ecode1 = 0 ;
55832 int val2 ;
55833 int ecode2 = 0 ;
55834 PyObject * obj0 = 0 ;
55835 PyObject * obj1 = 0 ;
55836 char * kwnames[] = {
55837 (char *) "vgap",(char *) "hgap", NULL
55838 };
55839
55840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55841 if (obj0) {
55842 ecode1 = SWIG_AsVal_int(obj0, &val1);
55843 if (!SWIG_IsOK(ecode1)) {
55844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55845 }
55846 arg1 = static_cast< int >(val1);
55847 }
55848 if (obj1) {
55849 ecode2 = SWIG_AsVal_int(obj1, &val2);
55850 if (!SWIG_IsOK(ecode2)) {
55851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55852 }
55853 arg2 = static_cast< int >(val2);
55854 }
55855 {
55856 PyThreadState* __tstate = wxPyBeginAllowThreads();
55857 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55858 wxPyEndAllowThreads(__tstate);
55859 if (PyErr_Occurred()) SWIG_fail;
55860 }
55861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55862 return resultobj;
55863 fail:
55864 return NULL;
55865 }
55866
55867
55868 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55869 PyObject *resultobj = 0;
55870 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55871 PyObject *arg2 = (PyObject *) 0 ;
55872 wxGBPosition *arg3 = 0 ;
55873 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55874 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55875 int arg5 = (int) 0 ;
55876 int arg6 = (int) 0 ;
55877 PyObject *arg7 = (PyObject *) NULL ;
55878 wxGBSizerItem *result = 0 ;
55879 void *argp1 = 0 ;
55880 int res1 = 0 ;
55881 wxGBPosition temp3 ;
55882 wxGBSpan temp4 ;
55883 int val5 ;
55884 int ecode5 = 0 ;
55885 int val6 ;
55886 int ecode6 = 0 ;
55887 PyObject * obj0 = 0 ;
55888 PyObject * obj1 = 0 ;
55889 PyObject * obj2 = 0 ;
55890 PyObject * obj3 = 0 ;
55891 PyObject * obj4 = 0 ;
55892 PyObject * obj5 = 0 ;
55893 PyObject * obj6 = 0 ;
55894 char * kwnames[] = {
55895 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55896 };
55897
55898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55900 if (!SWIG_IsOK(res1)) {
55901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55902 }
55903 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55904 arg2 = obj1;
55905 {
55906 arg3 = &temp3;
55907 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55908 }
55909 if (obj3) {
55910 {
55911 arg4 = &temp4;
55912 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55913 }
55914 }
55915 if (obj4) {
55916 ecode5 = SWIG_AsVal_int(obj4, &val5);
55917 if (!SWIG_IsOK(ecode5)) {
55918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55919 }
55920 arg5 = static_cast< int >(val5);
55921 }
55922 if (obj5) {
55923 ecode6 = SWIG_AsVal_int(obj5, &val6);
55924 if (!SWIG_IsOK(ecode6)) {
55925 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55926 }
55927 arg6 = static_cast< int >(val6);
55928 }
55929 if (obj6) {
55930 arg7 = obj6;
55931 }
55932 {
55933 PyThreadState* __tstate = wxPyBeginAllowThreads();
55934 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55935 wxPyEndAllowThreads(__tstate);
55936 if (PyErr_Occurred()) SWIG_fail;
55937 }
55938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55939 return resultobj;
55940 fail:
55941 return NULL;
55942 }
55943
55944
55945 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55946 PyObject *resultobj = 0;
55947 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55948 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55949 wxGBSizerItem *result = 0 ;
55950 void *argp1 = 0 ;
55951 int res1 = 0 ;
55952 int res2 = 0 ;
55953 PyObject * obj0 = 0 ;
55954 PyObject * obj1 = 0 ;
55955 char * kwnames[] = {
55956 (char *) "self",(char *) "item", NULL
55957 };
55958
55959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55961 if (!SWIG_IsOK(res1)) {
55962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55963 }
55964 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55965 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55966 if (!SWIG_IsOK(res2)) {
55967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55968 }
55969 {
55970 PyThreadState* __tstate = wxPyBeginAllowThreads();
55971 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55972 wxPyEndAllowThreads(__tstate);
55973 if (PyErr_Occurred()) SWIG_fail;
55974 }
55975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55976 return resultobj;
55977 fail:
55978 return NULL;
55979 }
55980
55981
55982 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55983 PyObject *resultobj = 0;
55984 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55985 int arg2 ;
55986 int arg3 ;
55987 wxSize result;
55988 void *argp1 = 0 ;
55989 int res1 = 0 ;
55990 int val2 ;
55991 int ecode2 = 0 ;
55992 int val3 ;
55993 int ecode3 = 0 ;
55994 PyObject * obj0 = 0 ;
55995 PyObject * obj1 = 0 ;
55996 PyObject * obj2 = 0 ;
55997 char * kwnames[] = {
55998 (char *) "self",(char *) "row",(char *) "col", NULL
55999 };
56000
56001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56003 if (!SWIG_IsOK(res1)) {
56004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56005 }
56006 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56007 ecode2 = SWIG_AsVal_int(obj1, &val2);
56008 if (!SWIG_IsOK(ecode2)) {
56009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
56010 }
56011 arg2 = static_cast< int >(val2);
56012 ecode3 = SWIG_AsVal_int(obj2, &val3);
56013 if (!SWIG_IsOK(ecode3)) {
56014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
56015 }
56016 arg3 = static_cast< int >(val3);
56017 {
56018 PyThreadState* __tstate = wxPyBeginAllowThreads();
56019 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
56020 wxPyEndAllowThreads(__tstate);
56021 if (PyErr_Occurred()) SWIG_fail;
56022 }
56023 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56024 return resultobj;
56025 fail:
56026 return NULL;
56027 }
56028
56029
56030 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56031 PyObject *resultobj = 0;
56032 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56033 wxSize result;
56034 void *argp1 = 0 ;
56035 int res1 = 0 ;
56036 PyObject *swig_obj[1] ;
56037
56038 if (!args) SWIG_fail;
56039 swig_obj[0] = args;
56040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56041 if (!SWIG_IsOK(res1)) {
56042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56043 }
56044 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56045 {
56046 PyThreadState* __tstate = wxPyBeginAllowThreads();
56047 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
56048 wxPyEndAllowThreads(__tstate);
56049 if (PyErr_Occurred()) SWIG_fail;
56050 }
56051 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56052 return resultobj;
56053 fail:
56054 return NULL;
56055 }
56056
56057
56058 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56059 PyObject *resultobj = 0;
56060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56061 wxSize *arg2 = 0 ;
56062 void *argp1 = 0 ;
56063 int res1 = 0 ;
56064 wxSize temp2 ;
56065 PyObject * obj0 = 0 ;
56066 PyObject * obj1 = 0 ;
56067 char * kwnames[] = {
56068 (char *) "self",(char *) "sz", NULL
56069 };
56070
56071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
56072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56073 if (!SWIG_IsOK(res1)) {
56074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56075 }
56076 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56077 {
56078 arg2 = &temp2;
56079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
56080 }
56081 {
56082 PyThreadState* __tstate = wxPyBeginAllowThreads();
56083 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
56084 wxPyEndAllowThreads(__tstate);
56085 if (PyErr_Occurred()) SWIG_fail;
56086 }
56087 resultobj = SWIG_Py_Void();
56088 return resultobj;
56089 fail:
56090 return NULL;
56091 }
56092
56093
56094 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56095 PyObject *resultobj = 0;
56096 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56097 wxWindow *arg2 = (wxWindow *) 0 ;
56098 wxGBPosition result;
56099 void *argp1 = 0 ;
56100 int res1 = 0 ;
56101 void *argp2 = 0 ;
56102 int res2 = 0 ;
56103
56104 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56106 if (!SWIG_IsOK(res1)) {
56107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56108 }
56109 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56110 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56111 if (!SWIG_IsOK(res2)) {
56112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56113 }
56114 arg2 = reinterpret_cast< wxWindow * >(argp2);
56115 {
56116 PyThreadState* __tstate = wxPyBeginAllowThreads();
56117 result = (arg1)->GetItemPosition(arg2);
56118 wxPyEndAllowThreads(__tstate);
56119 if (PyErr_Occurred()) SWIG_fail;
56120 }
56121 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56122 return resultobj;
56123 fail:
56124 return NULL;
56125 }
56126
56127
56128 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56129 PyObject *resultobj = 0;
56130 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56131 wxSizer *arg2 = (wxSizer *) 0 ;
56132 wxGBPosition result;
56133 void *argp1 = 0 ;
56134 int res1 = 0 ;
56135 void *argp2 = 0 ;
56136 int res2 = 0 ;
56137
56138 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56140 if (!SWIG_IsOK(res1)) {
56141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56142 }
56143 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56144 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56145 if (!SWIG_IsOK(res2)) {
56146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56147 }
56148 arg2 = reinterpret_cast< wxSizer * >(argp2);
56149 {
56150 PyThreadState* __tstate = wxPyBeginAllowThreads();
56151 result = (arg1)->GetItemPosition(arg2);
56152 wxPyEndAllowThreads(__tstate);
56153 if (PyErr_Occurred()) SWIG_fail;
56154 }
56155 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56156 return resultobj;
56157 fail:
56158 return NULL;
56159 }
56160
56161
56162 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56163 PyObject *resultobj = 0;
56164 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56165 size_t arg2 ;
56166 wxGBPosition result;
56167 void *argp1 = 0 ;
56168 int res1 = 0 ;
56169 size_t val2 ;
56170 int ecode2 = 0 ;
56171
56172 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56174 if (!SWIG_IsOK(res1)) {
56175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56176 }
56177 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56178 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56179 if (!SWIG_IsOK(ecode2)) {
56180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56181 }
56182 arg2 = static_cast< size_t >(val2);
56183 {
56184 PyThreadState* __tstate = wxPyBeginAllowThreads();
56185 result = (arg1)->GetItemPosition(arg2);
56186 wxPyEndAllowThreads(__tstate);
56187 if (PyErr_Occurred()) SWIG_fail;
56188 }
56189 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56190 return resultobj;
56191 fail:
56192 return NULL;
56193 }
56194
56195
56196 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
56197 int argc;
56198 PyObject *argv[3];
56199
56200 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
56201 --argc;
56202 if (argc == 2) {
56203 int _v = 0;
56204 {
56205 void *vptr = 0;
56206 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56207 _v = SWIG_CheckState(res);
56208 }
56209 if (!_v) goto check_1;
56210 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
56211 }
56212 check_1:
56213
56214 if (argc == 2) {
56215 int _v = 0;
56216 {
56217 void *vptr = 0;
56218 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56219 _v = SWIG_CheckState(res);
56220 }
56221 if (!_v) goto check_2;
56222 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
56223 }
56224 check_2:
56225
56226 if (argc == 2) {
56227 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
56228 }
56229
56230 fail:
56231 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
56232 return NULL;
56233 }
56234
56235
56236 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56237 PyObject *resultobj = 0;
56238 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56239 wxWindow *arg2 = (wxWindow *) 0 ;
56240 wxGBPosition *arg3 = 0 ;
56241 bool result;
56242 void *argp1 = 0 ;
56243 int res1 = 0 ;
56244 void *argp2 = 0 ;
56245 int res2 = 0 ;
56246 wxGBPosition temp3 ;
56247
56248 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56250 if (!SWIG_IsOK(res1)) {
56251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56252 }
56253 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56254 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56255 if (!SWIG_IsOK(res2)) {
56256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56257 }
56258 arg2 = reinterpret_cast< wxWindow * >(argp2);
56259 {
56260 arg3 = &temp3;
56261 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56262 }
56263 {
56264 PyThreadState* __tstate = wxPyBeginAllowThreads();
56265 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56266 wxPyEndAllowThreads(__tstate);
56267 if (PyErr_Occurred()) SWIG_fail;
56268 }
56269 {
56270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56271 }
56272 return resultobj;
56273 fail:
56274 return NULL;
56275 }
56276
56277
56278 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56279 PyObject *resultobj = 0;
56280 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56281 wxSizer *arg2 = (wxSizer *) 0 ;
56282 wxGBPosition *arg3 = 0 ;
56283 bool result;
56284 void *argp1 = 0 ;
56285 int res1 = 0 ;
56286 void *argp2 = 0 ;
56287 int res2 = 0 ;
56288 wxGBPosition temp3 ;
56289
56290 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56292 if (!SWIG_IsOK(res1)) {
56293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56294 }
56295 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56296 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56297 if (!SWIG_IsOK(res2)) {
56298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56299 }
56300 arg2 = reinterpret_cast< wxSizer * >(argp2);
56301 {
56302 arg3 = &temp3;
56303 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56304 }
56305 {
56306 PyThreadState* __tstate = wxPyBeginAllowThreads();
56307 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56308 wxPyEndAllowThreads(__tstate);
56309 if (PyErr_Occurred()) SWIG_fail;
56310 }
56311 {
56312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56313 }
56314 return resultobj;
56315 fail:
56316 return NULL;
56317 }
56318
56319
56320 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56321 PyObject *resultobj = 0;
56322 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56323 size_t arg2 ;
56324 wxGBPosition *arg3 = 0 ;
56325 bool result;
56326 void *argp1 = 0 ;
56327 int res1 = 0 ;
56328 size_t val2 ;
56329 int ecode2 = 0 ;
56330 wxGBPosition temp3 ;
56331
56332 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56334 if (!SWIG_IsOK(res1)) {
56335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56336 }
56337 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56338 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56339 if (!SWIG_IsOK(ecode2)) {
56340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56341 }
56342 arg2 = static_cast< size_t >(val2);
56343 {
56344 arg3 = &temp3;
56345 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56346 }
56347 {
56348 PyThreadState* __tstate = wxPyBeginAllowThreads();
56349 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56350 wxPyEndAllowThreads(__tstate);
56351 if (PyErr_Occurred()) SWIG_fail;
56352 }
56353 {
56354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56355 }
56356 return resultobj;
56357 fail:
56358 return NULL;
56359 }
56360
56361
56362 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
56363 int argc;
56364 PyObject *argv[4];
56365
56366 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
56367 --argc;
56368 if (argc == 3) {
56369 int _v = 0;
56370 {
56371 void *vptr = 0;
56372 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56373 _v = SWIG_CheckState(res);
56374 }
56375 if (!_v) goto check_1;
56376 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
56377 }
56378 check_1:
56379
56380 if (argc == 3) {
56381 int _v = 0;
56382 {
56383 void *vptr = 0;
56384 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56385 _v = SWIG_CheckState(res);
56386 }
56387 if (!_v) goto check_2;
56388 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
56389 }
56390 check_2:
56391
56392 if (argc == 3) {
56393 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
56394 }
56395
56396 fail:
56397 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
56398 return NULL;
56399 }
56400
56401
56402 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56403 PyObject *resultobj = 0;
56404 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56405 wxWindow *arg2 = (wxWindow *) 0 ;
56406 wxGBSpan result;
56407 void *argp1 = 0 ;
56408 int res1 = 0 ;
56409 void *argp2 = 0 ;
56410 int res2 = 0 ;
56411
56412 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56414 if (!SWIG_IsOK(res1)) {
56415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56416 }
56417 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56418 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56419 if (!SWIG_IsOK(res2)) {
56420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56421 }
56422 arg2 = reinterpret_cast< wxWindow * >(argp2);
56423 {
56424 PyThreadState* __tstate = wxPyBeginAllowThreads();
56425 result = (arg1)->GetItemSpan(arg2);
56426 wxPyEndAllowThreads(__tstate);
56427 if (PyErr_Occurred()) SWIG_fail;
56428 }
56429 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56430 return resultobj;
56431 fail:
56432 return NULL;
56433 }
56434
56435
56436 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56437 PyObject *resultobj = 0;
56438 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56439 wxSizer *arg2 = (wxSizer *) 0 ;
56440 wxGBSpan result;
56441 void *argp1 = 0 ;
56442 int res1 = 0 ;
56443 void *argp2 = 0 ;
56444 int res2 = 0 ;
56445
56446 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56448 if (!SWIG_IsOK(res1)) {
56449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56450 }
56451 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56452 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56453 if (!SWIG_IsOK(res2)) {
56454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56455 }
56456 arg2 = reinterpret_cast< wxSizer * >(argp2);
56457 {
56458 PyThreadState* __tstate = wxPyBeginAllowThreads();
56459 result = (arg1)->GetItemSpan(arg2);
56460 wxPyEndAllowThreads(__tstate);
56461 if (PyErr_Occurred()) SWIG_fail;
56462 }
56463 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56464 return resultobj;
56465 fail:
56466 return NULL;
56467 }
56468
56469
56470 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56471 PyObject *resultobj = 0;
56472 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56473 size_t arg2 ;
56474 wxGBSpan result;
56475 void *argp1 = 0 ;
56476 int res1 = 0 ;
56477 size_t val2 ;
56478 int ecode2 = 0 ;
56479
56480 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56482 if (!SWIG_IsOK(res1)) {
56483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56484 }
56485 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56486 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56487 if (!SWIG_IsOK(ecode2)) {
56488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56489 }
56490 arg2 = static_cast< size_t >(val2);
56491 {
56492 PyThreadState* __tstate = wxPyBeginAllowThreads();
56493 result = (arg1)->GetItemSpan(arg2);
56494 wxPyEndAllowThreads(__tstate);
56495 if (PyErr_Occurred()) SWIG_fail;
56496 }
56497 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56498 return resultobj;
56499 fail:
56500 return NULL;
56501 }
56502
56503
56504 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56505 int argc;
56506 PyObject *argv[3];
56507
56508 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56509 --argc;
56510 if (argc == 2) {
56511 int _v = 0;
56512 {
56513 void *vptr = 0;
56514 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56515 _v = SWIG_CheckState(res);
56516 }
56517 if (!_v) goto check_1;
56518 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56519 }
56520 check_1:
56521
56522 if (argc == 2) {
56523 int _v = 0;
56524 {
56525 void *vptr = 0;
56526 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56527 _v = SWIG_CheckState(res);
56528 }
56529 if (!_v) goto check_2;
56530 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56531 }
56532 check_2:
56533
56534 if (argc == 2) {
56535 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56536 }
56537
56538 fail:
56539 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56540 return NULL;
56541 }
56542
56543
56544 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56545 PyObject *resultobj = 0;
56546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56547 wxWindow *arg2 = (wxWindow *) 0 ;
56548 wxGBSpan *arg3 = 0 ;
56549 bool result;
56550 void *argp1 = 0 ;
56551 int res1 = 0 ;
56552 void *argp2 = 0 ;
56553 int res2 = 0 ;
56554 wxGBSpan temp3 ;
56555
56556 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56558 if (!SWIG_IsOK(res1)) {
56559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56560 }
56561 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56562 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56563 if (!SWIG_IsOK(res2)) {
56564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56565 }
56566 arg2 = reinterpret_cast< wxWindow * >(argp2);
56567 {
56568 arg3 = &temp3;
56569 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56570 }
56571 {
56572 PyThreadState* __tstate = wxPyBeginAllowThreads();
56573 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56574 wxPyEndAllowThreads(__tstate);
56575 if (PyErr_Occurred()) SWIG_fail;
56576 }
56577 {
56578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56579 }
56580 return resultobj;
56581 fail:
56582 return NULL;
56583 }
56584
56585
56586 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56587 PyObject *resultobj = 0;
56588 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56589 wxSizer *arg2 = (wxSizer *) 0 ;
56590 wxGBSpan *arg3 = 0 ;
56591 bool result;
56592 void *argp1 = 0 ;
56593 int res1 = 0 ;
56594 void *argp2 = 0 ;
56595 int res2 = 0 ;
56596 wxGBSpan temp3 ;
56597
56598 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56600 if (!SWIG_IsOK(res1)) {
56601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56602 }
56603 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56604 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56605 if (!SWIG_IsOK(res2)) {
56606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56607 }
56608 arg2 = reinterpret_cast< wxSizer * >(argp2);
56609 {
56610 arg3 = &temp3;
56611 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56612 }
56613 {
56614 PyThreadState* __tstate = wxPyBeginAllowThreads();
56615 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56616 wxPyEndAllowThreads(__tstate);
56617 if (PyErr_Occurred()) SWIG_fail;
56618 }
56619 {
56620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56621 }
56622 return resultobj;
56623 fail:
56624 return NULL;
56625 }
56626
56627
56628 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56629 PyObject *resultobj = 0;
56630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56631 size_t arg2 ;
56632 wxGBSpan *arg3 = 0 ;
56633 bool result;
56634 void *argp1 = 0 ;
56635 int res1 = 0 ;
56636 size_t val2 ;
56637 int ecode2 = 0 ;
56638 wxGBSpan temp3 ;
56639
56640 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56642 if (!SWIG_IsOK(res1)) {
56643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56644 }
56645 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56646 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56647 if (!SWIG_IsOK(ecode2)) {
56648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56649 }
56650 arg2 = static_cast< size_t >(val2);
56651 {
56652 arg3 = &temp3;
56653 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56654 }
56655 {
56656 PyThreadState* __tstate = wxPyBeginAllowThreads();
56657 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56658 wxPyEndAllowThreads(__tstate);
56659 if (PyErr_Occurred()) SWIG_fail;
56660 }
56661 {
56662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56663 }
56664 return resultobj;
56665 fail:
56666 return NULL;
56667 }
56668
56669
56670 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56671 int argc;
56672 PyObject *argv[4];
56673
56674 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56675 --argc;
56676 if (argc == 3) {
56677 int _v = 0;
56678 {
56679 void *vptr = 0;
56680 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56681 _v = SWIG_CheckState(res);
56682 }
56683 if (!_v) goto check_1;
56684 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56685 }
56686 check_1:
56687
56688 if (argc == 3) {
56689 int _v = 0;
56690 {
56691 void *vptr = 0;
56692 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56693 _v = SWIG_CheckState(res);
56694 }
56695 if (!_v) goto check_2;
56696 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56697 }
56698 check_2:
56699
56700 if (argc == 3) {
56701 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56702 }
56703
56704 fail:
56705 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56706 return NULL;
56707 }
56708
56709
56710 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56711 PyObject *resultobj = 0;
56712 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56713 wxWindow *arg2 = (wxWindow *) 0 ;
56714 wxGBSizerItem *result = 0 ;
56715 void *argp1 = 0 ;
56716 int res1 = 0 ;
56717 void *argp2 = 0 ;
56718 int res2 = 0 ;
56719
56720 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56722 if (!SWIG_IsOK(res1)) {
56723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56724 }
56725 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56726 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56727 if (!SWIG_IsOK(res2)) {
56728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56729 }
56730 arg2 = reinterpret_cast< wxWindow * >(argp2);
56731 {
56732 PyThreadState* __tstate = wxPyBeginAllowThreads();
56733 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56734 wxPyEndAllowThreads(__tstate);
56735 if (PyErr_Occurred()) SWIG_fail;
56736 }
56737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56738 return resultobj;
56739 fail:
56740 return NULL;
56741 }
56742
56743
56744 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56745 PyObject *resultobj = 0;
56746 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56747 wxSizer *arg2 = (wxSizer *) 0 ;
56748 wxGBSizerItem *result = 0 ;
56749 void *argp1 = 0 ;
56750 int res1 = 0 ;
56751 void *argp2 = 0 ;
56752 int res2 = 0 ;
56753
56754 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56756 if (!SWIG_IsOK(res1)) {
56757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56758 }
56759 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56760 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56761 if (!SWIG_IsOK(res2)) {
56762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56763 }
56764 arg2 = reinterpret_cast< wxSizer * >(argp2);
56765 {
56766 PyThreadState* __tstate = wxPyBeginAllowThreads();
56767 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56768 wxPyEndAllowThreads(__tstate);
56769 if (PyErr_Occurred()) SWIG_fail;
56770 }
56771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56772 return resultobj;
56773 fail:
56774 return NULL;
56775 }
56776
56777
56778 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56779 int argc;
56780 PyObject *argv[3];
56781
56782 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56783 --argc;
56784 if (argc == 2) {
56785 int _v = 0;
56786 {
56787 void *vptr = 0;
56788 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56789 _v = SWIG_CheckState(res);
56790 }
56791 if (!_v) goto check_1;
56792 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56793 }
56794 check_1:
56795
56796 if (argc == 2) {
56797 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56798 }
56799
56800 fail:
56801 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56802 return NULL;
56803 }
56804
56805
56806 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56807 PyObject *resultobj = 0;
56808 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56809 wxGBPosition *arg2 = 0 ;
56810 wxGBSizerItem *result = 0 ;
56811 void *argp1 = 0 ;
56812 int res1 = 0 ;
56813 wxGBPosition temp2 ;
56814 PyObject * obj0 = 0 ;
56815 PyObject * obj1 = 0 ;
56816 char * kwnames[] = {
56817 (char *) "self",(char *) "pos", NULL
56818 };
56819
56820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56822 if (!SWIG_IsOK(res1)) {
56823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56824 }
56825 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56826 {
56827 arg2 = &temp2;
56828 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56829 }
56830 {
56831 PyThreadState* __tstate = wxPyBeginAllowThreads();
56832 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56833 wxPyEndAllowThreads(__tstate);
56834 if (PyErr_Occurred()) SWIG_fail;
56835 }
56836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56837 return resultobj;
56838 fail:
56839 return NULL;
56840 }
56841
56842
56843 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56844 PyObject *resultobj = 0;
56845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56846 wxPoint *arg2 = 0 ;
56847 wxGBSizerItem *result = 0 ;
56848 void *argp1 = 0 ;
56849 int res1 = 0 ;
56850 wxPoint temp2 ;
56851 PyObject * obj0 = 0 ;
56852 PyObject * obj1 = 0 ;
56853 char * kwnames[] = {
56854 (char *) "self",(char *) "pt", NULL
56855 };
56856
56857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56859 if (!SWIG_IsOK(res1)) {
56860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56861 }
56862 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56863 {
56864 arg2 = &temp2;
56865 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56866 }
56867 {
56868 PyThreadState* __tstate = wxPyBeginAllowThreads();
56869 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56870 wxPyEndAllowThreads(__tstate);
56871 if (PyErr_Occurred()) SWIG_fail;
56872 }
56873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56874 return resultobj;
56875 fail:
56876 return NULL;
56877 }
56878
56879
56880 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56881 PyObject *resultobj = 0;
56882 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56883 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56884 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56885 bool result;
56886 void *argp1 = 0 ;
56887 int res1 = 0 ;
56888 void *argp2 = 0 ;
56889 int res2 = 0 ;
56890 void *argp3 = 0 ;
56891 int res3 = 0 ;
56892 PyObject * obj0 = 0 ;
56893 PyObject * obj1 = 0 ;
56894 PyObject * obj2 = 0 ;
56895 char * kwnames[] = {
56896 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56897 };
56898
56899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56901 if (!SWIG_IsOK(res1)) {
56902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56903 }
56904 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56905 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56906 if (!SWIG_IsOK(res2)) {
56907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56908 }
56909 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56910 if (obj2) {
56911 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56912 if (!SWIG_IsOK(res3)) {
56913 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56914 }
56915 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56916 }
56917 {
56918 PyThreadState* __tstate = wxPyBeginAllowThreads();
56919 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56920 wxPyEndAllowThreads(__tstate);
56921 if (PyErr_Occurred()) SWIG_fail;
56922 }
56923 {
56924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56925 }
56926 return resultobj;
56927 fail:
56928 return NULL;
56929 }
56930
56931
56932 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56933 PyObject *resultobj = 0;
56934 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56935 wxGBPosition *arg2 = 0 ;
56936 wxGBSpan *arg3 = 0 ;
56937 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56938 bool result;
56939 void *argp1 = 0 ;
56940 int res1 = 0 ;
56941 wxGBPosition temp2 ;
56942 wxGBSpan temp3 ;
56943 void *argp4 = 0 ;
56944 int res4 = 0 ;
56945 PyObject * obj0 = 0 ;
56946 PyObject * obj1 = 0 ;
56947 PyObject * obj2 = 0 ;
56948 PyObject * obj3 = 0 ;
56949 char * kwnames[] = {
56950 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56951 };
56952
56953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56955 if (!SWIG_IsOK(res1)) {
56956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56957 }
56958 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56959 {
56960 arg2 = &temp2;
56961 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56962 }
56963 {
56964 arg3 = &temp3;
56965 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56966 }
56967 if (obj3) {
56968 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56969 if (!SWIG_IsOK(res4)) {
56970 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56971 }
56972 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56973 }
56974 {
56975 PyThreadState* __tstate = wxPyBeginAllowThreads();
56976 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56977 wxPyEndAllowThreads(__tstate);
56978 if (PyErr_Occurred()) SWIG_fail;
56979 }
56980 {
56981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56982 }
56983 return resultobj;
56984 fail:
56985 return NULL;
56986 }
56987
56988
56989 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56990 PyObject *obj;
56991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56992 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56993 return SWIG_Py_Void();
56994 }
56995
56996 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56997 return SWIG_Python_InitShadowInstance(args);
56998 }
56999
57000 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57001 PyObject *resultobj = 0;
57002 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57003 wxRelationship arg2 ;
57004 wxWindow *arg3 = (wxWindow *) 0 ;
57005 wxEdge arg4 ;
57006 int arg5 = (int) 0 ;
57007 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
57008 void *argp1 = 0 ;
57009 int res1 = 0 ;
57010 int val2 ;
57011 int ecode2 = 0 ;
57012 void *argp3 = 0 ;
57013 int res3 = 0 ;
57014 int val4 ;
57015 int ecode4 = 0 ;
57016 int val5 ;
57017 int ecode5 = 0 ;
57018 int val6 ;
57019 int ecode6 = 0 ;
57020 PyObject * obj0 = 0 ;
57021 PyObject * obj1 = 0 ;
57022 PyObject * obj2 = 0 ;
57023 PyObject * obj3 = 0 ;
57024 PyObject * obj4 = 0 ;
57025 PyObject * obj5 = 0 ;
57026 char * kwnames[] = {
57027 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
57028 };
57029
57030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
57031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57032 if (!SWIG_IsOK(res1)) {
57033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57034 }
57035 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57036 ecode2 = SWIG_AsVal_int(obj1, &val2);
57037 if (!SWIG_IsOK(ecode2)) {
57038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
57039 }
57040 arg2 = static_cast< wxRelationship >(val2);
57041 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57042 if (!SWIG_IsOK(res3)) {
57043 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
57044 }
57045 arg3 = reinterpret_cast< wxWindow * >(argp3);
57046 ecode4 = SWIG_AsVal_int(obj3, &val4);
57047 if (!SWIG_IsOK(ecode4)) {
57048 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
57049 }
57050 arg4 = static_cast< wxEdge >(val4);
57051 if (obj4) {
57052 ecode5 = SWIG_AsVal_int(obj4, &val5);
57053 if (!SWIG_IsOK(ecode5)) {
57054 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
57055 }
57056 arg5 = static_cast< int >(val5);
57057 }
57058 if (obj5) {
57059 ecode6 = SWIG_AsVal_int(obj5, &val6);
57060 if (!SWIG_IsOK(ecode6)) {
57061 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
57062 }
57063 arg6 = static_cast< int >(val6);
57064 }
57065 {
57066 PyThreadState* __tstate = wxPyBeginAllowThreads();
57067 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
57068 wxPyEndAllowThreads(__tstate);
57069 if (PyErr_Occurred()) SWIG_fail;
57070 }
57071 resultobj = SWIG_Py_Void();
57072 return resultobj;
57073 fail:
57074 return NULL;
57075 }
57076
57077
57078 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57079 PyObject *resultobj = 0;
57080 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57081 wxWindow *arg2 = (wxWindow *) 0 ;
57082 int arg3 = (int) 0 ;
57083 void *argp1 = 0 ;
57084 int res1 = 0 ;
57085 void *argp2 = 0 ;
57086 int res2 = 0 ;
57087 int val3 ;
57088 int ecode3 = 0 ;
57089 PyObject * obj0 = 0 ;
57090 PyObject * obj1 = 0 ;
57091 PyObject * obj2 = 0 ;
57092 char * kwnames[] = {
57093 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57094 };
57095
57096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57098 if (!SWIG_IsOK(res1)) {
57099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57100 }
57101 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57103 if (!SWIG_IsOK(res2)) {
57104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57105 }
57106 arg2 = reinterpret_cast< wxWindow * >(argp2);
57107 if (obj2) {
57108 ecode3 = SWIG_AsVal_int(obj2, &val3);
57109 if (!SWIG_IsOK(ecode3)) {
57110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
57111 }
57112 arg3 = static_cast< int >(val3);
57113 }
57114 {
57115 PyThreadState* __tstate = wxPyBeginAllowThreads();
57116 (arg1)->LeftOf(arg2,arg3);
57117 wxPyEndAllowThreads(__tstate);
57118 if (PyErr_Occurred()) SWIG_fail;
57119 }
57120 resultobj = SWIG_Py_Void();
57121 return resultobj;
57122 fail:
57123 return NULL;
57124 }
57125
57126
57127 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57128 PyObject *resultobj = 0;
57129 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57130 wxWindow *arg2 = (wxWindow *) 0 ;
57131 int arg3 = (int) 0 ;
57132 void *argp1 = 0 ;
57133 int res1 = 0 ;
57134 void *argp2 = 0 ;
57135 int res2 = 0 ;
57136 int val3 ;
57137 int ecode3 = 0 ;
57138 PyObject * obj0 = 0 ;
57139 PyObject * obj1 = 0 ;
57140 PyObject * obj2 = 0 ;
57141 char * kwnames[] = {
57142 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57143 };
57144
57145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57147 if (!SWIG_IsOK(res1)) {
57148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57149 }
57150 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57152 if (!SWIG_IsOK(res2)) {
57153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57154 }
57155 arg2 = reinterpret_cast< wxWindow * >(argp2);
57156 if (obj2) {
57157 ecode3 = SWIG_AsVal_int(obj2, &val3);
57158 if (!SWIG_IsOK(ecode3)) {
57159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
57160 }
57161 arg3 = static_cast< int >(val3);
57162 }
57163 {
57164 PyThreadState* __tstate = wxPyBeginAllowThreads();
57165 (arg1)->RightOf(arg2,arg3);
57166 wxPyEndAllowThreads(__tstate);
57167 if (PyErr_Occurred()) SWIG_fail;
57168 }
57169 resultobj = SWIG_Py_Void();
57170 return resultobj;
57171 fail:
57172 return NULL;
57173 }
57174
57175
57176 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57177 PyObject *resultobj = 0;
57178 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57179 wxWindow *arg2 = (wxWindow *) 0 ;
57180 int arg3 = (int) 0 ;
57181 void *argp1 = 0 ;
57182 int res1 = 0 ;
57183 void *argp2 = 0 ;
57184 int res2 = 0 ;
57185 int val3 ;
57186 int ecode3 = 0 ;
57187 PyObject * obj0 = 0 ;
57188 PyObject * obj1 = 0 ;
57189 PyObject * obj2 = 0 ;
57190 char * kwnames[] = {
57191 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57192 };
57193
57194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57196 if (!SWIG_IsOK(res1)) {
57197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57198 }
57199 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57201 if (!SWIG_IsOK(res2)) {
57202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
57203 }
57204 arg2 = reinterpret_cast< wxWindow * >(argp2);
57205 if (obj2) {
57206 ecode3 = SWIG_AsVal_int(obj2, &val3);
57207 if (!SWIG_IsOK(ecode3)) {
57208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
57209 }
57210 arg3 = static_cast< int >(val3);
57211 }
57212 {
57213 PyThreadState* __tstate = wxPyBeginAllowThreads();
57214 (arg1)->Above(arg2,arg3);
57215 wxPyEndAllowThreads(__tstate);
57216 if (PyErr_Occurred()) SWIG_fail;
57217 }
57218 resultobj = SWIG_Py_Void();
57219 return resultobj;
57220 fail:
57221 return NULL;
57222 }
57223
57224
57225 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57226 PyObject *resultobj = 0;
57227 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57228 wxWindow *arg2 = (wxWindow *) 0 ;
57229 int arg3 = (int) 0 ;
57230 void *argp1 = 0 ;
57231 int res1 = 0 ;
57232 void *argp2 = 0 ;
57233 int res2 = 0 ;
57234 int val3 ;
57235 int ecode3 = 0 ;
57236 PyObject * obj0 = 0 ;
57237 PyObject * obj1 = 0 ;
57238 PyObject * obj2 = 0 ;
57239 char * kwnames[] = {
57240 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57241 };
57242
57243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57245 if (!SWIG_IsOK(res1)) {
57246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57247 }
57248 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57249 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57250 if (!SWIG_IsOK(res2)) {
57251 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
57252 }
57253 arg2 = reinterpret_cast< wxWindow * >(argp2);
57254 if (obj2) {
57255 ecode3 = SWIG_AsVal_int(obj2, &val3);
57256 if (!SWIG_IsOK(ecode3)) {
57257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
57258 }
57259 arg3 = static_cast< int >(val3);
57260 }
57261 {
57262 PyThreadState* __tstate = wxPyBeginAllowThreads();
57263 (arg1)->Below(arg2,arg3);
57264 wxPyEndAllowThreads(__tstate);
57265 if (PyErr_Occurred()) SWIG_fail;
57266 }
57267 resultobj = SWIG_Py_Void();
57268 return resultobj;
57269 fail:
57270 return NULL;
57271 }
57272
57273
57274 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57275 PyObject *resultobj = 0;
57276 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57277 wxWindow *arg2 = (wxWindow *) 0 ;
57278 wxEdge arg3 ;
57279 int arg4 = (int) 0 ;
57280 void *argp1 = 0 ;
57281 int res1 = 0 ;
57282 void *argp2 = 0 ;
57283 int res2 = 0 ;
57284 int val3 ;
57285 int ecode3 = 0 ;
57286 int val4 ;
57287 int ecode4 = 0 ;
57288 PyObject * obj0 = 0 ;
57289 PyObject * obj1 = 0 ;
57290 PyObject * obj2 = 0 ;
57291 PyObject * obj3 = 0 ;
57292 char * kwnames[] = {
57293 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
57294 };
57295
57296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57298 if (!SWIG_IsOK(res1)) {
57299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57300 }
57301 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57303 if (!SWIG_IsOK(res2)) {
57304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
57305 }
57306 arg2 = reinterpret_cast< wxWindow * >(argp2);
57307 ecode3 = SWIG_AsVal_int(obj2, &val3);
57308 if (!SWIG_IsOK(ecode3)) {
57309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
57310 }
57311 arg3 = static_cast< wxEdge >(val3);
57312 if (obj3) {
57313 ecode4 = SWIG_AsVal_int(obj3, &val4);
57314 if (!SWIG_IsOK(ecode4)) {
57315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
57316 }
57317 arg4 = static_cast< int >(val4);
57318 }
57319 {
57320 PyThreadState* __tstate = wxPyBeginAllowThreads();
57321 (arg1)->SameAs(arg2,arg3,arg4);
57322 wxPyEndAllowThreads(__tstate);
57323 if (PyErr_Occurred()) SWIG_fail;
57324 }
57325 resultobj = SWIG_Py_Void();
57326 return resultobj;
57327 fail:
57328 return NULL;
57329 }
57330
57331
57332 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57333 PyObject *resultobj = 0;
57334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57335 wxWindow *arg2 = (wxWindow *) 0 ;
57336 wxEdge arg3 ;
57337 int arg4 ;
57338 void *argp1 = 0 ;
57339 int res1 = 0 ;
57340 void *argp2 = 0 ;
57341 int res2 = 0 ;
57342 int val3 ;
57343 int ecode3 = 0 ;
57344 int val4 ;
57345 int ecode4 = 0 ;
57346 PyObject * obj0 = 0 ;
57347 PyObject * obj1 = 0 ;
57348 PyObject * obj2 = 0 ;
57349 PyObject * obj3 = 0 ;
57350 char * kwnames[] = {
57351 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
57352 };
57353
57354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57356 if (!SWIG_IsOK(res1)) {
57357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57358 }
57359 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57361 if (!SWIG_IsOK(res2)) {
57362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57363 }
57364 arg2 = reinterpret_cast< wxWindow * >(argp2);
57365 ecode3 = SWIG_AsVal_int(obj2, &val3);
57366 if (!SWIG_IsOK(ecode3)) {
57367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
57368 }
57369 arg3 = static_cast< wxEdge >(val3);
57370 ecode4 = SWIG_AsVal_int(obj3, &val4);
57371 if (!SWIG_IsOK(ecode4)) {
57372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
57373 }
57374 arg4 = static_cast< int >(val4);
57375 {
57376 PyThreadState* __tstate = wxPyBeginAllowThreads();
57377 (arg1)->PercentOf(arg2,arg3,arg4);
57378 wxPyEndAllowThreads(__tstate);
57379 if (PyErr_Occurred()) SWIG_fail;
57380 }
57381 resultobj = SWIG_Py_Void();
57382 return resultobj;
57383 fail:
57384 return NULL;
57385 }
57386
57387
57388 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57389 PyObject *resultobj = 0;
57390 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57391 int arg2 ;
57392 void *argp1 = 0 ;
57393 int res1 = 0 ;
57394 int val2 ;
57395 int ecode2 = 0 ;
57396 PyObject * obj0 = 0 ;
57397 PyObject * obj1 = 0 ;
57398 char * kwnames[] = {
57399 (char *) "self",(char *) "val", NULL
57400 };
57401
57402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
57403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57404 if (!SWIG_IsOK(res1)) {
57405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57406 }
57407 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57408 ecode2 = SWIG_AsVal_int(obj1, &val2);
57409 if (!SWIG_IsOK(ecode2)) {
57410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
57411 }
57412 arg2 = static_cast< int >(val2);
57413 {
57414 PyThreadState* __tstate = wxPyBeginAllowThreads();
57415 (arg1)->Absolute(arg2);
57416 wxPyEndAllowThreads(__tstate);
57417 if (PyErr_Occurred()) SWIG_fail;
57418 }
57419 resultobj = SWIG_Py_Void();
57420 return resultobj;
57421 fail:
57422 return NULL;
57423 }
57424
57425
57426 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57427 PyObject *resultobj = 0;
57428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57429 void *argp1 = 0 ;
57430 int res1 = 0 ;
57431 PyObject *swig_obj[1] ;
57432
57433 if (!args) SWIG_fail;
57434 swig_obj[0] = args;
57435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57436 if (!SWIG_IsOK(res1)) {
57437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57438 }
57439 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57440 {
57441 PyThreadState* __tstate = wxPyBeginAllowThreads();
57442 (arg1)->Unconstrained();
57443 wxPyEndAllowThreads(__tstate);
57444 if (PyErr_Occurred()) SWIG_fail;
57445 }
57446 resultobj = SWIG_Py_Void();
57447 return resultobj;
57448 fail:
57449 return NULL;
57450 }
57451
57452
57453 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57454 PyObject *resultobj = 0;
57455 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57456 void *argp1 = 0 ;
57457 int res1 = 0 ;
57458 PyObject *swig_obj[1] ;
57459
57460 if (!args) SWIG_fail;
57461 swig_obj[0] = args;
57462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57463 if (!SWIG_IsOK(res1)) {
57464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57465 }
57466 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57467 {
57468 PyThreadState* __tstate = wxPyBeginAllowThreads();
57469 (arg1)->AsIs();
57470 wxPyEndAllowThreads(__tstate);
57471 if (PyErr_Occurred()) SWIG_fail;
57472 }
57473 resultobj = SWIG_Py_Void();
57474 return resultobj;
57475 fail:
57476 return NULL;
57477 }
57478
57479
57480 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57481 PyObject *resultobj = 0;
57482 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57483 wxWindow *result = 0 ;
57484 void *argp1 = 0 ;
57485 int res1 = 0 ;
57486 PyObject *swig_obj[1] ;
57487
57488 if (!args) SWIG_fail;
57489 swig_obj[0] = args;
57490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57491 if (!SWIG_IsOK(res1)) {
57492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57493 }
57494 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57495 {
57496 PyThreadState* __tstate = wxPyBeginAllowThreads();
57497 result = (wxWindow *)(arg1)->GetOtherWindow();
57498 wxPyEndAllowThreads(__tstate);
57499 if (PyErr_Occurred()) SWIG_fail;
57500 }
57501 {
57502 resultobj = wxPyMake_wxObject(result, 0);
57503 }
57504 return resultobj;
57505 fail:
57506 return NULL;
57507 }
57508
57509
57510 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57511 PyObject *resultobj = 0;
57512 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57513 wxEdge result;
57514 void *argp1 = 0 ;
57515 int res1 = 0 ;
57516 PyObject *swig_obj[1] ;
57517
57518 if (!args) SWIG_fail;
57519 swig_obj[0] = args;
57520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57521 if (!SWIG_IsOK(res1)) {
57522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57523 }
57524 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57525 {
57526 PyThreadState* __tstate = wxPyBeginAllowThreads();
57527 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57528 wxPyEndAllowThreads(__tstate);
57529 if (PyErr_Occurred()) SWIG_fail;
57530 }
57531 resultobj = SWIG_From_int(static_cast< int >(result));
57532 return resultobj;
57533 fail:
57534 return NULL;
57535 }
57536
57537
57538 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57539 PyObject *resultobj = 0;
57540 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57541 wxEdge arg2 ;
57542 void *argp1 = 0 ;
57543 int res1 = 0 ;
57544 int val2 ;
57545 int ecode2 = 0 ;
57546 PyObject * obj0 = 0 ;
57547 PyObject * obj1 = 0 ;
57548 char * kwnames[] = {
57549 (char *) "self",(char *) "which", NULL
57550 };
57551
57552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57554 if (!SWIG_IsOK(res1)) {
57555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57556 }
57557 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57558 ecode2 = SWIG_AsVal_int(obj1, &val2);
57559 if (!SWIG_IsOK(ecode2)) {
57560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57561 }
57562 arg2 = static_cast< wxEdge >(val2);
57563 {
57564 PyThreadState* __tstate = wxPyBeginAllowThreads();
57565 (arg1)->SetEdge(arg2);
57566 wxPyEndAllowThreads(__tstate);
57567 if (PyErr_Occurred()) SWIG_fail;
57568 }
57569 resultobj = SWIG_Py_Void();
57570 return resultobj;
57571 fail:
57572 return NULL;
57573 }
57574
57575
57576 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57577 PyObject *resultobj = 0;
57578 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57579 int arg2 ;
57580 void *argp1 = 0 ;
57581 int res1 = 0 ;
57582 int val2 ;
57583 int ecode2 = 0 ;
57584 PyObject * obj0 = 0 ;
57585 PyObject * obj1 = 0 ;
57586 char * kwnames[] = {
57587 (char *) "self",(char *) "v", NULL
57588 };
57589
57590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57592 if (!SWIG_IsOK(res1)) {
57593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57594 }
57595 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57596 ecode2 = SWIG_AsVal_int(obj1, &val2);
57597 if (!SWIG_IsOK(ecode2)) {
57598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57599 }
57600 arg2 = static_cast< int >(val2);
57601 {
57602 PyThreadState* __tstate = wxPyBeginAllowThreads();
57603 (arg1)->SetValue(arg2);
57604 wxPyEndAllowThreads(__tstate);
57605 if (PyErr_Occurred()) SWIG_fail;
57606 }
57607 resultobj = SWIG_Py_Void();
57608 return resultobj;
57609 fail:
57610 return NULL;
57611 }
57612
57613
57614 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57615 PyObject *resultobj = 0;
57616 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57617 int result;
57618 void *argp1 = 0 ;
57619 int res1 = 0 ;
57620 PyObject *swig_obj[1] ;
57621
57622 if (!args) SWIG_fail;
57623 swig_obj[0] = args;
57624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57625 if (!SWIG_IsOK(res1)) {
57626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57627 }
57628 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57629 {
57630 PyThreadState* __tstate = wxPyBeginAllowThreads();
57631 result = (int)(arg1)->GetMargin();
57632 wxPyEndAllowThreads(__tstate);
57633 if (PyErr_Occurred()) SWIG_fail;
57634 }
57635 resultobj = SWIG_From_int(static_cast< int >(result));
57636 return resultobj;
57637 fail:
57638 return NULL;
57639 }
57640
57641
57642 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57643 PyObject *resultobj = 0;
57644 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57645 int arg2 ;
57646 void *argp1 = 0 ;
57647 int res1 = 0 ;
57648 int val2 ;
57649 int ecode2 = 0 ;
57650 PyObject * obj0 = 0 ;
57651 PyObject * obj1 = 0 ;
57652 char * kwnames[] = {
57653 (char *) "self",(char *) "m", NULL
57654 };
57655
57656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57658 if (!SWIG_IsOK(res1)) {
57659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57660 }
57661 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57662 ecode2 = SWIG_AsVal_int(obj1, &val2);
57663 if (!SWIG_IsOK(ecode2)) {
57664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57665 }
57666 arg2 = static_cast< int >(val2);
57667 {
57668 PyThreadState* __tstate = wxPyBeginAllowThreads();
57669 (arg1)->SetMargin(arg2);
57670 wxPyEndAllowThreads(__tstate);
57671 if (PyErr_Occurred()) SWIG_fail;
57672 }
57673 resultobj = SWIG_Py_Void();
57674 return resultobj;
57675 fail:
57676 return NULL;
57677 }
57678
57679
57680 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57681 PyObject *resultobj = 0;
57682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57683 int result;
57684 void *argp1 = 0 ;
57685 int res1 = 0 ;
57686 PyObject *swig_obj[1] ;
57687
57688 if (!args) SWIG_fail;
57689 swig_obj[0] = args;
57690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57691 if (!SWIG_IsOK(res1)) {
57692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57693 }
57694 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57695 {
57696 PyThreadState* __tstate = wxPyBeginAllowThreads();
57697 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57698 wxPyEndAllowThreads(__tstate);
57699 if (PyErr_Occurred()) SWIG_fail;
57700 }
57701 resultobj = SWIG_From_int(static_cast< int >(result));
57702 return resultobj;
57703 fail:
57704 return NULL;
57705 }
57706
57707
57708 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57709 PyObject *resultobj = 0;
57710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57711 int result;
57712 void *argp1 = 0 ;
57713 int res1 = 0 ;
57714 PyObject *swig_obj[1] ;
57715
57716 if (!args) SWIG_fail;
57717 swig_obj[0] = args;
57718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57719 if (!SWIG_IsOK(res1)) {
57720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57721 }
57722 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57723 {
57724 PyThreadState* __tstate = wxPyBeginAllowThreads();
57725 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57726 wxPyEndAllowThreads(__tstate);
57727 if (PyErr_Occurred()) SWIG_fail;
57728 }
57729 resultobj = SWIG_From_int(static_cast< int >(result));
57730 return resultobj;
57731 fail:
57732 return NULL;
57733 }
57734
57735
57736 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57737 PyObject *resultobj = 0;
57738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57739 int result;
57740 void *argp1 = 0 ;
57741 int res1 = 0 ;
57742 PyObject *swig_obj[1] ;
57743
57744 if (!args) SWIG_fail;
57745 swig_obj[0] = args;
57746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57747 if (!SWIG_IsOK(res1)) {
57748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57749 }
57750 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57751 {
57752 PyThreadState* __tstate = wxPyBeginAllowThreads();
57753 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57754 wxPyEndAllowThreads(__tstate);
57755 if (PyErr_Occurred()) SWIG_fail;
57756 }
57757 resultobj = SWIG_From_int(static_cast< int >(result));
57758 return resultobj;
57759 fail:
57760 return NULL;
57761 }
57762
57763
57764 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57765 PyObject *resultobj = 0;
57766 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57767 bool result;
57768 void *argp1 = 0 ;
57769 int res1 = 0 ;
57770 PyObject *swig_obj[1] ;
57771
57772 if (!args) SWIG_fail;
57773 swig_obj[0] = args;
57774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57775 if (!SWIG_IsOK(res1)) {
57776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57777 }
57778 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57779 {
57780 PyThreadState* __tstate = wxPyBeginAllowThreads();
57781 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57782 wxPyEndAllowThreads(__tstate);
57783 if (PyErr_Occurred()) SWIG_fail;
57784 }
57785 {
57786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57787 }
57788 return resultobj;
57789 fail:
57790 return NULL;
57791 }
57792
57793
57794 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57795 PyObject *resultobj = 0;
57796 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57797 bool arg2 ;
57798 void *argp1 = 0 ;
57799 int res1 = 0 ;
57800 bool val2 ;
57801 int ecode2 = 0 ;
57802 PyObject * obj0 = 0 ;
57803 PyObject * obj1 = 0 ;
57804 char * kwnames[] = {
57805 (char *) "self",(char *) "d", NULL
57806 };
57807
57808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57810 if (!SWIG_IsOK(res1)) {
57811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57812 }
57813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57815 if (!SWIG_IsOK(ecode2)) {
57816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57817 }
57818 arg2 = static_cast< bool >(val2);
57819 {
57820 PyThreadState* __tstate = wxPyBeginAllowThreads();
57821 (arg1)->SetDone(arg2);
57822 wxPyEndAllowThreads(__tstate);
57823 if (PyErr_Occurred()) SWIG_fail;
57824 }
57825 resultobj = SWIG_Py_Void();
57826 return resultobj;
57827 fail:
57828 return NULL;
57829 }
57830
57831
57832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57833 PyObject *resultobj = 0;
57834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57835 wxRelationship result;
57836 void *argp1 = 0 ;
57837 int res1 = 0 ;
57838 PyObject *swig_obj[1] ;
57839
57840 if (!args) SWIG_fail;
57841 swig_obj[0] = args;
57842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57843 if (!SWIG_IsOK(res1)) {
57844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57845 }
57846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57847 {
57848 PyThreadState* __tstate = wxPyBeginAllowThreads();
57849 result = (wxRelationship)(arg1)->GetRelationship();
57850 wxPyEndAllowThreads(__tstate);
57851 if (PyErr_Occurred()) SWIG_fail;
57852 }
57853 resultobj = SWIG_From_int(static_cast< int >(result));
57854 return resultobj;
57855 fail:
57856 return NULL;
57857 }
57858
57859
57860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57861 PyObject *resultobj = 0;
57862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57863 wxRelationship arg2 ;
57864 void *argp1 = 0 ;
57865 int res1 = 0 ;
57866 int val2 ;
57867 int ecode2 = 0 ;
57868 PyObject * obj0 = 0 ;
57869 PyObject * obj1 = 0 ;
57870 char * kwnames[] = {
57871 (char *) "self",(char *) "r", NULL
57872 };
57873
57874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57876 if (!SWIG_IsOK(res1)) {
57877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57878 }
57879 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57880 ecode2 = SWIG_AsVal_int(obj1, &val2);
57881 if (!SWIG_IsOK(ecode2)) {
57882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57883 }
57884 arg2 = static_cast< wxRelationship >(val2);
57885 {
57886 PyThreadState* __tstate = wxPyBeginAllowThreads();
57887 (arg1)->SetRelationship(arg2);
57888 wxPyEndAllowThreads(__tstate);
57889 if (PyErr_Occurred()) SWIG_fail;
57890 }
57891 resultobj = SWIG_Py_Void();
57892 return resultobj;
57893 fail:
57894 return NULL;
57895 }
57896
57897
57898 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57899 PyObject *resultobj = 0;
57900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57901 wxWindow *arg2 = (wxWindow *) 0 ;
57902 bool result;
57903 void *argp1 = 0 ;
57904 int res1 = 0 ;
57905 void *argp2 = 0 ;
57906 int res2 = 0 ;
57907 PyObject * obj0 = 0 ;
57908 PyObject * obj1 = 0 ;
57909 char * kwnames[] = {
57910 (char *) "self",(char *) "otherW", NULL
57911 };
57912
57913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57915 if (!SWIG_IsOK(res1)) {
57916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57917 }
57918 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57920 if (!SWIG_IsOK(res2)) {
57921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57922 }
57923 arg2 = reinterpret_cast< wxWindow * >(argp2);
57924 {
57925 PyThreadState* __tstate = wxPyBeginAllowThreads();
57926 result = (bool)(arg1)->ResetIfWin(arg2);
57927 wxPyEndAllowThreads(__tstate);
57928 if (PyErr_Occurred()) SWIG_fail;
57929 }
57930 {
57931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57932 }
57933 return resultobj;
57934 fail:
57935 return NULL;
57936 }
57937
57938
57939 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57940 PyObject *resultobj = 0;
57941 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57942 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57943 wxWindow *arg3 = (wxWindow *) 0 ;
57944 bool result;
57945 void *argp1 = 0 ;
57946 int res1 = 0 ;
57947 void *argp2 = 0 ;
57948 int res2 = 0 ;
57949 void *argp3 = 0 ;
57950 int res3 = 0 ;
57951 PyObject * obj0 = 0 ;
57952 PyObject * obj1 = 0 ;
57953 PyObject * obj2 = 0 ;
57954 char * kwnames[] = {
57955 (char *) "self",(char *) "constraints",(char *) "win", NULL
57956 };
57957
57958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57960 if (!SWIG_IsOK(res1)) {
57961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57962 }
57963 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57965 if (!SWIG_IsOK(res2)) {
57966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57967 }
57968 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57969 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57970 if (!SWIG_IsOK(res3)) {
57971 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57972 }
57973 arg3 = reinterpret_cast< wxWindow * >(argp3);
57974 {
57975 PyThreadState* __tstate = wxPyBeginAllowThreads();
57976 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57977 wxPyEndAllowThreads(__tstate);
57978 if (PyErr_Occurred()) SWIG_fail;
57979 }
57980 {
57981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57982 }
57983 return resultobj;
57984 fail:
57985 return NULL;
57986 }
57987
57988
57989 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57990 PyObject *resultobj = 0;
57991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57992 wxEdge arg2 ;
57993 wxWindow *arg3 = (wxWindow *) 0 ;
57994 wxWindow *arg4 = (wxWindow *) 0 ;
57995 int result;
57996 void *argp1 = 0 ;
57997 int res1 = 0 ;
57998 int val2 ;
57999 int ecode2 = 0 ;
58000 void *argp3 = 0 ;
58001 int res3 = 0 ;
58002 void *argp4 = 0 ;
58003 int res4 = 0 ;
58004 PyObject * obj0 = 0 ;
58005 PyObject * obj1 = 0 ;
58006 PyObject * obj2 = 0 ;
58007 PyObject * obj3 = 0 ;
58008 char * kwnames[] = {
58009 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
58010 };
58011
58012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
58013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58014 if (!SWIG_IsOK(res1)) {
58015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
58016 }
58017 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58018 ecode2 = SWIG_AsVal_int(obj1, &val2);
58019 if (!SWIG_IsOK(ecode2)) {
58020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
58021 }
58022 arg2 = static_cast< wxEdge >(val2);
58023 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58024 if (!SWIG_IsOK(res3)) {
58025 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
58026 }
58027 arg3 = reinterpret_cast< wxWindow * >(argp3);
58028 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
58029 if (!SWIG_IsOK(res4)) {
58030 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
58031 }
58032 arg4 = reinterpret_cast< wxWindow * >(argp4);
58033 {
58034 PyThreadState* __tstate = wxPyBeginAllowThreads();
58035 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
58036 wxPyEndAllowThreads(__tstate);
58037 if (PyErr_Occurred()) SWIG_fail;
58038 }
58039 resultobj = SWIG_From_int(static_cast< int >(result));
58040 return resultobj;
58041 fail:
58042 return NULL;
58043 }
58044
58045
58046 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58047 PyObject *obj;
58048 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58049 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
58050 return SWIG_Py_Void();
58051 }
58052
58053 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58054 PyObject *resultobj = 0;
58055 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58056 wxIndividualLayoutConstraint *result = 0 ;
58057 void *argp1 = 0 ;
58058 int res1 = 0 ;
58059 PyObject *swig_obj[1] ;
58060
58061 if (!args) SWIG_fail;
58062 swig_obj[0] = args;
58063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58064 if (!SWIG_IsOK(res1)) {
58065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58066 }
58067 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58068 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
58069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58070 return resultobj;
58071 fail:
58072 return NULL;
58073 }
58074
58075
58076 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58077 PyObject *resultobj = 0;
58078 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58079 wxIndividualLayoutConstraint *result = 0 ;
58080 void *argp1 = 0 ;
58081 int res1 = 0 ;
58082 PyObject *swig_obj[1] ;
58083
58084 if (!args) SWIG_fail;
58085 swig_obj[0] = args;
58086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58087 if (!SWIG_IsOK(res1)) {
58088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58089 }
58090 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58091 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
58092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58093 return resultobj;
58094 fail:
58095 return NULL;
58096 }
58097
58098
58099 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58100 PyObject *resultobj = 0;
58101 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58102 wxIndividualLayoutConstraint *result = 0 ;
58103 void *argp1 = 0 ;
58104 int res1 = 0 ;
58105 PyObject *swig_obj[1] ;
58106
58107 if (!args) SWIG_fail;
58108 swig_obj[0] = args;
58109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58110 if (!SWIG_IsOK(res1)) {
58111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58112 }
58113 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58114 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
58115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58116 return resultobj;
58117 fail:
58118 return NULL;
58119 }
58120
58121
58122 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58123 PyObject *resultobj = 0;
58124 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58125 wxIndividualLayoutConstraint *result = 0 ;
58126 void *argp1 = 0 ;
58127 int res1 = 0 ;
58128 PyObject *swig_obj[1] ;
58129
58130 if (!args) SWIG_fail;
58131 swig_obj[0] = args;
58132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58133 if (!SWIG_IsOK(res1)) {
58134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58135 }
58136 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58137 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
58138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58139 return resultobj;
58140 fail:
58141 return NULL;
58142 }
58143
58144
58145 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58146 PyObject *resultobj = 0;
58147 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58148 wxIndividualLayoutConstraint *result = 0 ;
58149 void *argp1 = 0 ;
58150 int res1 = 0 ;
58151 PyObject *swig_obj[1] ;
58152
58153 if (!args) SWIG_fail;
58154 swig_obj[0] = args;
58155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58156 if (!SWIG_IsOK(res1)) {
58157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58158 }
58159 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58160 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
58161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58162 return resultobj;
58163 fail:
58164 return NULL;
58165 }
58166
58167
58168 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58169 PyObject *resultobj = 0;
58170 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58171 wxIndividualLayoutConstraint *result = 0 ;
58172 void *argp1 = 0 ;
58173 int res1 = 0 ;
58174 PyObject *swig_obj[1] ;
58175
58176 if (!args) SWIG_fail;
58177 swig_obj[0] = args;
58178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58179 if (!SWIG_IsOK(res1)) {
58180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58181 }
58182 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58183 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
58184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58185 return resultobj;
58186 fail:
58187 return NULL;
58188 }
58189
58190
58191 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58192 PyObject *resultobj = 0;
58193 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58194 wxIndividualLayoutConstraint *result = 0 ;
58195 void *argp1 = 0 ;
58196 int res1 = 0 ;
58197 PyObject *swig_obj[1] ;
58198
58199 if (!args) SWIG_fail;
58200 swig_obj[0] = args;
58201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58202 if (!SWIG_IsOK(res1)) {
58203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58204 }
58205 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58206 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
58207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58208 return resultobj;
58209 fail:
58210 return NULL;
58211 }
58212
58213
58214 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58215 PyObject *resultobj = 0;
58216 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58217 wxIndividualLayoutConstraint *result = 0 ;
58218 void *argp1 = 0 ;
58219 int res1 = 0 ;
58220 PyObject *swig_obj[1] ;
58221
58222 if (!args) SWIG_fail;
58223 swig_obj[0] = args;
58224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58225 if (!SWIG_IsOK(res1)) {
58226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58227 }
58228 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58229 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
58230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58231 return resultobj;
58232 fail:
58233 return NULL;
58234 }
58235
58236
58237 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58238 PyObject *resultobj = 0;
58239 wxLayoutConstraints *result = 0 ;
58240
58241 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
58242 {
58243 PyThreadState* __tstate = wxPyBeginAllowThreads();
58244 result = (wxLayoutConstraints *)new wxLayoutConstraints();
58245 wxPyEndAllowThreads(__tstate);
58246 if (PyErr_Occurred()) SWIG_fail;
58247 }
58248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
58249 return resultobj;
58250 fail:
58251 return NULL;
58252 }
58253
58254
58255 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58256 PyObject *resultobj = 0;
58257 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58258 void *argp1 = 0 ;
58259 int res1 = 0 ;
58260 PyObject *swig_obj[1] ;
58261
58262 if (!args) SWIG_fail;
58263 swig_obj[0] = args;
58264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
58265 if (!SWIG_IsOK(res1)) {
58266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58267 }
58268 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58269 {
58270 PyThreadState* __tstate = wxPyBeginAllowThreads();
58271 delete arg1;
58272
58273 wxPyEndAllowThreads(__tstate);
58274 if (PyErr_Occurred()) SWIG_fail;
58275 }
58276 resultobj = SWIG_Py_Void();
58277 return resultobj;
58278 fail:
58279 return NULL;
58280 }
58281
58282
58283 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58284 PyObject *resultobj = 0;
58285 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58286 wxWindow *arg2 = (wxWindow *) 0 ;
58287 int *arg3 = (int *) 0 ;
58288 bool result;
58289 void *argp1 = 0 ;
58290 int res1 = 0 ;
58291 void *argp2 = 0 ;
58292 int res2 = 0 ;
58293 int temp3 ;
58294 int res3 = SWIG_TMPOBJ ;
58295 PyObject * obj0 = 0 ;
58296 PyObject * obj1 = 0 ;
58297 char * kwnames[] = {
58298 (char *) "self",(char *) "win", NULL
58299 };
58300
58301 arg3 = &temp3;
58302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
58303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58304 if (!SWIG_IsOK(res1)) {
58305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58306 }
58307 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58308 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
58309 if (!SWIG_IsOK(res2)) {
58310 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
58311 }
58312 arg2 = reinterpret_cast< wxWindow * >(argp2);
58313 {
58314 PyThreadState* __tstate = wxPyBeginAllowThreads();
58315 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
58316 wxPyEndAllowThreads(__tstate);
58317 if (PyErr_Occurred()) SWIG_fail;
58318 }
58319 {
58320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58321 }
58322 if (SWIG_IsTmpObj(res3)) {
58323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
58324 } else {
58325 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
58327 }
58328 return resultobj;
58329 fail:
58330 return NULL;
58331 }
58332
58333
58334 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58335 PyObject *resultobj = 0;
58336 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58337 bool result;
58338 void *argp1 = 0 ;
58339 int res1 = 0 ;
58340 PyObject *swig_obj[1] ;
58341
58342 if (!args) SWIG_fail;
58343 swig_obj[0] = args;
58344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58345 if (!SWIG_IsOK(res1)) {
58346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
58347 }
58348 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58349 {
58350 PyThreadState* __tstate = wxPyBeginAllowThreads();
58351 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
58352 wxPyEndAllowThreads(__tstate);
58353 if (PyErr_Occurred()) SWIG_fail;
58354 }
58355 {
58356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58357 }
58358 return resultobj;
58359 fail:
58360 return NULL;
58361 }
58362
58363
58364 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58365 PyObject *obj;
58366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58367 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
58368 return SWIG_Py_Void();
58369 }
58370
58371 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58372 return SWIG_Python_InitShadowInstance(args);
58373 }
58374
58375 static PyMethodDef SwigMethods[] = {
58376 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
58377 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
58378 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
58379 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58380 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
58381 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
58382 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
58383 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
58384 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
58385 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58386 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
58387 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58388 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58389 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58390 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
58392 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
58393 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
58394 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
58395 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58396 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58397 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58398 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58399 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
58400 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
58401 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
58402 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
58403 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
58404 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
58405 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
58406 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
58407 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
58408 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
58409 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
58410 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58411 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
58412 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58413 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58414 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58415 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58416 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58417 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
58418 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
58419 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
58420 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
58421 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
58422 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
58423 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
58424 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
58425 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
58426 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58427 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58428 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58429 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58430 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58431 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58432 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58433 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
58434 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
58435 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
58436 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
58438 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
58439 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
58440 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
58441 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
58442 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
58443 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
58444 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
58445 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
58446 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58447 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
58448 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58449 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
58450 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58451 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
58452 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58453 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
58454 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
58455 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58456 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
58457 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
58458 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
58459 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
58461 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58462 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
58463 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
58464 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
58465 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
58466 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58467 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58468 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58469 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58470 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
58471 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
58472 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
58473 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58475 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58477 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58478 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58479 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58480 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
58481 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58482 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58483 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58484 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
58486 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
58487 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
58488 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
58489 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
58490 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
58491 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
58492 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
58493 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58494 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
58495 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
58496 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
58497 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
58498 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
58499 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58500 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58501 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58502 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58503 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58504 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58505 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58506 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58507 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58509 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58510 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58511 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58512 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58513 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58515 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58516 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58519 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58520 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58521 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58522 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58523 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58525 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58526 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58527 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58528 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58529 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58530 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58531 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58532 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58533 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58534 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58535 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58536 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58537 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58538 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58541 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58542 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58544 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58545 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58547 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58548 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58549 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58550 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58551 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58552 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58553 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58554 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58555 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58556 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58557 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58558 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58559 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58560 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58561 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58562 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58563 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58564 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58565 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58566 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58567 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58568 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58571 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58572 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58573 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58574 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58575 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58576 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58577 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58578 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58579 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58580 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58581 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58582 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58583 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58584 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58585 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58586 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58587 { (char *)"new_Position", (PyCFunction) _wrap_new_Position, METH_VARARGS | METH_KEYWORDS, NULL},
58588 { (char *)"delete_Position", (PyCFunction)_wrap_delete_Position, METH_O, NULL},
58589 { (char *)"Position_GetRow", (PyCFunction)_wrap_Position_GetRow, METH_O, NULL},
58590 { (char *)"Position_GetColumn", (PyCFunction)_wrap_Position_GetColumn, METH_O, NULL},
58591 { (char *)"Position_GetCol", (PyCFunction)_wrap_Position_GetCol, METH_O, NULL},
58592 { (char *)"Position_SetRow", (PyCFunction) _wrap_Position_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"Position_SetColumn", (PyCFunction) _wrap_Position_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"Position_SetCol", (PyCFunction) _wrap_Position_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58595 { (char *)"Position___eq__", (PyCFunction) _wrap_Position___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58596 { (char *)"Position___ne__", (PyCFunction) _wrap_Position___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"Position___add__", _wrap_Position___add__, METH_VARARGS, NULL},
58598 { (char *)"Position___sub__", _wrap_Position___sub__, METH_VARARGS, NULL},
58599 { (char *)"Position_swigregister", Position_swigregister, METH_VARARGS, NULL},
58600 { (char *)"Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
58601 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58602 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58603 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58604 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58605 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58606 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58607 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58608 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58609 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58611 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58612 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58613 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58614 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58615 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58616 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58618 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58619 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58620 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58621 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58622 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58623 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58624 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58625 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58626 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58627 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58628 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58629 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58630 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58631 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58632 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58633 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58634 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58635 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58636 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58637 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58638 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58642 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58643 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58644 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58645 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58648 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58649 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58650 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58651 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58653 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58656 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58657 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58658 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58659 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58660 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58661 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58662 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58663 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58664 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58665 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58666 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58667 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58668 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58669 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58671 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58672 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58673 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58674 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58675 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58676 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58677 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58679 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58680 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58682 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58683 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58684 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58685 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58686 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58687 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58688 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58689 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58690 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58691 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58692 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58693 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58694 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58695 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58696 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58697 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58698 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58699 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58700 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58701 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58702 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58703 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58704 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58705 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58707 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58708 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58709 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58711 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58712 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58713 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58714 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58715 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58716 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58717 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58718 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58719 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58720 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58721 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58722 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58723 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58724 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58725 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58726 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58727 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58729 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58730 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58731 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58732 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58733 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58735 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58738 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58743 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58744 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58745 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58746 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58747 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58748 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58754 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58755 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58756 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58757 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58758 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58759 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58761 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58762 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58763 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58764 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58766 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58767 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58768 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58769 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58771 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58772 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58773 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58774 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58777 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58779 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58781 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58783 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58785 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58788 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58789 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58790 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58791 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58792 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58793 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58794 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58795 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58796 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58797 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58798 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58799 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58800 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58801 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58802 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58810 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58811 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58812 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58813 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58817 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58818 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58819 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58820 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58821 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58822 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58823 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58824 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58825 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58826 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58827 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58828 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58829 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58830 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58831 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58832 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58833 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58834 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58835 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58836 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58837 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58838 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58839 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58840 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58841 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58842 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58843 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58844 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58845 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58846 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58847 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58848 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58849 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58850 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58851 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58852 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58853 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58854 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58855 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58856 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58857 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58858 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58859 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58860 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58861 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58862 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58863 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58864 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58866 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58867 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58869 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58871 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58872 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58873 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58874 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58875 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58876 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58877 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58878 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58879 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58880 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58881 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58882 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58883 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58885 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58886 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58887 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58888 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58889 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58890 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58892 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58893 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58894 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58895 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58896 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58897 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58898 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58899 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58900 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58902 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58903 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58904 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58905 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58906 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58908 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58909 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58911 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58912 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58913 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58915 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58916 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58917 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58918 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58919 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58920 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58921 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58922 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58923 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58924 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58925 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58926 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58927 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58928 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58929 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58930 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58931 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58932 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58933 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58935 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58941 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58942 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58943 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58944 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58945 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58946 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58947 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58948 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58949 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58950 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58951 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58952 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58953 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58954 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58955 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58956 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58957 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58958 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58959 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58960 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58961 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58962 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58963 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58964 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58965 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58966 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58967 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58968 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58969 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58970 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58971 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58972 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58973 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58974 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58975 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58976 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58977 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58978 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58979 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58980 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58981 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58982 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58983 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58984 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58985 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58986 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58987 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58988 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58989 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58990 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58991 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58992 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58993 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58994 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58995 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58996 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58997 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58998 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58999 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
59000 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
59001 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59002 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
59003 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
59004 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
59005 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
59006 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59007 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
59008 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
59009 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
59010 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
59011 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
59012 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
59013 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
59014 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
59015 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
59016 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
59017 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
59018 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
59019 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
59020 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
59021 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
59022 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
59023 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
59024 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
59025 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
59026 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
59027 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
59028 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
59029 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
59030 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
59031 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
59032 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
59033 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
59034 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
59035 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
59036 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
59037 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
59038 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
59039 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
59040 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
59041 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
59042 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
59043 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
59044 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
59045 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59046 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
59047 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
59048 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59049 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59050 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
59051 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
59052 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
59053 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
59054 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
59055 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
59056 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59057 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
59058 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
59059 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59060 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59061 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
59062 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
59063 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
59065 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
59066 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
59068 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
59069 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
59071 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
59072 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
59073 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59074 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
59075 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59076 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
59077 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
59078 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59079 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
59080 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
59081 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
59082 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59083 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
59084 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
59085 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
59086 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59087 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
59088 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
59089 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59090 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
59091 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
59092 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
59093 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
59094 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
59095 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
59097 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
59098 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
59099 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
59100 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
59101 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
59102 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
59103 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
59104 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
59107 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
59108 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
59109 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59110 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
59111 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
59112 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
59113 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59114 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
59115 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
59116 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
59117 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
59118 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
59119 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
59120 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
59122 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
59123 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
59124 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
59125 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
59126 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
59127 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
59128 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
59129 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59130 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59131 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
59134 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
59135 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
59137 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59138 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
59139 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
59140 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
59141 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
59142 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
59143 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
59144 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59145 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
59146 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
59147 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
59148 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59149 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
59150 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
59151 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
59152 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
59153 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
59154 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59155 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
59157 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
59158 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
59159 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59160 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
59161 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
59162 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
59163 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
59164 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
59165 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
59166 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
59168 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
59169 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
59170 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
59171 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59172 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
59173 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59174 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
59175 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
59176 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
59178 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
59179 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
59180 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
59182 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
59183 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
59184 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59185 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
59186 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59187 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
59188 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
59189 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
59190 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
59191 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
59192 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59193 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
59194 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
59195 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
59196 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
59197 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59198 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
59199 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
59200 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
59202 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59203 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
59204 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
59205 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
59206 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59207 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
59208 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
59210 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
59211 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
59212 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59213 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
59214 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
59215 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
59216 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
59217 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
59218 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
59219 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
59221 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
59222 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
59223 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
59224 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59225 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
59226 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
59228 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
59229 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
59230 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
59231 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
59232 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
59233 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
59234 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
59235 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
59236 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
59237 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
59238 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
59239 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
59240 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
59241 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
59242 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
59243 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
59244 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
59245 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59246 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
59247 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
59248 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
59249 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
59250 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
59251 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
59253 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
59255 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
59256 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
59257 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
59258 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
59259 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
59260 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
59261 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59262 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59263 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59264 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
59265 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
59266 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
59267 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
59268 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
59269 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
59270 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
59271 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
59272 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
59273 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
59275 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59276 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
59277 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
59278 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
59279 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
59280 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
59281 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
59282 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
59283 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
59284 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
59285 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
59286 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
59287 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
59288 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
59289 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
59290 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
59291 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
59292 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
59293 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
59294 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
59295 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
59296 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
59297 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59298 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59299 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
59300 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
59301 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
59302 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
59303 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
59304 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
59305 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
59306 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
59307 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59308 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
59309 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
59310 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
59311 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
59312 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
59313 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
59314 { (char *)"VisualAttributes__get_font", (PyCFunction)_wrap_VisualAttributes__get_font, METH_O, NULL},
59315 { (char *)"VisualAttributes__get_colFg", (PyCFunction)_wrap_VisualAttributes__get_colFg, METH_O, NULL},
59316 { (char *)"VisualAttributes__get_colBg", (PyCFunction)_wrap_VisualAttributes__get_colBg, METH_O, NULL},
59317 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
59318 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
59319 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
59320 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
59321 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59322 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
59323 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
59324 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
59325 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
59326 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59327 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
59328 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
59329 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
59330 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
59331 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
59332 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59333 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
59334 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
59335 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59336 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59337 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
59338 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59339 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59340 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59341 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
59342 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59343 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
59346 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
59347 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
59348 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
59349 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
59350 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59351 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
59352 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
59353 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
59354 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
59355 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
59356 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
59357 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
59358 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
59359 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
59360 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
59361 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
59362 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
59363 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
59364 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
59365 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
59366 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
59367 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
59368 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
59369 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
59370 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
59371 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
59372 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
59373 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59374 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59375 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59376 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59377 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
59378 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
59379 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59380 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
59381 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
59382 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
59383 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
59384 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
59385 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
59386 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59387 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
59388 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
59389 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
59390 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
59391 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59392 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
59393 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59394 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
59395 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
59396 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
59397 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
59398 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
59399 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59400 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
59401 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59402 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
59403 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59404 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59405 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
59406 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
59407 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59408 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
59409 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
59410 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
59411 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
59412 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
59413 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
59414 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
59415 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
59416 { (char *)"Window_SetCanFocus", (PyCFunction) _wrap_Window_SetCanFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59417 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
59418 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
59419 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59420 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
59422 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
59423 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
59424 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
59425 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
59426 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
59427 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
59428 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
59429 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
59430 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59431 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59432 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
59433 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59434 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59435 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59436 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59437 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
59438 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
59439 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
59440 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
59441 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
59442 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
59443 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59444 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
59445 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59446 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59447 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59448 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59449 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
59450 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
59451 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59452 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59453 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
59454 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
59455 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
59456 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
59457 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
59458 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
59459 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
59460 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
59461 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
59462 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
59463 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
59464 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
59465 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
59466 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
59467 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
59468 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
59469 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
59470 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59471 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
59472 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
59473 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59474 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59475 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59476 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59477 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59478 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
59479 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
59480 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
59481 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
59482 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59483 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
59484 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
59485 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59486 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
59487 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59488 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
59489 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
59490 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
59491 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
59492 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
59493 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
59494 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59495 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59496 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
59497 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
59498 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
59499 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
59500 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
59501 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
59502 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
59503 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
59504 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
59505 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59506 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
59507 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
59508 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
59509 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
59510 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
59511 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59512 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59513 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59514 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59515 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59516 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59517 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59518 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59519 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59520 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59521 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59522 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59523 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59524 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59525 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59526 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59527 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59528 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59529 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59530 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59531 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59532 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59533 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59534 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59535 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59536 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59537 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59538 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59539 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59540 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59541 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59542 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59543 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59544 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59545 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59546 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59547 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59548 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59549 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59550 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59551 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59552 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59553 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59554 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59555 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59556 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59557 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59558 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59559 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59560 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59561 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59562 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59563 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59564 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59565 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59566 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59567 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59568 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59569 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59570 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59571 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59572 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59573 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59574 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59575 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59576 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59577 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59578 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59579 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59580 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59581 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59582 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59583 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59584 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59585 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59586 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59587 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59588 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59589 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59590 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59591 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59592 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59593 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59594 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59595 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59596 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59597 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59598 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59599 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59600 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59601 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59602 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59603 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59604 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59605 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59606 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59607 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59608 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59609 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59610 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59611 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59612 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59613 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59614 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59615 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59616 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59617 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59618 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59619 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59620 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59621 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59622 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59623 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59624 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59625 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59626 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59627 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59628 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59629 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59630 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59631 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59632 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59633 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59634 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59635 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59636 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59637 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59638 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59639 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59640 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59641 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59642 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59643 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59644 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59645 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59646 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59647 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59648 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59649 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59650 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59651 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59652 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59653 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59654 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59655 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59656 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59657 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59658 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59659 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59660 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59661 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59662 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59663 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59664 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59665 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59666 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59667 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59668 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59669 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59670 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59671 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59672 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59673 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59674 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59675 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59676 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59677 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59678 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59679 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59680 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59681 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59682 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59683 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59684 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59685 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59686 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59687 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59688 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59689 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59690 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59691 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59692 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59693 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59694 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59695 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59696 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59697 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59698 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59699 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59700 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59701 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59702 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59703 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59704 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59705 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59706 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59707 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59708 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59709 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59710 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59711 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59712 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59713 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59714 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59715 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59716 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59717 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59718 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59719 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59720 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59721 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59722 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59723 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59724 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59725 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59726 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59727 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59728 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59729 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59730 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59731 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59732 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59733 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59734 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59735 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59736 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59737 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59738 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59739 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59740 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59741 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59742 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59743 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59744 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59745 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59746 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59747 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59748 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59749 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59750 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59751 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59752 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59753 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59754 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59755 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59756 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59757 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59758 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59759 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59760 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59761 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59762 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59763 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59764 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59765 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59766 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59767 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59768 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59769 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59770 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59771 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59772 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59773 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59774 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59775 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59776 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59777 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59778 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59779 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59780 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59781 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59782 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59783 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59784 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59785 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59786 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59787 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59788 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59789 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59790 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59791 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59792 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59793 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59794 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59795 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59796 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59797 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59798 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59799 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59800 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59801 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59802 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59803 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59804 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59805 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59806 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59807 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59808 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59809 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59810 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59811 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59812 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59813 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59814 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59815 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59816 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59817 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59818 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59819 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59820 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59821 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59822 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59823 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59824 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59825 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59826 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59827 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59828 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59829 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59830 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59831 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59832 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59833 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59834 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59835 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59836 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59837 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59838 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59839 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59840 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59841 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59842 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59843 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59844 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59845 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59846 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59847 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59848 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59849 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59850 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59851 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59852 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59853 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59854 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59855 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59856 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59857 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59858 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59859 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59860 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59861 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59862 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59863 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59864 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59865 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59866 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59867 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59868 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59869 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59870 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59871 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59872 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59873 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59874 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59875 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59876 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59877 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59878 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59879 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59880 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59881 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59882 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59883 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59884 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59885 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59886 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59887 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59888 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59889 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59890 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59891 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59892 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59893 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59894 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59895 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59896 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59897 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59898 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59899 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59900 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59901 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59902 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59903 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59904 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59905 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59906 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59907 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59908 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59909 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59910 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59911 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59912 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59913 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59914 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59915 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59916 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59917 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59918 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59919 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59920 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59921 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59922 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59923 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59924 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59925 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59926 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59927 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59928 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59929 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59930 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59931 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59932 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59933 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59934 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59935 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59936 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59937 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59938 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59939 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59940 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59941 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59942 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59943 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59944 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59945 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59946 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59947 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59948 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59949 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59950 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59951 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59952 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59953 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59954 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59955 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59956 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59957 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59958 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59959 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59960 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59961 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59962 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59963 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59964 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59965 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59966 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59967 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59968 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59969 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59970 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59971 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59972 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59973 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59974 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59975 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59976 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59977 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59978 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59979 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59980 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59981 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59982 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59983 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59984 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59985 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59986 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59987 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59988 { NULL, NULL, 0, NULL }
59989 };
59990
59991
59992 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59993
59994 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59995 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59996 }
59997 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59998 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59999 }
60000 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
60001 return (void *)((wxEvent *) ((wxCloseEvent *) x));
60002 }
60003 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
60004 return (void *)((wxEvent *) ((wxMouseEvent *) x));
60005 }
60006 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
60007 return (void *)((wxEvent *) ((wxEraseEvent *) x));
60008 }
60009 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
60010 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
60011 }
60012 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
60013 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
60014 }
60015 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
60016 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
60017 }
60018 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
60019 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
60020 }
60021 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
60022 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
60023 }
60024 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
60025 return (void *)((wxEvent *) ((wxPyEvent *) x));
60026 }
60027 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
60028 return (void *)((wxEvent *) ((wxIdleEvent *) x));
60029 }
60030 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
60031 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
60032 }
60033 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
60034 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
60035 }
60036 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
60037 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
60038 }
60039 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
60040 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
60041 }
60042 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
60043 return (void *)((wxEvent *) ((wxActivateEvent *) x));
60044 }
60045 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
60046 return (void *)((wxEvent *) ((wxSizeEvent *) x));
60047 }
60048 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
60049 return (void *)((wxEvent *) ((wxMoveEvent *) x));
60050 }
60051 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
60052 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
60053 }
60054 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
60055 return (void *)((wxEvent *) ((wxPaintEvent *) x));
60056 }
60057 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
60058 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
60059 }
60060 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
60061 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
60062 }
60063 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
60064 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
60065 }
60066 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
60067 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
60068 }
60069 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
60070 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
60071 }
60072 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
60073 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60074 }
60075 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
60076 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
60077 }
60078 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
60079 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
60080 }
60081 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
60082 return (void *)((wxEvent *) ((wxFocusEvent *) x));
60083 }
60084 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
60085 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
60086 }
60087 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
60088 return (void *)((wxEvent *) ((wxShowEvent *) x));
60089 }
60090 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
60091 return (void *)((wxEvent *) ((wxCommandEvent *) x));
60092 }
60093 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
60094 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
60095 }
60096 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
60097 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60098 }
60099 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
60100 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
60101 }
60102 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
60103 return (void *)((wxEvent *) ((wxKeyEvent *) x));
60104 }
60105 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
60106 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
60107 }
60108 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
60109 return (void *)((wxValidator *) ((wxPyValidator *) x));
60110 }
60111 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
60112 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
60113 }
60114 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
60115 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
60116 }
60117 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
60118 return (void *)((wxObject *) ((wxSizerItem *) x));
60119 }
60120 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
60121 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
60122 }
60123 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
60124 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
60125 }
60126 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
60127 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
60128 }
60129 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
60130 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
60131 }
60132 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
60133 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
60134 }
60135 static void *_p_wxSizerTo_p_wxObject(void *x) {
60136 return (void *)((wxObject *) ((wxSizer *) x));
60137 }
60138 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
60139 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60140 }
60141 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
60142 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
60143 }
60144 static void *_p_wxEventTo_p_wxObject(void *x) {
60145 return (void *)((wxObject *) ((wxEvent *) x));
60146 }
60147 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
60148 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
60149 }
60150 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
60151 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
60152 }
60153 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
60154 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
60155 }
60156 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
60157 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
60158 }
60159 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
60160 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
60161 }
60162 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
60163 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
60164 }
60165 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
60166 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
60167 }
60168 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
60169 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
60170 }
60171 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
60172 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60173 }
60174 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
60175 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
60176 }
60177 static void *_p_wxControlTo_p_wxObject(void *x) {
60178 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
60179 }
60180 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
60181 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
60182 }
60183 static void *_p_wxFSFileTo_p_wxObject(void *x) {
60184 return (void *)((wxObject *) ((wxFSFile *) x));
60185 }
60186 static void *_p_wxPySizerTo_p_wxObject(void *x) {
60187 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
60188 }
60189 static void *_p_wxPyEventTo_p_wxObject(void *x) {
60190 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
60191 }
60192 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
60193 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
60194 }
60195 static void *_p_wxShowEventTo_p_wxObject(void *x) {
60196 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
60197 }
60198 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
60199 return (void *)((wxObject *) ((wxMenuItem *) x));
60200 }
60201 static void *_p_wxDateEventTo_p_wxObject(void *x) {
60202 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
60203 }
60204 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
60205 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
60206 }
60207 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
60208 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
60209 }
60210 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
60211 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
60212 }
60213 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
60214 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
60215 }
60216 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
60217 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
60218 }
60219 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
60220 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
60221 }
60222 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
60223 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
60224 }
60225 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
60226 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
60227 }
60228 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
60229 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
60230 }
60231 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
60232 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
60233 }
60234 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
60235 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
60236 }
60237 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
60238 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
60239 }
60240 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
60241 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
60242 }
60243 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
60244 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60245 }
60246 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
60247 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60248 }
60249 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
60250 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
60251 }
60252 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
60253 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
60254 }
60255 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
60256 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
60257 }
60258 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
60259 return (void *)((wxObject *) ((wxImageHandler *) x));
60260 }
60261 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
60262 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
60263 }
60264 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
60265 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
60266 }
60267 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
60268 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
60269 }
60270 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
60271 return (void *)((wxObject *) ((wxEvtHandler *) x));
60272 }
60273 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
60274 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
60275 }
60276 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
60277 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
60278 }
60279 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
60280 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60281 }
60282 static void *_p_wxImageTo_p_wxObject(void *x) {
60283 return (void *)((wxObject *) ((wxImage *) x));
60284 }
60285 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
60286 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
60287 }
60288 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
60289 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60290 }
60291 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
60292 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
60293 }
60294 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
60295 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
60296 }
60297 static void *_p_wxWindowTo_p_wxObject(void *x) {
60298 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
60299 }
60300 static void *_p_wxMenuTo_p_wxObject(void *x) {
60301 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
60302 }
60303 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
60304 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
60305 }
60306 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
60307 return (void *)((wxObject *) ((wxFileSystem *) x));
60308 }
60309 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
60310 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
60311 }
60312 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
60313 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
60314 }
60315 static void *_p_wxPyAppTo_p_wxObject(void *x) {
60316 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
60317 }
60318 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
60319 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
60320 }
60321 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
60322 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
60323 }
60324 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
60325 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
60326 }
60327 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
60328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
60329 }
60330 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
60331 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
60332 }
60333 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
60334 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
60335 }
60336 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
60337 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
60338 }
60339 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
60340 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
60341 }
60342 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
60343 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60344 }
60345 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
60346 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
60347 }
60348 static void *_p_wxValidatorTo_p_wxObject(void *x) {
60349 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
60350 }
60351 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
60352 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
60353 }
60354 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
60355 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
60356 }
60357 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
60358 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
60359 }
60360 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
60361 return (void *)((wxControl *) ((wxControlWithItems *) x));
60362 }
60363 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
60364 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
60365 }
60366 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
60367 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
60368 }
60369 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
60370 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60371 }
60372 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
60373 return (void *)((wxSizer *) ((wxBoxSizer *) x));
60374 }
60375 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
60376 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
60377 }
60378 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
60379 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60380 }
60381 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
60382 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60383 }
60384 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
60385 return (void *)((wxSizer *) ((wxGridSizer *) x));
60386 }
60387 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
60388 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
60389 }
60390 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
60391 return (void *)((wxSizer *) ((wxPySizer *) x));
60392 }
60393 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
60394 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
60395 }
60396 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
60397 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
60398 }
60399 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
60400 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
60401 }
60402 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
60403 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
60404 }
60405 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
60406 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
60407 }
60408 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
60409 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
60410 }
60411 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
60412 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
60413 }
60414 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
60415 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
60416 }
60417 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
60418 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60419 }
60420 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
60421 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60422 }
60423 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
60424 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
60425 }
60426 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
60427 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
60428 }
60429 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
60430 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
60431 }
60432 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
60433 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
60434 }
60435 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
60436 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
60437 }
60438 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
60439 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
60440 }
60441 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
60442 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
60443 }
60444 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
60445 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
60446 }
60447 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
60448 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
60449 }
60450 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
60451 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
60452 }
60453 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
60454 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60455 }
60456 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
60457 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
60458 }
60459 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
60460 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
60461 }
60462 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
60463 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
60464 }
60465 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
60466 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
60467 }
60468 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
60469 return (void *)((wxEvtHandler *) ((wxWindow *) x));
60470 }
60471 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
60472 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60473 }
60474 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
60475 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
60476 }
60477 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
60478 return (void *)((wxEvtHandler *) ((wxValidator *) x));
60479 }
60480 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
60481 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
60482 }
60483 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
60484 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
60485 }
60486 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
60487 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
60488 }
60489 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
60490 return (void *)((wxEvtHandler *) ((wxMenu *) x));
60491 }
60492 static void *_p_wxControlTo_p_wxWindow(void *x) {
60493 return (void *)((wxWindow *) ((wxControl *) x));
60494 }
60495 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
60496 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
60497 }
60498 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
60499 return (void *)((wxWindow *) ((wxMenuBar *) x));
60500 }
60501 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
60502 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
60503 }
60504 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
60505 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
60506 }
60507 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
60508 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
60509 }
60510 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
60511 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60512 }
60513 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60514 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60515 }
60516 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60517 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60518 }
60519 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60520 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60521 }
60522 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60523 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60524 }
60525 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60526 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60527 }
60528 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60529 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60530 }
60531 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60532 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60533 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};
60534 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60535 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60536 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60537 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60538 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60539 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60540 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60541 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60542 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60543 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60544 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60545 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60546 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60547 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60548 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60549 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60550 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60551 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60552 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60553 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60554 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60555 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60556 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60557 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60558 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60559 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60560 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60561 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60562 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60563 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60564 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60565 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60566 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60567 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60568 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60569 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60570 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60571 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60572 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60573 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60574 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60575 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60576 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60577 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60578 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60579 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60580 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60581 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60582 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60583 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60584 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60585 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60586 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60587 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60588 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60589 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60590 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60591 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60592 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60593 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60594 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60595 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60596 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60597 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60598 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60599 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60600 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60601 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60602 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60603 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60604 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60605 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60606 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60607 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60608 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60609 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60610 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60611 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60612 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60613 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60614 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60615 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60616 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60617 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60618 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60619 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60620 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60621 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60622 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60623 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60624 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60625 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60626 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60627 static swig_type_info _swigt__p_wxPosition = {"_p_wxPosition", "wxPosition *", 0, 0, (void*)0, 0};
60628 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60629 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60630 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60631 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60632 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60633 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60634 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60635 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60636 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60637 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60638 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60639 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60640 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60641 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60642 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60643 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60644 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60645 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60646 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60647 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60648 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60649 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60650 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60651 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60652 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60653 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60654 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60655 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60656 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60657 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60658 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60659 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60660 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60661 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60662 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60663 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60664 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60665 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60666 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60667 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60668 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60669
60670 static swig_type_info *swig_type_initial[] = {
60671 &_swigt__p_buffer,
60672 &_swigt__p_char,
60673 &_swigt__p_form_ops_t,
60674 &_swigt__p_int,
60675 &_swigt__p_long,
60676 &_swigt__p_unsigned_char,
60677 &_swigt__p_unsigned_int,
60678 &_swigt__p_unsigned_long,
60679 &_swigt__p_wxANIHandler,
60680 &_swigt__p_wxAcceleratorEntry,
60681 &_swigt__p_wxAcceleratorTable,
60682 &_swigt__p_wxActivateEvent,
60683 &_swigt__p_wxAppTraits,
60684 &_swigt__p_wxArrayString,
60685 &_swigt__p_wxBMPHandler,
60686 &_swigt__p_wxBitmap,
60687 &_swigt__p_wxBoxSizer,
60688 &_swigt__p_wxButton,
60689 &_swigt__p_wxCURHandler,
60690 &_swigt__p_wxCaret,
60691 &_swigt__p_wxChildFocusEvent,
60692 &_swigt__p_wxClipboardTextEvent,
60693 &_swigt__p_wxCloseEvent,
60694 &_swigt__p_wxColour,
60695 &_swigt__p_wxCommandEvent,
60696 &_swigt__p_wxContextMenuEvent,
60697 &_swigt__p_wxControl,
60698 &_swigt__p_wxControlWithItems,
60699 &_swigt__p_wxCursor,
60700 &_swigt__p_wxDC,
60701 &_swigt__p_wxDateEvent,
60702 &_swigt__p_wxDateTime,
60703 &_swigt__p_wxDisplayChangedEvent,
60704 &_swigt__p_wxDouble,
60705 &_swigt__p_wxDropFilesEvent,
60706 &_swigt__p_wxDuplexMode,
60707 &_swigt__p_wxEraseEvent,
60708 &_swigt__p_wxEvent,
60709 &_swigt__p_wxEventBlocker,
60710 &_swigt__p_wxEventLoop,
60711 &_swigt__p_wxEventLoopActivator,
60712 &_swigt__p_wxEvtHandler,
60713 &_swigt__p_wxFSFile,
60714 &_swigt__p_wxFileSystem,
60715 &_swigt__p_wxFileSystemHandler,
60716 &_swigt__p_wxFlexGridSizer,
60717 &_swigt__p_wxFocusEvent,
60718 &_swigt__p_wxFont,
60719 &_swigt__p_wxFrame,
60720 &_swigt__p_wxGBPosition,
60721 &_swigt__p_wxGBSizerItem,
60722 &_swigt__p_wxGBSpan,
60723 &_swigt__p_wxGIFHandler,
60724 &_swigt__p_wxGridBagSizer,
60725 &_swigt__p_wxGridSizer,
60726 &_swigt__p_wxHelpEvent__Origin,
60727 &_swigt__p_wxICOHandler,
60728 &_swigt__p_wxIconizeEvent,
60729 &_swigt__p_wxIdleEvent,
60730 &_swigt__p_wxImage,
60731 &_swigt__p_wxImageHandler,
60732 &_swigt__p_wxImageHistogram,
60733 &_swigt__p_wxImage_HSVValue,
60734 &_swigt__p_wxImage_RGBValue,
60735 &_swigt__p_wxIndividualLayoutConstraint,
60736 &_swigt__p_wxInitDialogEvent,
60737 &_swigt__p_wxInputStream,
60738 &_swigt__p_wxInternetFSHandler,
60739 &_swigt__p_wxItemContainer,
60740 &_swigt__p_wxJPEGHandler,
60741 &_swigt__p_wxKeyEvent,
60742 &_swigt__p_wxLayoutConstraints,
60743 &_swigt__p_wxMaximizeEvent,
60744 &_swigt__p_wxMemoryFSHandler,
60745 &_swigt__p_wxMenu,
60746 &_swigt__p_wxMenuBar,
60747 &_swigt__p_wxMenuBarBase,
60748 &_swigt__p_wxMenuEvent,
60749 &_swigt__p_wxMenuItem,
60750 &_swigt__p_wxMouseCaptureChangedEvent,
60751 &_swigt__p_wxMouseCaptureLostEvent,
60752 &_swigt__p_wxMouseEvent,
60753 &_swigt__p_wxMoveEvent,
60754 &_swigt__p_wxNavigationKeyEvent,
60755 &_swigt__p_wxNcPaintEvent,
60756 &_swigt__p_wxNotifyEvent,
60757 &_swigt__p_wxObject,
60758 &_swigt__p_wxOutputStream,
60759 &_swigt__p_wxPCXHandler,
60760 &_swigt__p_wxPNGHandler,
60761 &_swigt__p_wxPNMHandler,
60762 &_swigt__p_wxPaintEvent,
60763 &_swigt__p_wxPaletteChangedEvent,
60764 &_swigt__p_wxPaperSize,
60765 &_swigt__p_wxPoint,
60766 &_swigt__p_wxPoint2D,
60767 &_swigt__p_wxPosition,
60768 &_swigt__p_wxPropagateOnce,
60769 &_swigt__p_wxPropagationDisabler,
60770 &_swigt__p_wxPyApp,
60771 &_swigt__p_wxPyCommandEvent,
60772 &_swigt__p_wxPyDropTarget,
60773 &_swigt__p_wxPyEvent,
60774 &_swigt__p_wxPyFileSystemHandler,
60775 &_swigt__p_wxPyImageHandler,
60776 &_swigt__p_wxPyInputStream,
60777 &_swigt__p_wxPySizer,
60778 &_swigt__p_wxPyValidator,
60779 &_swigt__p_wxQuantize,
60780 &_swigt__p_wxQueryNewPaletteEvent,
60781 &_swigt__p_wxRealPoint,
60782 &_swigt__p_wxRect,
60783 &_swigt__p_wxRect2D,
60784 &_swigt__p_wxRegion,
60785 &_swigt__p_wxScrollEvent,
60786 &_swigt__p_wxScrollWinEvent,
60787 &_swigt__p_wxSetCursorEvent,
60788 &_swigt__p_wxShowEvent,
60789 &_swigt__p_wxSize,
60790 &_swigt__p_wxSizeEvent,
60791 &_swigt__p_wxSizer,
60792 &_swigt__p_wxSizerFlags,
60793 &_swigt__p_wxSizerItem,
60794 &_swigt__p_wxStaticBox,
60795 &_swigt__p_wxStaticBoxSizer,
60796 &_swigt__p_wxStdDialogButtonSizer,
60797 &_swigt__p_wxSysColourChangedEvent,
60798 &_swigt__p_wxTGAHandler,
60799 &_swigt__p_wxTIFFHandler,
60800 &_swigt__p_wxToolTip,
60801 &_swigt__p_wxUpdateUIEvent,
60802 &_swigt__p_wxValidator,
60803 &_swigt__p_wxVisualAttributes,
60804 &_swigt__p_wxWindow,
60805 &_swigt__p_wxWindowCreateEvent,
60806 &_swigt__p_wxWindowDestroyEvent,
60807 &_swigt__p_wxXPMHandler,
60808 &_swigt__p_wxZipFSHandler,
60809 };
60810
60811 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60812 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60813 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60814 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60815 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60816 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60817 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60818 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60819 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60820 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60821 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60822 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60823 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60824 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60825 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}};
60826 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60827 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}};
60828 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60829 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}};
60830 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60831 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60832 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60833 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60834 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60835 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}};
60836 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60837 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}};
60838 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60839 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60840 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60841 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60842 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60843 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60844 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60845 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60846 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60847 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60848 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}};
60849 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60850 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60851 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60852 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60853 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60854 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60855 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}};
60856 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}};
60857 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60858 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60859 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60860 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60861 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60862 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60863 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60864 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60865 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}};
60866 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60867 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}};
60868 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60869 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60870 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60871 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60872 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60873 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60874 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60875 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60876 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60877 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60878 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60879 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}};
60880 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60881 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60882 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60883 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60884 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60885 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60886 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60887 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60888 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60889 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60890 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60891 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60892 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60893 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60894 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60895 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60896 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60897 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
60898 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60899 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60900 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60901 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60902 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60903 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60904 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60905 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60906 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60907 static swig_cast_info _swigc__p_wxPosition[] = { {&_swigt__p_wxPosition, 0, 0, 0},{0, 0, 0, 0}};
60908 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60909 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60910 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60911 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60912 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60913 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60914 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60915 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60916 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60917 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60918 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60919 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60920 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60921 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60922 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60923 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60924 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60925 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60926 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60927 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60928 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60929 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60930 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60931 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}};
60932 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60933 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}};
60934 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60935 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60936 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60937 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60938 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60939 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60940 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60941 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60942 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}};
60943 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60944 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}};
60945 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60946 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60947 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60948 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60949
60950 static swig_cast_info *swig_cast_initial[] = {
60951 _swigc__p_buffer,
60952 _swigc__p_char,
60953 _swigc__p_form_ops_t,
60954 _swigc__p_int,
60955 _swigc__p_long,
60956 _swigc__p_unsigned_char,
60957 _swigc__p_unsigned_int,
60958 _swigc__p_unsigned_long,
60959 _swigc__p_wxANIHandler,
60960 _swigc__p_wxAcceleratorEntry,
60961 _swigc__p_wxAcceleratorTable,
60962 _swigc__p_wxActivateEvent,
60963 _swigc__p_wxAppTraits,
60964 _swigc__p_wxArrayString,
60965 _swigc__p_wxBMPHandler,
60966 _swigc__p_wxBitmap,
60967 _swigc__p_wxBoxSizer,
60968 _swigc__p_wxButton,
60969 _swigc__p_wxCURHandler,
60970 _swigc__p_wxCaret,
60971 _swigc__p_wxChildFocusEvent,
60972 _swigc__p_wxClipboardTextEvent,
60973 _swigc__p_wxCloseEvent,
60974 _swigc__p_wxColour,
60975 _swigc__p_wxCommandEvent,
60976 _swigc__p_wxContextMenuEvent,
60977 _swigc__p_wxControl,
60978 _swigc__p_wxControlWithItems,
60979 _swigc__p_wxCursor,
60980 _swigc__p_wxDC,
60981 _swigc__p_wxDateEvent,
60982 _swigc__p_wxDateTime,
60983 _swigc__p_wxDisplayChangedEvent,
60984 _swigc__p_wxDouble,
60985 _swigc__p_wxDropFilesEvent,
60986 _swigc__p_wxDuplexMode,
60987 _swigc__p_wxEraseEvent,
60988 _swigc__p_wxEvent,
60989 _swigc__p_wxEventBlocker,
60990 _swigc__p_wxEventLoop,
60991 _swigc__p_wxEventLoopActivator,
60992 _swigc__p_wxEvtHandler,
60993 _swigc__p_wxFSFile,
60994 _swigc__p_wxFileSystem,
60995 _swigc__p_wxFileSystemHandler,
60996 _swigc__p_wxFlexGridSizer,
60997 _swigc__p_wxFocusEvent,
60998 _swigc__p_wxFont,
60999 _swigc__p_wxFrame,
61000 _swigc__p_wxGBPosition,
61001 _swigc__p_wxGBSizerItem,
61002 _swigc__p_wxGBSpan,
61003 _swigc__p_wxGIFHandler,
61004 _swigc__p_wxGridBagSizer,
61005 _swigc__p_wxGridSizer,
61006 _swigc__p_wxHelpEvent__Origin,
61007 _swigc__p_wxICOHandler,
61008 _swigc__p_wxIconizeEvent,
61009 _swigc__p_wxIdleEvent,
61010 _swigc__p_wxImage,
61011 _swigc__p_wxImageHandler,
61012 _swigc__p_wxImageHistogram,
61013 _swigc__p_wxImage_HSVValue,
61014 _swigc__p_wxImage_RGBValue,
61015 _swigc__p_wxIndividualLayoutConstraint,
61016 _swigc__p_wxInitDialogEvent,
61017 _swigc__p_wxInputStream,
61018 _swigc__p_wxInternetFSHandler,
61019 _swigc__p_wxItemContainer,
61020 _swigc__p_wxJPEGHandler,
61021 _swigc__p_wxKeyEvent,
61022 _swigc__p_wxLayoutConstraints,
61023 _swigc__p_wxMaximizeEvent,
61024 _swigc__p_wxMemoryFSHandler,
61025 _swigc__p_wxMenu,
61026 _swigc__p_wxMenuBar,
61027 _swigc__p_wxMenuBarBase,
61028 _swigc__p_wxMenuEvent,
61029 _swigc__p_wxMenuItem,
61030 _swigc__p_wxMouseCaptureChangedEvent,
61031 _swigc__p_wxMouseCaptureLostEvent,
61032 _swigc__p_wxMouseEvent,
61033 _swigc__p_wxMoveEvent,
61034 _swigc__p_wxNavigationKeyEvent,
61035 _swigc__p_wxNcPaintEvent,
61036 _swigc__p_wxNotifyEvent,
61037 _swigc__p_wxObject,
61038 _swigc__p_wxOutputStream,
61039 _swigc__p_wxPCXHandler,
61040 _swigc__p_wxPNGHandler,
61041 _swigc__p_wxPNMHandler,
61042 _swigc__p_wxPaintEvent,
61043 _swigc__p_wxPaletteChangedEvent,
61044 _swigc__p_wxPaperSize,
61045 _swigc__p_wxPoint,
61046 _swigc__p_wxPoint2D,
61047 _swigc__p_wxPosition,
61048 _swigc__p_wxPropagateOnce,
61049 _swigc__p_wxPropagationDisabler,
61050 _swigc__p_wxPyApp,
61051 _swigc__p_wxPyCommandEvent,
61052 _swigc__p_wxPyDropTarget,
61053 _swigc__p_wxPyEvent,
61054 _swigc__p_wxPyFileSystemHandler,
61055 _swigc__p_wxPyImageHandler,
61056 _swigc__p_wxPyInputStream,
61057 _swigc__p_wxPySizer,
61058 _swigc__p_wxPyValidator,
61059 _swigc__p_wxQuantize,
61060 _swigc__p_wxQueryNewPaletteEvent,
61061 _swigc__p_wxRealPoint,
61062 _swigc__p_wxRect,
61063 _swigc__p_wxRect2D,
61064 _swigc__p_wxRegion,
61065 _swigc__p_wxScrollEvent,
61066 _swigc__p_wxScrollWinEvent,
61067 _swigc__p_wxSetCursorEvent,
61068 _swigc__p_wxShowEvent,
61069 _swigc__p_wxSize,
61070 _swigc__p_wxSizeEvent,
61071 _swigc__p_wxSizer,
61072 _swigc__p_wxSizerFlags,
61073 _swigc__p_wxSizerItem,
61074 _swigc__p_wxStaticBox,
61075 _swigc__p_wxStaticBoxSizer,
61076 _swigc__p_wxStdDialogButtonSizer,
61077 _swigc__p_wxSysColourChangedEvent,
61078 _swigc__p_wxTGAHandler,
61079 _swigc__p_wxTIFFHandler,
61080 _swigc__p_wxToolTip,
61081 _swigc__p_wxUpdateUIEvent,
61082 _swigc__p_wxValidator,
61083 _swigc__p_wxVisualAttributes,
61084 _swigc__p_wxWindow,
61085 _swigc__p_wxWindowCreateEvent,
61086 _swigc__p_wxWindowDestroyEvent,
61087 _swigc__p_wxXPMHandler,
61088 _swigc__p_wxZipFSHandler,
61089 };
61090
61091
61092 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
61093
61094 static swig_const_info swig_const_table[] = {
61095 {0, 0, 0, 0.0, 0, 0}};
61096
61097 #ifdef __cplusplus
61098 }
61099 #endif
61100 /* -----------------------------------------------------------------------------
61101 * Type initialization:
61102 * This problem is tough by the requirement that no dynamic
61103 * memory is used. Also, since swig_type_info structures store pointers to
61104 * swig_cast_info structures and swig_cast_info structures store pointers back
61105 * to swig_type_info structures, we need some lookup code at initialization.
61106 * The idea is that swig generates all the structures that are needed.
61107 * The runtime then collects these partially filled structures.
61108 * The SWIG_InitializeModule function takes these initial arrays out of
61109 * swig_module, and does all the lookup, filling in the swig_module.types
61110 * array with the correct data and linking the correct swig_cast_info
61111 * structures together.
61112 *
61113 * The generated swig_type_info structures are assigned staticly to an initial
61114 * array. We just loop though that array, and handle each type individually.
61115 * First we lookup if this type has been already loaded, and if so, use the
61116 * loaded structure instead of the generated one. Then we have to fill in the
61117 * cast linked list. The cast data is initially stored in something like a
61118 * two-dimensional array. Each row corresponds to a type (there are the same
61119 * number of rows as there are in the swig_type_initial array). Each entry in
61120 * a column is one of the swig_cast_info structures for that type.
61121 * The cast_initial array is actually an array of arrays, because each row has
61122 * a variable number of columns. So to actually build the cast linked list,
61123 * we find the array of casts associated with the type, and loop through it
61124 * adding the casts to the list. The one last trick we need to do is making
61125 * sure the type pointer in the swig_cast_info struct is correct.
61126 *
61127 * First off, we lookup the cast->type name to see if it is already loaded.
61128 * There are three cases to handle:
61129 * 1) If the cast->type has already been loaded AND the type we are adding
61130 * casting info to has not been loaded (it is in this module), THEN we
61131 * replace the cast->type pointer with the type pointer that has already
61132 * been loaded.
61133 * 2) If BOTH types (the one we are adding casting info to, and the
61134 * cast->type) are loaded, THEN the cast info has already been loaded by
61135 * the previous module so we just ignore it.
61136 * 3) Finally, if cast->type has not already been loaded, then we add that
61137 * swig_cast_info to the linked list (because the cast->type) pointer will
61138 * be correct.
61139 * ----------------------------------------------------------------------------- */
61140
61141 #ifdef __cplusplus
61142 extern "C" {
61143 #if 0
61144 } /* c-mode */
61145 #endif
61146 #endif
61147
61148 #if 0
61149 #define SWIGRUNTIME_DEBUG
61150 #endif
61151
61152 SWIGRUNTIME void
61153 SWIG_InitializeModule(void *clientdata) {
61154 size_t i;
61155 swig_module_info *module_head;
61156 static int init_run = 0;
61157
61158 clientdata = clientdata;
61159
61160 if (init_run) return;
61161 init_run = 1;
61162
61163 /* Initialize the swig_module */
61164 swig_module.type_initial = swig_type_initial;
61165 swig_module.cast_initial = swig_cast_initial;
61166
61167 /* Try and load any already created modules */
61168 module_head = SWIG_GetModule(clientdata);
61169 if (module_head) {
61170 swig_module.next = module_head->next;
61171 module_head->next = &swig_module;
61172 } else {
61173 /* This is the first module loaded */
61174 swig_module.next = &swig_module;
61175 SWIG_SetModule(clientdata, &swig_module);
61176 }
61177
61178 /* Now work on filling in swig_module.types */
61179 #ifdef SWIGRUNTIME_DEBUG
61180 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
61181 #endif
61182 for (i = 0; i < swig_module.size; ++i) {
61183 swig_type_info *type = 0;
61184 swig_type_info *ret;
61185 swig_cast_info *cast;
61186
61187 #ifdef SWIGRUNTIME_DEBUG
61188 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61189 #endif
61190
61191 /* if there is another module already loaded */
61192 if (swig_module.next != &swig_module) {
61193 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
61194 }
61195 if (type) {
61196 /* Overwrite clientdata field */
61197 #ifdef SWIGRUNTIME_DEBUG
61198 printf("SWIG_InitializeModule: found type %s\n", type->name);
61199 #endif
61200 if (swig_module.type_initial[i]->clientdata) {
61201 type->clientdata = swig_module.type_initial[i]->clientdata;
61202 #ifdef SWIGRUNTIME_DEBUG
61203 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
61204 #endif
61205 }
61206 } else {
61207 type = swig_module.type_initial[i];
61208 }
61209
61210 /* Insert casting types */
61211 cast = swig_module.cast_initial[i];
61212 while (cast->type) {
61213 /* Don't need to add information already in the list */
61214 ret = 0;
61215 #ifdef SWIGRUNTIME_DEBUG
61216 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
61217 #endif
61218 if (swig_module.next != &swig_module) {
61219 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
61220 #ifdef SWIGRUNTIME_DEBUG
61221 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
61222 #endif
61223 }
61224 if (ret) {
61225 if (type == swig_module.type_initial[i]) {
61226 #ifdef SWIGRUNTIME_DEBUG
61227 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
61228 #endif
61229 cast->type = ret;
61230 ret = 0;
61231 } else {
61232 /* Check for casting already in the list */
61233 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
61234 #ifdef SWIGRUNTIME_DEBUG
61235 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
61236 #endif
61237 if (!ocast) ret = 0;
61238 }
61239 }
61240
61241 if (!ret) {
61242 #ifdef SWIGRUNTIME_DEBUG
61243 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
61244 #endif
61245 if (type->cast) {
61246 type->cast->prev = cast;
61247 cast->next = type->cast;
61248 }
61249 type->cast = cast;
61250 }
61251 cast++;
61252 }
61253 /* Set entry in modules->types array equal to the type */
61254 swig_module.types[i] = type;
61255 }
61256 swig_module.types[i] = 0;
61257
61258 #ifdef SWIGRUNTIME_DEBUG
61259 printf("**** SWIG_InitializeModule: Cast List ******\n");
61260 for (i = 0; i < swig_module.size; ++i) {
61261 int j = 0;
61262 swig_cast_info *cast = swig_module.cast_initial[i];
61263 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61264 while (cast->type) {
61265 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
61266 cast++;
61267 ++j;
61268 }
61269 printf("---- Total casts: %d\n",j);
61270 }
61271 printf("**** SWIG_InitializeModule: Cast List ******\n");
61272 #endif
61273 }
61274
61275 /* This function will propagate the clientdata field of type to
61276 * any new swig_type_info structures that have been added into the list
61277 * of equivalent types. It is like calling
61278 * SWIG_TypeClientData(type, clientdata) a second time.
61279 */
61280 SWIGRUNTIME void
61281 SWIG_PropagateClientData(void) {
61282 size_t i;
61283 swig_cast_info *equiv;
61284 static int init_run = 0;
61285
61286 if (init_run) return;
61287 init_run = 1;
61288
61289 for (i = 0; i < swig_module.size; i++) {
61290 if (swig_module.types[i]->clientdata) {
61291 equiv = swig_module.types[i]->cast;
61292 while (equiv) {
61293 if (!equiv->converter) {
61294 if (equiv->type && !equiv->type->clientdata)
61295 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
61296 }
61297 equiv = equiv->next;
61298 }
61299 }
61300 }
61301 }
61302
61303 #ifdef __cplusplus
61304 #if 0
61305 {
61306 /* c-mode */
61307 #endif
61308 }
61309 #endif
61310
61311
61312
61313 #ifdef __cplusplus
61314 extern "C" {
61315 #endif
61316
61317 /* Python-specific SWIG API */
61318 #define SWIG_newvarlink() SWIG_Python_newvarlink()
61319 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
61320 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
61321
61322 /* -----------------------------------------------------------------------------
61323 * global variable support code.
61324 * ----------------------------------------------------------------------------- */
61325
61326 typedef struct swig_globalvar {
61327 char *name; /* Name of global variable */
61328 PyObject *(*get_attr)(void); /* Return the current value */
61329 int (*set_attr)(PyObject *); /* Set the value */
61330 struct swig_globalvar *next;
61331 } swig_globalvar;
61332
61333 typedef struct swig_varlinkobject {
61334 PyObject_HEAD
61335 swig_globalvar *vars;
61336 } swig_varlinkobject;
61337
61338 SWIGINTERN PyObject *
61339 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
61340 return PyString_FromString("<Swig global variables>");
61341 }
61342
61343 SWIGINTERN PyObject *
61344 swig_varlink_str(swig_varlinkobject *v) {
61345 PyObject *str = PyString_FromString("(");
61346 swig_globalvar *var;
61347 for (var = v->vars; var; var=var->next) {
61348 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
61349 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
61350 }
61351 PyString_ConcatAndDel(&str,PyString_FromString(")"));
61352 return str;
61353 }
61354
61355 SWIGINTERN int
61356 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
61357 PyObject *str = swig_varlink_str(v);
61358 fprintf(fp,"Swig global variables ");
61359 fprintf(fp,"%s\n", PyString_AsString(str));
61360 Py_DECREF(str);
61361 return 0;
61362 }
61363
61364 SWIGINTERN void
61365 swig_varlink_dealloc(swig_varlinkobject *v) {
61366 swig_globalvar *var = v->vars;
61367 while (var) {
61368 swig_globalvar *n = var->next;
61369 free(var->name);
61370 free(var);
61371 var = n;
61372 }
61373 }
61374
61375 SWIGINTERN PyObject *
61376 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
61377 PyObject *res = NULL;
61378 swig_globalvar *var = v->vars;
61379 while (var) {
61380 if (strcmp(var->name,n) == 0) {
61381 res = (*var->get_attr)();
61382 break;
61383 }
61384 var = var->next;
61385 }
61386 if (res == NULL && !PyErr_Occurred()) {
61387 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61388 }
61389 return res;
61390 }
61391
61392 SWIGINTERN int
61393 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
61394 int res = 1;
61395 swig_globalvar *var = v->vars;
61396 while (var) {
61397 if (strcmp(var->name,n) == 0) {
61398 res = (*var->set_attr)(p);
61399 break;
61400 }
61401 var = var->next;
61402 }
61403 if (res == 1 && !PyErr_Occurred()) {
61404 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61405 }
61406 return res;
61407 }
61408
61409 SWIGINTERN PyTypeObject*
61410 swig_varlink_type(void) {
61411 static char varlink__doc__[] = "Swig var link object";
61412 static PyTypeObject varlink_type;
61413 static int type_init = 0;
61414 if (!type_init) {
61415 const PyTypeObject tmp
61416 = {
61417 PyObject_HEAD_INIT(NULL)
61418 0, /* Number of items in variable part (ob_size) */
61419 (char *)"swigvarlink", /* Type name (tp_name) */
61420 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
61421 0, /* Itemsize (tp_itemsize) */
61422 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
61423 (printfunc) swig_varlink_print, /* Print (tp_print) */
61424 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
61425 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
61426 0, /* tp_compare */
61427 (reprfunc) swig_varlink_repr, /* tp_repr */
61428 0, /* tp_as_number */
61429 0, /* tp_as_sequence */
61430 0, /* tp_as_mapping */
61431 0, /* tp_hash */
61432 0, /* tp_call */
61433 (reprfunc)swig_varlink_str, /* tp_str */
61434 0, /* tp_getattro */
61435 0, /* tp_setattro */
61436 0, /* tp_as_buffer */
61437 0, /* tp_flags */
61438 varlink__doc__, /* tp_doc */
61439 0, /* tp_traverse */
61440 0, /* tp_clear */
61441 0, /* tp_richcompare */
61442 0, /* tp_weaklistoffset */
61443 #if PY_VERSION_HEX >= 0x02020000
61444 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
61445 #endif
61446 #if PY_VERSION_HEX >= 0x02030000
61447 0, /* tp_del */
61448 #endif
61449 #ifdef COUNT_ALLOCS
61450 0,0,0,0 /* tp_alloc -> tp_next */
61451 #endif
61452 };
61453 varlink_type = tmp;
61454 varlink_type.ob_type = &PyType_Type;
61455 type_init = 1;
61456 }
61457 return &varlink_type;
61458 }
61459
61460 /* Create a variable linking object for use later */
61461 SWIGINTERN PyObject *
61462 SWIG_Python_newvarlink(void) {
61463 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
61464 if (result) {
61465 result->vars = 0;
61466 }
61467 return ((PyObject*) result);
61468 }
61469
61470 SWIGINTERN void
61471 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
61472 swig_varlinkobject *v = (swig_varlinkobject *) p;
61473 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
61474 if (gv) {
61475 size_t size = strlen(name)+1;
61476 gv->name = (char *)malloc(size);
61477 if (gv->name) {
61478 strncpy(gv->name,name,size);
61479 gv->get_attr = get_attr;
61480 gv->set_attr = set_attr;
61481 gv->next = v->vars;
61482 }
61483 }
61484 v->vars = gv;
61485 }
61486
61487 SWIGINTERN PyObject *
61488 SWIG_globals() {
61489 static PyObject *_SWIG_globals = 0;
61490 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
61491 return _SWIG_globals;
61492 }
61493
61494 /* -----------------------------------------------------------------------------
61495 * constants/methods manipulation
61496 * ----------------------------------------------------------------------------- */
61497
61498 /* Install Constants */
61499 SWIGINTERN void
61500 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
61501 PyObject *obj = 0;
61502 size_t i;
61503 for (i = 0; constants[i].type; ++i) {
61504 switch(constants[i].type) {
61505 case SWIG_PY_POINTER:
61506 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
61507 break;
61508 case SWIG_PY_BINARY:
61509 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
61510 break;
61511 default:
61512 obj = 0;
61513 break;
61514 }
61515 if (obj) {
61516 PyDict_SetItemString(d, constants[i].name, obj);
61517 Py_DECREF(obj);
61518 }
61519 }
61520 }
61521
61522 /* -----------------------------------------------------------------------------*/
61523 /* Fix SwigMethods to carry the callback ptrs when needed */
61524 /* -----------------------------------------------------------------------------*/
61525
61526 SWIGINTERN void
61527 SWIG_Python_FixMethods(PyMethodDef *methods,
61528 swig_const_info *const_table,
61529 swig_type_info **types,
61530 swig_type_info **types_initial) {
61531 size_t i;
61532 for (i = 0; methods[i].ml_name; ++i) {
61533 const char *c = methods[i].ml_doc;
61534 if (c && (c = strstr(c, "swig_ptr: "))) {
61535 int j;
61536 swig_const_info *ci = 0;
61537 const char *name = c + 10;
61538 for (j = 0; const_table[j].type; ++j) {
61539 if (strncmp(const_table[j].name, name,
61540 strlen(const_table[j].name)) == 0) {
61541 ci = &(const_table[j]);
61542 break;
61543 }
61544 }
61545 if (ci) {
61546 size_t shift = (ci->ptype) - types;
61547 swig_type_info *ty = types_initial[shift];
61548 size_t ldoc = (c - methods[i].ml_doc);
61549 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61550 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61551 if (ndoc) {
61552 char *buff = ndoc;
61553 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61554 if (ptr) {
61555 strncpy(buff, methods[i].ml_doc, ldoc);
61556 buff += ldoc;
61557 strncpy(buff, "swig_ptr: ", 10);
61558 buff += 10;
61559 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61560 methods[i].ml_doc = ndoc;
61561 }
61562 }
61563 }
61564 }
61565 }
61566 }
61567
61568 #ifdef __cplusplus
61569 }
61570 #endif
61571
61572 /* -----------------------------------------------------------------------------*
61573 * Partial Init method
61574 * -----------------------------------------------------------------------------*/
61575
61576 #ifdef __cplusplus
61577 extern "C"
61578 #endif
61579 SWIGEXPORT void SWIG_init(void) {
61580 PyObject *m, *d;
61581
61582 /* Fix SwigMethods to carry the callback ptrs when needed */
61583 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61584
61585 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61586 d = PyModule_GetDict(m);
61587
61588 SWIG_InitializeModule(0);
61589 SWIG_InstallConstants(d,swig_const_table);
61590
61591
61592
61593 #ifndef wxPyUSE_EXPORT
61594 // Make our API structure a CObject so other modules can import it
61595 // from this module.
61596 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61597 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61598 Py_XDECREF(cobj);
61599 #endif
61600
61601 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61602 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61603 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61604 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61605 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61606 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61607 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61608 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61609 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61610 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61611 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61612 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61613 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61614 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61615 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61616 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61617 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61618 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61619 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61620 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61621 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61622 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61623 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61624 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61625 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61626 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61627 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61628 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61629 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61630 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61631 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61632 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61633 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61634 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61635 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61636 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61637 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61638 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61639 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61640 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61641 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61642 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61643 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61644 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61645 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61646 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61647 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61648 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61649 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61650 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61651 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61652 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61653 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61654 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61655 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61656 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61657 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61658 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61659 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61660 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61661 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61662 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61663 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61664 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61665 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61666 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61667 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61668 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61669 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61670 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61671 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61672 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61673 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61674 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61675 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61676 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61677 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61678 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61679 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61680 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61681 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61682 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61683 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61684 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61685 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61686 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61687 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61688 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61689 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61690 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61691 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61692 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61693 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61694 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61695 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61696 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61697 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61698 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61699 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61700 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61701 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61702 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61703 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61704 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61705 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61706 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61707 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61708 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61709 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61710 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61711 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61712 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61713 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61714 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61715 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61716 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61717 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61718 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61719 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61720 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61721 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61722 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61723 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61724 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61725 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61726 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61727 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61728 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61729 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61730 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61731 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61732 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61733 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61734 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61735 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61736 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61737 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61738 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61739 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61740 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61741 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61742 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61743 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61744 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61745 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61746 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61747 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61748 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61749 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61750 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61751 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61752 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61753 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61754 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61755 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61756 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61757 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61758 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61759 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61760 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61761 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61762 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61763 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61764 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61765 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61766 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61767 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61768 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61769 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61770 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61771 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61772 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61773 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61774 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61775 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61776 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61777 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61778 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61779 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61780 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61781 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61782 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61783 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61784 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61785 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61786 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61787 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61788 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61789 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61790 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61791 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61792 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61793 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61794 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61795 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61796 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61797 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61798 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61799 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61800 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61801 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61802 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61803 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61804 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61805 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61806 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61807 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61808 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61809 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61810 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61811 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61812 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61813 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61814 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61815 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61816 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61817 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61818 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61819 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61820 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61821 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61822 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61823 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61824 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61825 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61826 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61827 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61828 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61829 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61830 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61831 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61832 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61833 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61834 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61835 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61836 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61837 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61838 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61839 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61840 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61841 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61842 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61843 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61844 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61845 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61846 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61847 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61848 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61849 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61850 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61851 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61852 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61853 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61854 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61855 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61856 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61857 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61858 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61859 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61860 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61861 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61862 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61863 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61864 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61865 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61866 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61867 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61868 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61869 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61870 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61871 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61872 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61873 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61874 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61875 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61876 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61877 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61878 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61879 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61880 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61881 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61882 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61883 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61884 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61885 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61886 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61887 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61888 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61889 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61890 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61891 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61892 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61893 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61894 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61895 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61896 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61897 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61898 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61899 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61900 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61901 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61902 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61903 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61904 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61905 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61906 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61907 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61908 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61909 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61910 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61911 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61912 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61913 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61914 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61915 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61916 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61917 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61918 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61919 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61920 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61921 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61922 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61923 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61924 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61925 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61926 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61927 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61928 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61929 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61930 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61931 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61932 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61933 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61934 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61935 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61936 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61937 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61938 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61939 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61940 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61941 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61942 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61943 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61944 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61945 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61946 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61947 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61948 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61949 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61950 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61951 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61952 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61953 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61954 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61955 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61956 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61957 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61958 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61959 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61960 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61961 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61962 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61963 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61964 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61965 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61966 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61967 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61968 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61969 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61970 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61971 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61972 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61973 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61974 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61975 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61976 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61977 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61978 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61979 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61980 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61981 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61982 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61983 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61984 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61985 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61986 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
62000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
62001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
62002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
62003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
62004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
62005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
62006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
62007 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
62008 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
62009 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
62010 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
62011 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
62012 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
62013 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
62014 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
62015 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
62016 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
62017 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
62018 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
62019 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
62020 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
62021 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
62022 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
62023 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
62024 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
62025 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
62026 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
62027 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
62028 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
62029 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
62030 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
62031 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
62032 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
62033 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
62034 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
62035 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
62036 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
62037 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
62038 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
62039 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
62040 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
62041 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
62042 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
62043 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
62044 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
62045 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
62046 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
62047 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
62048 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
62049 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
62050 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
62051 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
62052 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
62053 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
62054 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
62055 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
62056 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
62057 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
62058 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
62059 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
62060 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
62061 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
62062 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
62063 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
62064 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
62065 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
62066 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
62067 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
62068 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
62069 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
62070 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
62071 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
62072 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
62073 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
62074 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
62075 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
62076 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
62077 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
62078 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
62079 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
62080 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
62081 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
62082 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
62083 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
62084 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
62085 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
62086 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
62087 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
62088 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
62089 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
62090 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
62091 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
62092 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
62093 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
62094 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
62095 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
62096 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
62097 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
62098 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
62099 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
62100 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
62101 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
62102 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
62103 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
62104 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
62105 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
62106 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
62107 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
62108 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
62109 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
62110 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
62111 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
62112 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
62113 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
62114 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
62115 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
62116 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
62117 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
62118 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
62119 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
62120 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
62121 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
62122 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
62123 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
62124 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
62125 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
62126 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
62127 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
62128 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
62129 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
62130 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
62131 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
62132 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
62133 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
62134 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
62135 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
62136 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
62137 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
62138 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
62139 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
62140 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
62141 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
62142 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
62143 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
62144 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
62145 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
62146 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
62147 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
62148 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
62149 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
62150 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
62151 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
62152 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
62153 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
62154 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
62155 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
62156 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
62157 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
62158 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
62159 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
62160 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
62161 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
62162 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
62163 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
62164 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
62165 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
62166 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
62167 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
62168 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
62169 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
62170 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
62171 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
62172 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
62173 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
62174 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
62175 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
62176 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
62177 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
62178 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
62179 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
62180 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
62181 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
62182 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
62183 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
62184 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
62185 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
62186 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
62187 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
62188 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
62189 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
62190 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
62191 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
62192 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
62193 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
62194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
62195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
62196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
62197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
62198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
62199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
62200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
62201 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
62202 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
62203 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
62204 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
62205 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
62206 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
62207 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
62208 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
62209 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
62210 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
62211 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
62212 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
62213 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
62214 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
62215 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
62216 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
62217 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
62218 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
62219 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
62220 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
62221 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
62222 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
62223 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
62224 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
62225 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
62226 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
62227 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
62228 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
62229 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
62230 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
62231 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
62232 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
62233 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
62234 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
62235 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
62236 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
62237 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
62238 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
62239 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
62240 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
62241 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
62242 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
62243 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
62244 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
62245 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
62246 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
62247 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
62248 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
62249 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
62250 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
62251 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
62252 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
62253 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
62254 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
62255 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
62256
62257 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
62258
62259
62260 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
62261
62262 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
62263 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
62264 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
62265 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
62266 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
62267 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
62268 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
62269 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
62270 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
62271 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
62272 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
62273 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
62274 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
62275 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
62276 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
62277 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
62278 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
62279 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
62280 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
62281 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
62282 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
62283 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
62284 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
62285 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
62286 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
62287 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
62288 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
62289 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
62290 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
62291 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
62292 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
62293 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
62294 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
62295 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
62296 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
62297 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
62298 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
62299 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
62300 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
62301 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
62302 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
62303 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
62304 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
62305 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
62306 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
62307 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
62308 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
62309 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
62310 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
62311 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
62312 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
62313 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
62314 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
62315 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
62316 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
62317 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
62318 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
62319 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
62320 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
62321 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
62322 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
62323 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
62324 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
62325 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
62326 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
62327 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
62328 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
62329 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
62330 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
62331 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
62332 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
62333 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
62334 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
62335 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
62336 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
62337 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
62338 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
62339 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
62340 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
62341 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
62342 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
62343 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
62344 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
62345 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
62346 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
62347 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
62348 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
62349 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
62350 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
62351 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
62352 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
62353 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
62354 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
62355 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
62356 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
62357 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
62358 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
62359 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
62360 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
62361 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
62362 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
62363 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
62364 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
62365 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
62366 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
62367 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
62368 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
62369 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
62370 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
62371 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
62372 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
62373 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
62374 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
62375 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
62376 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
62377 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
62378 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
62379 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
62380 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
62381 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
62382 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
62383 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
62384 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
62385 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
62386 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
62387 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
62388 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
62389 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
62390 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
62391 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
62392 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
62393 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
62394 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
62395 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
62396 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
62397 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
62398 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
62399 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
62400 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
62401 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
62402 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
62403 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
62404 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
62405 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
62406 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
62407 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
62408 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
62409 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
62410 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
62411 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
62412 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
62413 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
62414 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
62415 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
62416 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
62417 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
62418 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
62419 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
62420 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
62421 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
62422 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
62423 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
62424 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
62425 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
62426 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
62427 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
62428 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
62429 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
62430 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
62431 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
62432 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
62433 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
62434 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
62435 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
62436 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
62437 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
62438 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
62439 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
62440 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
62441 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
62442 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
62443 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
62444 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
62445 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
62446 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
62447 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
62448 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
62449 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
62450 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
62451 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
62452 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
62453 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
62454 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
62455 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
62456 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
62457 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
62458 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
62459 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
62460 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
62461 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
62462 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
62463 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
62464 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
62465 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
62466 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
62467 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
62468 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
62469 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
62470 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
62471 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
62472 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
62473 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
62474 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
62475 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
62476 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
62477
62478 // Initialize threading, some globals and such
62479 __wxPyPreStart(d);
62480
62481
62482 // Although these are defined in __version__ they need to be here too so
62483 // that an assert can be done to ensure that the wxPython and the wxWindows
62484 // versions match.
62485 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
62486 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
62487 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
62488
62489 }
62490
wxWidgets (Impactor)