]> 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
update the text of a read-only combobox (and hence wxChoice) when selection is change...
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3834 return wxPyTestDisplayAvailable();
3835 }
3836
3837 void wxApp_CleanUp() {
3838 __wxPyCleanup();
3839 }
3840
3841
3842 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3843
3844
3845
3846
3847
3848 SWIGINTERNINLINE PyObject *
3849 SWIG_FromCharPtr(const char *cptr)
3850 {
3851 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3852 }
3853
3854
3855 #if 0 // #ifdef __WXMAC__
3856
3857 // A dummy class that raises an exception if used...
3858 class wxEventLoop
3859 {
3860 public:
3861 wxEventLoop() { wxPyRaiseNotImplemented(); }
3862 int Run() { return 0; }
3863 void Exit(int rc = 0) {}
3864 bool Pending() const { return false; }
3865 bool Dispatch() { return false; }
3866 bool IsRunning() const { return false; }
3867 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3868 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3869 };
3870
3871 #else
3872
3873 #include <wx/evtloop.h>
3874
3875 #endif
3876
3877
3878
3879 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3880 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3881 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3882 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3883 wxWindowList& list = self->GetChildren();
3884 return wxPy_ConvertList(&list);
3885 }
3886 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3887 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3888 #if wxUSE_HOTKEY
3889 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3890 #else
3891 return false;
3892 #endif
3893 }
3894 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3895
3896
3897
3898 return false;
3899
3900 }
3901 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3902 return wxPyGetWinHandle(self);
3903 }
3904 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3905 self->AssociateHandle((WXWidget)handle);
3906 }
3907
3908 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3909 return wxWindow::FindWindowById(id, parent);
3910 }
3911
3912 wxWindow* wxFindWindowByName( const wxString& name,
3913 const wxWindow *parent = NULL ) {
3914 return wxWindow::FindWindowByName(name, parent);
3915 }
3916
3917 wxWindow* wxFindWindowByLabel( const wxString& label,
3918 const wxWindow *parent = NULL ) {
3919 return wxWindow::FindWindowByLabel(label, parent);
3920 }
3921
3922
3923 #ifdef __WXMSW__
3924 #include <wx/msw/private.h> // to get wxGetWindowId
3925 #endif
3926
3927
3928 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3929 #ifdef __WXMSW__
3930 WXHWND hWnd = (WXHWND)_hWnd;
3931 long id = wxGetWindowId(hWnd);
3932 wxWindow* win = new wxWindow;
3933 if (parent)
3934 parent->AddChild(win);
3935 win->SetEventHandler(win);
3936 win->SetHWND(hWnd);
3937 win->SetId(id);
3938 win->SubclassWin(hWnd);
3939 win->AdoptAttributesFromHWND();
3940 win->SetupColours();
3941 return win;
3942 #else
3943 wxPyRaiseNotImplemented();
3944 return NULL;
3945 #endif
3946 }
3947
3948
3949 PyObject* GetTopLevelWindows() {
3950 return wxPy_ConvertList(&wxTopLevelWindows);
3951 }
3952
3953
3954 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3955 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3957
3958 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3959
3960
3961 SWIGINTERNINLINE int
3962 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3963 {
3964 unsigned long v;
3965 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3966 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3967 return res;
3968 }
3969
3970 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3971 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3972 wxMenuItemList& list = self->GetMenuItems();
3973 return wxPy_ConvertList(&list);
3974 }
3975 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3976 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3977 static const wxString wxPyControlNameStr(wxControlNameStr);
3978 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3979 if (clientData) {
3980 wxPyClientData* data = new wxPyClientData(clientData);
3981 return self->Append(item, data);
3982 } else
3983 return self->Append(item);
3984 }
3985 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3986 if (clientData) {
3987 wxPyClientData* data = new wxPyClientData(clientData);
3988 return self->Insert(item, pos, data);
3989 } else
3990 return self->Insert(item, pos);
3991 }
3992 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3993 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3994 if (data) {
3995 Py_INCREF(data->m_obj);
3996 return data->m_obj;
3997 } else {
3998 Py_INCREF(Py_None);
3999 return Py_None;
4000 }
4001 }
4002 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 self->SetClientObject(n, data);
4005 }
4006
4007
4008 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 return new wxSizerItem(window, proportion, flag, border, data);
4016 }
4017 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4018 wxPyUserData* data = NULL;
4019 if ( userData ) {
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 data = new wxPyUserData(userData);
4022 wxPyEndBlockThreads(blocked);
4023 }
4024 return new wxSizerItem(width, height, proportion, flag, border, data);
4025 }
4026 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4027 wxPyUserData* data = NULL;
4028 if ( userData ) {
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 data = new wxPyUserData(userData);
4031 wxPyEndBlockThreads(blocked);
4032 }
4033 return new wxSizerItem(sizer, proportion, flag, border, data);
4034 }
4035
4036 SWIGINTERNINLINE PyObject *
4037 SWIG_From_float (float value)
4038 {
4039 return SWIG_From_double (value);
4040 }
4041
4042 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4043 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4044 if (data) {
4045 Py_INCREF(data->m_obj);
4046 return data->m_obj;
4047 } else {
4048 Py_INCREF(Py_None);
4049 return Py_None;
4050 }
4051 }
4052 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4053 wxPyUserData* data = NULL;
4054 if ( userData ) {
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 data = new wxPyUserData(userData);
4057 wxPyEndBlockThreads(blocked);
4058 }
4059 self->SetUserData(data);
4060 }
4061
4062 // Figure out the type of the sizer item
4063
4064 struct wxPySizerItemInfo {
4065 wxPySizerItemInfo()
4066 : window(NULL), sizer(NULL), gotSize(false),
4067 size(wxDefaultSize), gotPos(false), pos(-1)
4068 {}
4069
4070 wxWindow* window;
4071 wxSizer* sizer;
4072 bool gotSize;
4073 wxSize size;
4074 bool gotPos;
4075 int pos;
4076 };
4077
4078 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4079
4080 wxPySizerItemInfo info;
4081 wxSize size;
4082 wxSize* sizePtr = &size;
4083
4084 // Find out what the type of the item is
4085 // try wxWindow
4086 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4087 PyErr_Clear();
4088 info.window = NULL;
4089
4090 // try wxSizer
4091 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4092 PyErr_Clear();
4093 info.sizer = NULL;
4094
4095 // try wxSize or (w,h)
4096 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4097 info.size = *sizePtr;
4098 info.gotSize = true;
4099 }
4100
4101 // or a single int
4102 if (checkIdx && PyInt_Check(item)) {
4103 info.pos = PyInt_AsLong(item);
4104 info.gotPos = true;
4105 }
4106 }
4107 }
4108
4109 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4110 // no expected type, figure out what kind of error message to generate
4111 if ( !checkSize && !checkIdx )
4112 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4113 else if ( checkSize && !checkIdx )
4114 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4115 else if ( !checkSize && checkIdx)
4116 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4117 else
4118 // can this one happen?
4119 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4120 }
4121
4122 return info;
4123 }
4124
4125 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4126 if (!self->GetClientObject())
4127 self->SetClientObject(new wxPyOORClientData(_self));
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Add method if a valid item type was found
4141 if ( info.window )
4142 return self->Add(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Add(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4152
4153 wxPyUserData* data = NULL;
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4156 if ( userData && (info.window || info.sizer || info.gotSize) )
4157 data = new wxPyUserData(userData);
4158 if ( info.sizer )
4159 PyObject_SetAttrString(item,"thisown",Py_False);
4160 wxPyEndBlockThreads(blocked);
4161
4162 // Now call the real Insert method if a valid item type was found
4163 if ( info.window )
4164 return self->Insert(before, info.window, proportion, flag, border, data);
4165 else if ( info.sizer )
4166 return self->Insert(before, info.sizer, proportion, flag, border, data);
4167 else if (info.gotSize)
4168 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4169 proportion, flag, border, data);
4170 else
4171 return NULL;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4174
4175 wxPyUserData* data = NULL;
4176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4178 if ( userData && (info.window || info.sizer || info.gotSize) )
4179 data = new wxPyUserData(userData);
4180 if ( info.sizer )
4181 PyObject_SetAttrString(item,"thisown",Py_False);
4182 wxPyEndBlockThreads(blocked);
4183
4184 // Now call the real Prepend method if a valid item type was found
4185 if ( info.window )
4186 return self->Prepend(info.window, proportion, flag, border, data);
4187 else if ( info.sizer )
4188 return self->Prepend(info.sizer, proportion, flag, border, data);
4189 else if (info.gotSize)
4190 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4191 proportion, flag, border, data);
4192 else
4193 return NULL;
4194 }
4195 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4198 wxPyEndBlockThreads(blocked);
4199 if ( info.window )
4200 return self->Remove(info.window);
4201 else if ( info.sizer )
4202 return self->Remove(info.sizer);
4203 else if ( info.gotPos )
4204 return self->Remove(info.pos);
4205 else
4206 return false;
4207 }
4208 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4211 wxPyEndBlockThreads(blocked);
4212 if ( info.window )
4213 return self->Detach(info.window);
4214 else if ( info.sizer )
4215 return self->Detach(info.sizer);
4216 else if ( info.gotPos )
4217 return self->Detach(info.pos);
4218 else
4219 return false;
4220 }
4221 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->GetItem(info.window);
4227 else if ( info.sizer )
4228 return self->GetItem(info.sizer);
4229 else if ( info.gotPos )
4230 return self->GetItem(info.pos);
4231 else
4232 return NULL;
4233 }
4234 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 self->SetItemMinSize(info.window, size);
4240 else if ( info.sizer )
4241 self->SetItemMinSize(info.sizer, size);
4242 else if ( info.gotPos )
4243 self->SetItemMinSize(info.pos, size);
4244 }
4245 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4246 wxSizerItemList& list = self->GetChildren();
4247 return wxPy_ConvertList(&list);
4248 }
4249 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4252 wxPyEndBlockThreads(blocked);
4253 if ( info.window )
4254 return self->Show(info.window, show, recursive);
4255 else if ( info.sizer )
4256 return self->Show(info.sizer, show, recursive);
4257 else if ( info.gotPos )
4258 return self->Show(info.pos, show);
4259 else
4260 return false;
4261 }
4262 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4264 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4265 wxPyEndBlockThreads(blocked);
4266 if ( info.window )
4267 return self->IsShown(info.window);
4268 else if ( info.sizer )
4269 return self->IsShown(info.sizer);
4270 else if ( info.gotPos )
4271 return self->IsShown(info.pos);
4272 else
4273 return false;
4274 }
4275
4276 // See pyclasses.h
4277 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4278 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4279 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4280
4281
4282
4283
4284 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4285 {
4286 if (source == Py_None) {
4287 **obj = wxGBPosition(-1,-1);
4288 return true;
4289 }
4290 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4291 }
4292
4293 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4294 {
4295 if (source == Py_None) {
4296 **obj = wxGBSpan(-1,-1);
4297 return true;
4298 }
4299 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4300 }
4301
4302
4303 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4304 wxGBPosition temp, *obj = &temp;
4305 if ( other == Py_None ) return false;
4306 if ( ! wxGBPosition_helper(other, &obj) ) {
4307 PyErr_Clear();
4308 return false;
4309 }
4310 return self->operator==(*obj);
4311 }
4312 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4313 wxGBPosition temp, *obj = &temp;
4314 if ( other == Py_None ) return true;
4315 if ( ! wxGBPosition_helper(other, &obj)) {
4316 PyErr_Clear();
4317 return true;
4318 }
4319 return self->operator!=(*obj);
4320 }
4321 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4322 self->SetRow(row);
4323 self->SetCol(col);
4324 }
4325 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 PyObject* tup = PyTuple_New(2);
4328 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4329 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4330 wxPyEndBlockThreads(blocked);
4331 return tup;
4332 }
4333 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4334 wxGBSpan temp, *obj = &temp;
4335 if ( other == Py_None ) return false;
4336 if ( ! wxGBSpan_helper(other, &obj) ) {
4337 PyErr_Clear();
4338 return false;
4339 }
4340 return self->operator==(*obj);
4341 }
4342 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4343 wxGBSpan temp, *obj = &temp;
4344 if ( other == Py_None ) return true;
4345 if ( ! wxGBSpan_helper(other, &obj)) {
4346 PyErr_Clear();
4347 return true;
4348 }
4349 return self->operator!=(*obj);
4350 }
4351 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4352 self->SetRowspan(rowspan);
4353 self->SetColspan(colspan);
4354 }
4355 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 PyObject* tup = PyTuple_New(2);
4358 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4359 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4360 wxPyEndBlockThreads(blocked);
4361 return tup;
4362 }
4363 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4364 wxPyUserData* data = NULL;
4365 if ( userData ) {
4366 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4367 data = new wxPyUserData(userData);
4368 wxPyEndBlockThreads(blocked);
4369 }
4370 return new wxGBSizerItem(window, pos, span, flag, border, data);
4371 }
4372 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4373 wxPyUserData* data = NULL;
4374 if ( userData ) {
4375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4376 data = new wxPyUserData(userData);
4377 wxPyEndBlockThreads(blocked);
4378 }
4379 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4380 }
4381 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4382 wxPyUserData* data = NULL;
4383 if ( userData ) {
4384 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4385 data = new wxPyUserData(userData);
4386 wxPyEndBlockThreads(blocked);
4387 }
4388 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4389 }
4390 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4391 int row, col;
4392 self->GetEndPos(row, col);
4393 return wxGBPosition(row, col);
4394 }
4395 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4396
4397 wxPyUserData* data = NULL;
4398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4399 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4400 if ( userData && (info.window || info.sizer || info.gotSize) )
4401 data = new wxPyUserData(userData);
4402 if ( info.sizer )
4403 PyObject_SetAttrString(item,"thisown",Py_False);
4404 wxPyEndBlockThreads(blocked);
4405
4406 // Now call the real Add method if a valid item type was found
4407 if ( info.window )
4408 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4409 else if ( info.sizer )
4410 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4411 else if (info.gotSize)
4412 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4413 pos, span, flag, border, data);
4414 return NULL;
4415 }
4416
4417
4418 #ifdef __cplusplus
4419 extern "C" {
4420 #endif
4421 SWIGINTERN int EmptyString_set(PyObject *) {
4422 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4423 return 1;
4424 }
4425
4426
4427 SWIGINTERN PyObject *EmptyString_get(void) {
4428 PyObject *pyobj = 0;
4429
4430 {
4431 #if wxUSE_UNICODE
4432 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4433 #else
4434 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4435 #endif
4436 }
4437 return pyobj;
4438 }
4439
4440
4441 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442 PyObject *resultobj = 0;
4443 wxObject *arg1 = (wxObject *) 0 ;
4444 wxString result;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 PyObject *swig_obj[1] ;
4448
4449 if (!args) SWIG_fail;
4450 swig_obj[0] = args;
4451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4452 if (!SWIG_IsOK(res1)) {
4453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4454 }
4455 arg1 = reinterpret_cast< wxObject * >(argp1);
4456 {
4457 PyThreadState* __tstate = wxPyBeginAllowThreads();
4458 result = wxObject_GetClassName(arg1);
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 {
4463 #if wxUSE_UNICODE
4464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4465 #else
4466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4467 #endif
4468 }
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxObject *arg1 = (wxObject *) 0 ;
4478 void *argp1 = 0 ;
4479 int res1 = 0 ;
4480 PyObject *swig_obj[1] ;
4481
4482 if (!args) SWIG_fail;
4483 swig_obj[0] = args;
4484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4485 if (!SWIG_IsOK(res1)) {
4486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4487 }
4488 arg1 = reinterpret_cast< wxObject * >(argp1);
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 wxObject_Destroy(arg1);
4492 wxPyEndAllowThreads(__tstate);
4493 if (PyErr_Occurred()) SWIG_fail;
4494 }
4495 resultobj = SWIG_Py_Void();
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxObject *arg1 = (wxObject *) 0 ;
4505 wxObject *arg2 = 0 ;
4506 bool result;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 void *argp2 = 0 ;
4510 int res2 = 0 ;
4511 PyObject * obj0 = 0 ;
4512 PyObject * obj1 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "self",(char *) "p", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4519 if (!SWIG_IsOK(res1)) {
4520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4521 }
4522 arg1 = reinterpret_cast< wxObject * >(argp1);
4523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4524 if (!SWIG_IsOK(res2)) {
4525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4526 }
4527 if (!argp2) {
4528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4529 }
4530 arg2 = reinterpret_cast< wxObject * >(argp2);
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4547 PyObject *obj;
4548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4549 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4550 return SWIG_Py_Void();
4551 }
4552
4553 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 PyObject *resultobj = 0;
4555 wxSize *arg1 = (wxSize *) 0 ;
4556 int arg2 ;
4557 void *argp1 = 0 ;
4558 int res1 = 0 ;
4559 int val2 ;
4560 int ecode2 = 0 ;
4561 PyObject *swig_obj[2] ;
4562
4563 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4567 }
4568 arg1 = reinterpret_cast< wxSize * >(argp1);
4569 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4570 if (!SWIG_IsOK(ecode2)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4572 }
4573 arg2 = static_cast< int >(val2);
4574 if (arg1) (arg1)->x = arg2;
4575
4576 resultobj = SWIG_Py_Void();
4577 return resultobj;
4578 fail:
4579 return NULL;
4580 }
4581
4582
4583 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4584 PyObject *resultobj = 0;
4585 wxSize *arg1 = (wxSize *) 0 ;
4586 int result;
4587 void *argp1 = 0 ;
4588 int res1 = 0 ;
4589 PyObject *swig_obj[1] ;
4590
4591 if (!args) SWIG_fail;
4592 swig_obj[0] = args;
4593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 result = (int) ((arg1)->x);
4599 resultobj = SWIG_From_int(static_cast< int >(result));
4600 return resultobj;
4601 fail:
4602 return NULL;
4603 }
4604
4605
4606 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *resultobj = 0;
4608 wxSize *arg1 = (wxSize *) 0 ;
4609 int arg2 ;
4610 void *argp1 = 0 ;
4611 int res1 = 0 ;
4612 int val2 ;
4613 int ecode2 = 0 ;
4614 PyObject *swig_obj[2] ;
4615
4616 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4618 if (!SWIG_IsOK(res1)) {
4619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4620 }
4621 arg1 = reinterpret_cast< wxSize * >(argp1);
4622 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4623 if (!SWIG_IsOK(ecode2)) {
4624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4625 }
4626 arg2 = static_cast< int >(val2);
4627 if (arg1) (arg1)->y = arg2;
4628
4629 resultobj = SWIG_Py_Void();
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4637 PyObject *resultobj = 0;
4638 wxSize *arg1 = (wxSize *) 0 ;
4639 int result;
4640 void *argp1 = 0 ;
4641 int res1 = 0 ;
4642 PyObject *swig_obj[1] ;
4643
4644 if (!args) SWIG_fail;
4645 swig_obj[0] = args;
4646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4647 if (!SWIG_IsOK(res1)) {
4648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4649 }
4650 arg1 = reinterpret_cast< wxSize * >(argp1);
4651 result = (int) ((arg1)->y);
4652 resultobj = SWIG_From_int(static_cast< int >(result));
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 int arg1 = (int) 0 ;
4662 int arg2 = (int) 0 ;
4663 wxSize *result = 0 ;
4664 int val1 ;
4665 int ecode1 = 0 ;
4666 int val2 ;
4667 int ecode2 = 0 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 char * kwnames[] = {
4671 (char *) "w",(char *) "h", NULL
4672 };
4673
4674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4675 if (obj0) {
4676 ecode1 = SWIG_AsVal_int(obj0, &val1);
4677 if (!SWIG_IsOK(ecode1)) {
4678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4679 }
4680 arg1 = static_cast< int >(val1);
4681 }
4682 if (obj1) {
4683 ecode2 = SWIG_AsVal_int(obj1, &val2);
4684 if (!SWIG_IsOK(ecode2)) {
4685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4686 }
4687 arg2 = static_cast< int >(val2);
4688 }
4689 {
4690 result = (wxSize *)new wxSize(arg1,arg2);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4701 PyObject *resultobj = 0;
4702 wxSize *arg1 = (wxSize *) 0 ;
4703 void *argp1 = 0 ;
4704 int res1 = 0 ;
4705 PyObject *swig_obj[1] ;
4706
4707 if (!args) SWIG_fail;
4708 swig_obj[0] = args;
4709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4710 if (!SWIG_IsOK(res1)) {
4711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4712 }
4713 arg1 = reinterpret_cast< wxSize * >(argp1);
4714 {
4715 delete arg1;
4716
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = SWIG_Py_Void();
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 PyObject *arg2 = (PyObject *) 0 ;
4730 bool result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "other", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 arg2 = obj1;
4746 {
4747 result = (bool)wxSize___eq__(arg1,arg2);
4748 if (PyErr_Occurred()) SWIG_fail;
4749 }
4750 {
4751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4752 }
4753 return resultobj;
4754 fail:
4755 return NULL;
4756 }
4757
4758
4759 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4760 PyObject *resultobj = 0;
4761 wxSize *arg1 = (wxSize *) 0 ;
4762 PyObject *arg2 = (PyObject *) 0 ;
4763 bool result;
4764 void *argp1 = 0 ;
4765 int res1 = 0 ;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 char * kwnames[] = {
4769 (char *) "self",(char *) "other", NULL
4770 };
4771
4772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4774 if (!SWIG_IsOK(res1)) {
4775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4776 }
4777 arg1 = reinterpret_cast< wxSize * >(argp1);
4778 arg2 = obj1;
4779 {
4780 result = (bool)wxSize___ne__(arg1,arg2);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 {
4784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4785 }
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj = 0;
4794 wxSize *arg1 = (wxSize *) 0 ;
4795 wxSize *arg2 = 0 ;
4796 wxSize result;
4797 void *argp1 = 0 ;
4798 int res1 = 0 ;
4799 wxSize temp2 ;
4800 PyObject * obj0 = 0 ;
4801 PyObject * obj1 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "self",(char *) "sz", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4808 if (!SWIG_IsOK(res1)) {
4809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4810 }
4811 arg1 = reinterpret_cast< wxSize * >(argp1);
4812 {
4813 arg2 = &temp2;
4814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4815 }
4816 {
4817 result = (arg1)->operator +((wxSize const &)*arg2);
4818 if (PyErr_Occurred()) SWIG_fail;
4819 }
4820 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4821 return resultobj;
4822 fail:
4823 return NULL;
4824 }
4825
4826
4827 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4828 PyObject *resultobj = 0;
4829 wxSize *arg1 = (wxSize *) 0 ;
4830 wxSize *arg2 = 0 ;
4831 wxSize result;
4832 void *argp1 = 0 ;
4833 int res1 = 0 ;
4834 wxSize temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char * kwnames[] = {
4838 (char *) "self",(char *) "sz", NULL
4839 };
4840
4841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4843 if (!SWIG_IsOK(res1)) {
4844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4845 }
4846 arg1 = reinterpret_cast< wxSize * >(argp1);
4847 {
4848 arg2 = &temp2;
4849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4850 }
4851 {
4852 result = (arg1)->operator -((wxSize const &)*arg2);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4863 PyObject *resultobj = 0;
4864 wxSize *arg1 = (wxSize *) 0 ;
4865 wxSize *arg2 = 0 ;
4866 void *argp1 = 0 ;
4867 int res1 = 0 ;
4868 wxSize temp2 ;
4869 PyObject * obj0 = 0 ;
4870 PyObject * obj1 = 0 ;
4871 char * kwnames[] = {
4872 (char *) "self",(char *) "sz", NULL
4873 };
4874
4875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4877 if (!SWIG_IsOK(res1)) {
4878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4879 }
4880 arg1 = reinterpret_cast< wxSize * >(argp1);
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 {
4886 (arg1)->IncTo((wxSize const &)*arg2);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 wxSize *arg1 = (wxSize *) 0 ;
4899 wxSize *arg2 = 0 ;
4900 void *argp1 = 0 ;
4901 int res1 = 0 ;
4902 wxSize temp2 ;
4903 PyObject * obj0 = 0 ;
4904 PyObject * obj1 = 0 ;
4905 char * kwnames[] = {
4906 (char *) "self",(char *) "sz", NULL
4907 };
4908
4909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4911 if (!SWIG_IsOK(res1)) {
4912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4913 }
4914 arg1 = reinterpret_cast< wxSize * >(argp1);
4915 {
4916 arg2 = &temp2;
4917 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4918 }
4919 {
4920 (arg1)->DecTo((wxSize const &)*arg2);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 resultobj = SWIG_Py_Void();
4924 return resultobj;
4925 fail:
4926 return NULL;
4927 }
4928
4929
4930 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj = 0;
4932 wxSize *arg1 = (wxSize *) 0 ;
4933 int arg2 ;
4934 int arg3 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 int val2 ;
4938 int ecode2 = 0 ;
4939 int val3 ;
4940 int ecode3 = 0 ;
4941 PyObject * obj0 = 0 ;
4942 PyObject * obj1 = 0 ;
4943 PyObject * obj2 = 0 ;
4944 char * kwnames[] = {
4945 (char *) "self",(char *) "dx",(char *) "dy", NULL
4946 };
4947
4948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4952 }
4953 arg1 = reinterpret_cast< wxSize * >(argp1);
4954 ecode2 = SWIG_AsVal_int(obj1, &val2);
4955 if (!SWIG_IsOK(ecode2)) {
4956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4957 }
4958 arg2 = static_cast< int >(val2);
4959 ecode3 = SWIG_AsVal_int(obj2, &val3);
4960 if (!SWIG_IsOK(ecode3)) {
4961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4962 }
4963 arg3 = static_cast< int >(val3);
4964 {
4965 (arg1)->IncBy(arg2,arg3);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_Py_Void();
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj = 0;
4977 wxSize *arg1 = (wxSize *) 0 ;
4978 int arg2 ;
4979 int arg3 ;
4980 void *argp1 = 0 ;
4981 int res1 = 0 ;
4982 int val2 ;
4983 int ecode2 = 0 ;
4984 int val3 ;
4985 int ecode3 = 0 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 PyObject * obj2 = 0 ;
4989 char * kwnames[] = {
4990 (char *) "self",(char *) "dx",(char *) "dy", NULL
4991 };
4992
4993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4995 if (!SWIG_IsOK(res1)) {
4996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4997 }
4998 arg1 = reinterpret_cast< wxSize * >(argp1);
4999 ecode2 = SWIG_AsVal_int(obj1, &val2);
5000 if (!SWIG_IsOK(ecode2)) {
5001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5002 }
5003 arg2 = static_cast< int >(val2);
5004 ecode3 = SWIG_AsVal_int(obj2, &val3);
5005 if (!SWIG_IsOK(ecode3)) {
5006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5007 }
5008 arg3 = static_cast< int >(val3);
5009 {
5010 (arg1)->DecBy(arg2,arg3);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 float arg2 ;
5024 float arg3 ;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 float val2 ;
5028 int ecode2 = 0 ;
5029 float val3 ;
5030 int ecode3 = 0 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 PyObject * obj2 = 0 ;
5034 char * kwnames[] = {
5035 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5036 };
5037
5038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5040 if (!SWIG_IsOK(res1)) {
5041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5042 }
5043 arg1 = reinterpret_cast< wxSize * >(argp1);
5044 ecode2 = SWIG_AsVal_float(obj1, &val2);
5045 if (!SWIG_IsOK(ecode2)) {
5046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5047 }
5048 arg2 = static_cast< float >(val2);
5049 ecode3 = SWIG_AsVal_float(obj2, &val3);
5050 if (!SWIG_IsOK(ecode3)) {
5051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5052 }
5053 arg3 = static_cast< float >(val3);
5054 {
5055 (arg1)->Scale(arg2,arg3);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 resultobj = SWIG_Py_Void();
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj = 0;
5067 wxSize *arg1 = (wxSize *) 0 ;
5068 int arg2 ;
5069 int arg3 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 int val2 ;
5073 int ecode2 = 0 ;
5074 int val3 ;
5075 int ecode3 = 0 ;
5076 PyObject * obj0 = 0 ;
5077 PyObject * obj1 = 0 ;
5078 PyObject * obj2 = 0 ;
5079 char * kwnames[] = {
5080 (char *) "self",(char *) "w",(char *) "h", NULL
5081 };
5082
5083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5087 }
5088 arg1 = reinterpret_cast< wxSize * >(argp1);
5089 ecode2 = SWIG_AsVal_int(obj1, &val2);
5090 if (!SWIG_IsOK(ecode2)) {
5091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5092 }
5093 arg2 = static_cast< int >(val2);
5094 ecode3 = SWIG_AsVal_int(obj2, &val3);
5095 if (!SWIG_IsOK(ecode3)) {
5096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5097 }
5098 arg3 = static_cast< int >(val3);
5099 {
5100 (arg1)->Set(arg2,arg3);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_Py_Void();
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 int arg2 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 int val2 ;
5117 int ecode2 = 0 ;
5118 PyObject * obj0 = 0 ;
5119 PyObject * obj1 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "self",(char *) "w", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5128 }
5129 arg1 = reinterpret_cast< wxSize * >(argp1);
5130 ecode2 = SWIG_AsVal_int(obj1, &val2);
5131 if (!SWIG_IsOK(ecode2)) {
5132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5133 }
5134 arg2 = static_cast< int >(val2);
5135 {
5136 (arg1)->SetWidth(arg2);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 int arg2 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 int val2 ;
5153 int ecode2 = 0 ;
5154 PyObject * obj0 = 0 ;
5155 PyObject * obj1 = 0 ;
5156 char * kwnames[] = {
5157 (char *) "self",(char *) "h", NULL
5158 };
5159
5160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5162 if (!SWIG_IsOK(res1)) {
5163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5164 }
5165 arg1 = reinterpret_cast< wxSize * >(argp1);
5166 ecode2 = SWIG_AsVal_int(obj1, &val2);
5167 if (!SWIG_IsOK(ecode2)) {
5168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5169 }
5170 arg2 = static_cast< int >(val2);
5171 {
5172 (arg1)->SetHeight(arg2);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 resultobj = SWIG_Py_Void();
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxSize *arg1 = (wxSize *) 0 ;
5185 int result;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 PyObject *swig_obj[1] ;
5189
5190 if (!args) SWIG_fail;
5191 swig_obj[0] = args;
5192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5195 }
5196 arg1 = reinterpret_cast< wxSize * >(argp1);
5197 {
5198 result = (int)((wxSize const *)arg1)->GetWidth();
5199 if (PyErr_Occurred()) SWIG_fail;
5200 }
5201 resultobj = SWIG_From_int(static_cast< int >(result));
5202 return resultobj;
5203 fail:
5204 return NULL;
5205 }
5206
5207
5208 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5209 PyObject *resultobj = 0;
5210 wxSize *arg1 = (wxSize *) 0 ;
5211 int result;
5212 void *argp1 = 0 ;
5213 int res1 = 0 ;
5214 PyObject *swig_obj[1] ;
5215
5216 if (!args) SWIG_fail;
5217 swig_obj[0] = args;
5218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5219 if (!SWIG_IsOK(res1)) {
5220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5221 }
5222 arg1 = reinterpret_cast< wxSize * >(argp1);
5223 {
5224 result = (int)((wxSize const *)arg1)->GetHeight();
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 resultobj = SWIG_From_int(static_cast< int >(result));
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5235 PyObject *resultobj = 0;
5236 wxSize *arg1 = (wxSize *) 0 ;
5237 bool result;
5238 void *argp1 = 0 ;
5239 int res1 = 0 ;
5240 PyObject *swig_obj[1] ;
5241
5242 if (!args) SWIG_fail;
5243 swig_obj[0] = args;
5244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5245 if (!SWIG_IsOK(res1)) {
5246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5247 }
5248 arg1 = reinterpret_cast< wxSize * >(argp1);
5249 {
5250 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 {
5254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5255 }
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 wxSize *arg1 = (wxSize *) 0 ;
5265 wxSize *arg2 = 0 ;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 wxSize temp2 ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "size", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5279 }
5280 arg1 = reinterpret_cast< wxSize * >(argp1);
5281 {
5282 arg2 = &temp2;
5283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5284 }
5285 {
5286 (arg1)->SetDefaults((wxSize const &)*arg2);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 resultobj = SWIG_Py_Void();
5290 return resultobj;
5291 fail:
5292 return NULL;
5293 }
5294
5295
5296 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxSize *arg1 = (wxSize *) 0 ;
5299 PyObject *result = 0 ;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 PyObject *swig_obj[1] ;
5303
5304 if (!args) SWIG_fail;
5305 swig_obj[0] = args;
5306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5307 if (!SWIG_IsOK(res1)) {
5308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5309 }
5310 arg1 = reinterpret_cast< wxSize * >(argp1);
5311 {
5312 result = (PyObject *)wxSize_Get(arg1);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 resultobj = result;
5316 return resultobj;
5317 fail:
5318 return NULL;
5319 }
5320
5321
5322 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5323 PyObject *obj;
5324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5325 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5326 return SWIG_Py_Void();
5327 }
5328
5329 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 return SWIG_Python_InitShadowInstance(args);
5331 }
5332
5333 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5334 PyObject *resultobj = 0;
5335 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5336 double arg2 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 double val2 ;
5340 int ecode2 = 0 ;
5341 PyObject *swig_obj[2] ;
5342
5343 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5350 if (!SWIG_IsOK(ecode2)) {
5351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5352 }
5353 arg2 = static_cast< double >(val2);
5354 if (arg1) (arg1)->x = arg2;
5355
5356 resultobj = SWIG_Py_Void();
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 double result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject *swig_obj[1] ;
5370
5371 if (!args) SWIG_fail;
5372 swig_obj[0] = args;
5373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5376 }
5377 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5378 result = (double) ((arg1)->x);
5379 resultobj = SWIG_From_double(static_cast< double >(result));
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5387 PyObject *resultobj = 0;
5388 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5389 double arg2 ;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 double val2 ;
5393 int ecode2 = 0 ;
5394 PyObject *swig_obj[2] ;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5398 if (!SWIG_IsOK(res1)) {
5399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5400 }
5401 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5402 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5403 if (!SWIG_IsOK(ecode2)) {
5404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5405 }
5406 arg2 = static_cast< double >(val2);
5407 if (arg1) (arg1)->y = arg2;
5408
5409 resultobj = SWIG_Py_Void();
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5419 double result;
5420 void *argp1 = 0 ;
5421 int res1 = 0 ;
5422 PyObject *swig_obj[1] ;
5423
5424 if (!args) SWIG_fail;
5425 swig_obj[0] = args;
5426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5427 if (!SWIG_IsOK(res1)) {
5428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5429 }
5430 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5431 result = (double) ((arg1)->y);
5432 resultobj = SWIG_From_double(static_cast< double >(result));
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 double arg1 = (double) 0.0 ;
5442 double arg2 = (double) 0.0 ;
5443 wxRealPoint *result = 0 ;
5444 double val1 ;
5445 int ecode1 = 0 ;
5446 double val2 ;
5447 int ecode2 = 0 ;
5448 PyObject * obj0 = 0 ;
5449 PyObject * obj1 = 0 ;
5450 char * kwnames[] = {
5451 (char *) "x",(char *) "y", NULL
5452 };
5453
5454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5455 if (obj0) {
5456 ecode1 = SWIG_AsVal_double(obj0, &val1);
5457 if (!SWIG_IsOK(ecode1)) {
5458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5459 }
5460 arg1 = static_cast< double >(val1);
5461 }
5462 if (obj1) {
5463 ecode2 = SWIG_AsVal_double(obj1, &val2);
5464 if (!SWIG_IsOK(ecode2)) {
5465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5466 }
5467 arg2 = static_cast< double >(val2);
5468 }
5469 {
5470 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 void *argp1 = 0 ;
5484 int res1 = 0 ;
5485 PyObject *swig_obj[1] ;
5486
5487 if (!args) SWIG_fail;
5488 swig_obj[0] = args;
5489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5490 if (!SWIG_IsOK(res1)) {
5491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5492 }
5493 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5494 {
5495 delete arg1;
5496
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 PyObject *arg2 = (PyObject *) 0 ;
5510 bool result;
5511 void *argp1 = 0 ;
5512 int res1 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char * kwnames[] = {
5516 (char *) "self",(char *) "other", NULL
5517 };
5518
5519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5521 if (!SWIG_IsOK(res1)) {
5522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5523 }
5524 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5525 arg2 = obj1;
5526 {
5527 result = (bool)wxRealPoint___eq__(arg1,arg2);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj = 0;
5541 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5542 PyObject *arg2 = (PyObject *) 0 ;
5543 bool result;
5544 void *argp1 = 0 ;
5545 int res1 = 0 ;
5546 PyObject * obj0 = 0 ;
5547 PyObject * obj1 = 0 ;
5548 char * kwnames[] = {
5549 (char *) "self",(char *) "other", NULL
5550 };
5551
5552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5554 if (!SWIG_IsOK(res1)) {
5555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5556 }
5557 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5558 arg2 = obj1;
5559 {
5560 result = (bool)wxRealPoint___ne__(arg1,arg2);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 {
5564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5565 }
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5573 PyObject *resultobj = 0;
5574 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5575 wxRealPoint *arg2 = 0 ;
5576 wxRealPoint result;
5577 void *argp1 = 0 ;
5578 int res1 = 0 ;
5579 wxRealPoint temp2 ;
5580 PyObject * obj0 = 0 ;
5581 PyObject * obj1 = 0 ;
5582 char * kwnames[] = {
5583 (char *) "self",(char *) "pt", NULL
5584 };
5585
5586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5588 if (!SWIG_IsOK(res1)) {
5589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5590 }
5591 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5592 {
5593 arg2 = &temp2;
5594 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5595 }
5596 {
5597 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5601 return resultobj;
5602 fail:
5603 return NULL;
5604 }
5605
5606
5607 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj = 0;
5609 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5610 wxRealPoint *arg2 = 0 ;
5611 wxRealPoint result;
5612 void *argp1 = 0 ;
5613 int res1 = 0 ;
5614 wxRealPoint temp2 ;
5615 PyObject * obj0 = 0 ;
5616 PyObject * obj1 = 0 ;
5617 char * kwnames[] = {
5618 (char *) "self",(char *) "pt", NULL
5619 };
5620
5621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5623 if (!SWIG_IsOK(res1)) {
5624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5625 }
5626 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5627 {
5628 arg2 = &temp2;
5629 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5630 }
5631 {
5632 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = 0;
5644 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5645 double arg2 ;
5646 double arg3 ;
5647 void *argp1 = 0 ;
5648 int res1 = 0 ;
5649 double val2 ;
5650 int ecode2 = 0 ;
5651 double val3 ;
5652 int ecode3 = 0 ;
5653 PyObject * obj0 = 0 ;
5654 PyObject * obj1 = 0 ;
5655 PyObject * obj2 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "self",(char *) "x",(char *) "y", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5662 if (!SWIG_IsOK(res1)) {
5663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5664 }
5665 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5666 ecode2 = SWIG_AsVal_double(obj1, &val2);
5667 if (!SWIG_IsOK(ecode2)) {
5668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5669 }
5670 arg2 = static_cast< double >(val2);
5671 ecode3 = SWIG_AsVal_double(obj2, &val3);
5672 if (!SWIG_IsOK(ecode3)) {
5673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5674 }
5675 arg3 = static_cast< double >(val3);
5676 {
5677 wxRealPoint_Set(arg1,arg2,arg3);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5690 PyObject *result = 0 ;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5702 {
5703 result = (PyObject *)wxRealPoint_Get(arg1);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = result;
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5714 PyObject *obj;
5715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5716 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5717 return SWIG_Py_Void();
5718 }
5719
5720 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5721 return SWIG_Python_InitShadowInstance(args);
5722 }
5723
5724 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5725 PyObject *resultobj = 0;
5726 wxPoint *arg1 = (wxPoint *) 0 ;
5727 int arg2 ;
5728 void *argp1 = 0 ;
5729 int res1 = 0 ;
5730 int val2 ;
5731 int ecode2 = 0 ;
5732 PyObject *swig_obj[2] ;
5733
5734 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxPoint * >(argp1);
5740 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5741 if (!SWIG_IsOK(ecode2)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5743 }
5744 arg2 = static_cast< int >(val2);
5745 if (arg1) (arg1)->x = arg2;
5746
5747 resultobj = SWIG_Py_Void();
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5755 PyObject *resultobj = 0;
5756 wxPoint *arg1 = (wxPoint *) 0 ;
5757 int result;
5758 void *argp1 = 0 ;
5759 int res1 = 0 ;
5760 PyObject *swig_obj[1] ;
5761
5762 if (!args) SWIG_fail;
5763 swig_obj[0] = args;
5764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5765 if (!SWIG_IsOK(res1)) {
5766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5767 }
5768 arg1 = reinterpret_cast< wxPoint * >(argp1);
5769 result = (int) ((arg1)->x);
5770 resultobj = SWIG_From_int(static_cast< int >(result));
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5778 PyObject *resultobj = 0;
5779 wxPoint *arg1 = (wxPoint *) 0 ;
5780 int arg2 ;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 int val2 ;
5784 int ecode2 = 0 ;
5785 PyObject *swig_obj[2] ;
5786
5787 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5789 if (!SWIG_IsOK(res1)) {
5790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5791 }
5792 arg1 = reinterpret_cast< wxPoint * >(argp1);
5793 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5794 if (!SWIG_IsOK(ecode2)) {
5795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5796 }
5797 arg2 = static_cast< int >(val2);
5798 if (arg1) (arg1)->y = arg2;
5799
5800 resultobj = SWIG_Py_Void();
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5808 PyObject *resultobj = 0;
5809 wxPoint *arg1 = (wxPoint *) 0 ;
5810 int result;
5811 void *argp1 = 0 ;
5812 int res1 = 0 ;
5813 PyObject *swig_obj[1] ;
5814
5815 if (!args) SWIG_fail;
5816 swig_obj[0] = args;
5817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5818 if (!SWIG_IsOK(res1)) {
5819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5820 }
5821 arg1 = reinterpret_cast< wxPoint * >(argp1);
5822 result = (int) ((arg1)->y);
5823 resultobj = SWIG_From_int(static_cast< int >(result));
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = 0;
5832 int arg1 = (int) 0 ;
5833 int arg2 = (int) 0 ;
5834 wxPoint *result = 0 ;
5835 int val1 ;
5836 int ecode1 = 0 ;
5837 int val2 ;
5838 int ecode2 = 0 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "x",(char *) "y", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5846 if (obj0) {
5847 ecode1 = SWIG_AsVal_int(obj0, &val1);
5848 if (!SWIG_IsOK(ecode1)) {
5849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5850 }
5851 arg1 = static_cast< int >(val1);
5852 }
5853 if (obj1) {
5854 ecode2 = SWIG_AsVal_int(obj1, &val2);
5855 if (!SWIG_IsOK(ecode2)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5857 }
5858 arg2 = static_cast< int >(val2);
5859 }
5860 {
5861 result = (wxPoint *)new wxPoint(arg1,arg2);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5872 PyObject *resultobj = 0;
5873 wxPoint *arg1 = (wxPoint *) 0 ;
5874 void *argp1 = 0 ;
5875 int res1 = 0 ;
5876 PyObject *swig_obj[1] ;
5877
5878 if (!args) SWIG_fail;
5879 swig_obj[0] = args;
5880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 delete arg1;
5887
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 resultobj = SWIG_Py_Void();
5891 return resultobj;
5892 fail:
5893 return NULL;
5894 }
5895
5896
5897 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5898 PyObject *resultobj = 0;
5899 wxPoint *arg1 = (wxPoint *) 0 ;
5900 PyObject *arg2 = (PyObject *) 0 ;
5901 bool result;
5902 void *argp1 = 0 ;
5903 int res1 = 0 ;
5904 PyObject * obj0 = 0 ;
5905 PyObject * obj1 = 0 ;
5906 char * kwnames[] = {
5907 (char *) "self",(char *) "other", NULL
5908 };
5909
5910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5912 if (!SWIG_IsOK(res1)) {
5913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5914 }
5915 arg1 = reinterpret_cast< wxPoint * >(argp1);
5916 arg2 = obj1;
5917 {
5918 result = (bool)wxPoint___eq__(arg1,arg2);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5923 }
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj = 0;
5932 wxPoint *arg1 = (wxPoint *) 0 ;
5933 PyObject *arg2 = (PyObject *) 0 ;
5934 bool result;
5935 void *argp1 = 0 ;
5936 int res1 = 0 ;
5937 PyObject * obj0 = 0 ;
5938 PyObject * obj1 = 0 ;
5939 char * kwnames[] = {
5940 (char *) "self",(char *) "other", NULL
5941 };
5942
5943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5945 if (!SWIG_IsOK(res1)) {
5946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5947 }
5948 arg1 = reinterpret_cast< wxPoint * >(argp1);
5949 arg2 = obj1;
5950 {
5951 result = (bool)wxPoint___ne__(arg1,arg2);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj = 0;
5965 wxPoint *arg1 = (wxPoint *) 0 ;
5966 wxPoint *arg2 = 0 ;
5967 wxPoint result;
5968 void *argp1 = 0 ;
5969 int res1 = 0 ;
5970 wxPoint temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char * kwnames[] = {
5974 (char *) "self",(char *) "pt", NULL
5975 };
5976
5977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5979 if (!SWIG_IsOK(res1)) {
5980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5981 }
5982 arg1 = reinterpret_cast< wxPoint * >(argp1);
5983 {
5984 arg2 = &temp2;
5985 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5986 }
5987 {
5988 result = (arg1)->operator +((wxPoint const &)*arg2);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj = 0;
6000 wxPoint *arg1 = (wxPoint *) 0 ;
6001 wxPoint *arg2 = 0 ;
6002 wxPoint result;
6003 void *argp1 = 0 ;
6004 int res1 = 0 ;
6005 wxPoint temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char * kwnames[] = {
6009 (char *) "self",(char *) "pt", NULL
6010 };
6011
6012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6014 if (!SWIG_IsOK(res1)) {
6015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6016 }
6017 arg1 = reinterpret_cast< wxPoint * >(argp1);
6018 {
6019 arg2 = &temp2;
6020 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6021 }
6022 {
6023 result = (arg1)->operator -((wxPoint const &)*arg2);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj = 0;
6035 wxPoint *arg1 = (wxPoint *) 0 ;
6036 wxPoint *arg2 = 0 ;
6037 wxPoint *result = 0 ;
6038 void *argp1 = 0 ;
6039 int res1 = 0 ;
6040 wxPoint temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char * kwnames[] = {
6044 (char *) "self",(char *) "pt", NULL
6045 };
6046
6047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6049 if (!SWIG_IsOK(res1)) {
6050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6051 }
6052 arg1 = reinterpret_cast< wxPoint * >(argp1);
6053 {
6054 arg2 = &temp2;
6055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 {
6059 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6060 result = (wxPoint *) &_result_ref;
6061 }
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 wxPoint *arg1 = (wxPoint *) 0 ;
6074 wxPoint *arg2 = 0 ;
6075 wxPoint *result = 0 ;
6076 void *argp1 = 0 ;
6077 int res1 = 0 ;
6078 wxPoint temp2 ;
6079 PyObject * obj0 = 0 ;
6080 PyObject * obj1 = 0 ;
6081 char * kwnames[] = {
6082 (char *) "self",(char *) "pt", NULL
6083 };
6084
6085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6087 if (!SWIG_IsOK(res1)) {
6088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6089 }
6090 arg1 = reinterpret_cast< wxPoint * >(argp1);
6091 {
6092 arg2 = &temp2;
6093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6094 }
6095 {
6096 {
6097 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6098 result = (wxPoint *) &_result_ref;
6099 }
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = 0;
6111 wxPoint *arg1 = (wxPoint *) 0 ;
6112 long arg2 ;
6113 long arg3 ;
6114 void *argp1 = 0 ;
6115 int res1 = 0 ;
6116 long val2 ;
6117 int ecode2 = 0 ;
6118 long val3 ;
6119 int ecode3 = 0 ;
6120 PyObject * obj0 = 0 ;
6121 PyObject * obj1 = 0 ;
6122 PyObject * obj2 = 0 ;
6123 char * kwnames[] = {
6124 (char *) "self",(char *) "x",(char *) "y", NULL
6125 };
6126
6127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6129 if (!SWIG_IsOK(res1)) {
6130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6131 }
6132 arg1 = reinterpret_cast< wxPoint * >(argp1);
6133 ecode2 = SWIG_AsVal_long(obj1, &val2);
6134 if (!SWIG_IsOK(ecode2)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6136 }
6137 arg2 = static_cast< long >(val2);
6138 ecode3 = SWIG_AsVal_long(obj2, &val3);
6139 if (!SWIG_IsOK(ecode3)) {
6140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6141 }
6142 arg3 = static_cast< long >(val3);
6143 {
6144 wxPoint_Set(arg1,arg2,arg3);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_Py_Void();
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *resultobj = 0;
6156 wxPoint *arg1 = (wxPoint *) 0 ;
6157 PyObject *result = 0 ;
6158 void *argp1 = 0 ;
6159 int res1 = 0 ;
6160 PyObject *swig_obj[1] ;
6161
6162 if (!args) SWIG_fail;
6163 swig_obj[0] = args;
6164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6165 if (!SWIG_IsOK(res1)) {
6166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6167 }
6168 arg1 = reinterpret_cast< wxPoint * >(argp1);
6169 {
6170 result = (PyObject *)wxPoint_Get(arg1);
6171 if (PyErr_Occurred()) SWIG_fail;
6172 }
6173 resultobj = result;
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6181 PyObject *obj;
6182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6183 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6184 return SWIG_Py_Void();
6185 }
6186
6187 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6188 return SWIG_Python_InitShadowInstance(args);
6189 }
6190
6191 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj = 0;
6193 int arg1 = (int) 0 ;
6194 int arg2 = (int) 0 ;
6195 int arg3 = (int) 0 ;
6196 int arg4 = (int) 0 ;
6197 wxRect *result = 0 ;
6198 int val1 ;
6199 int ecode1 = 0 ;
6200 int val2 ;
6201 int ecode2 = 0 ;
6202 int val3 ;
6203 int ecode3 = 0 ;
6204 int val4 ;
6205 int ecode4 = 0 ;
6206 PyObject * obj0 = 0 ;
6207 PyObject * obj1 = 0 ;
6208 PyObject * obj2 = 0 ;
6209 PyObject * obj3 = 0 ;
6210 char * kwnames[] = {
6211 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6212 };
6213
6214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6215 if (obj0) {
6216 ecode1 = SWIG_AsVal_int(obj0, &val1);
6217 if (!SWIG_IsOK(ecode1)) {
6218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6219 }
6220 arg1 = static_cast< int >(val1);
6221 }
6222 if (obj1) {
6223 ecode2 = SWIG_AsVal_int(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6226 }
6227 arg2 = static_cast< int >(val2);
6228 }
6229 if (obj2) {
6230 ecode3 = SWIG_AsVal_int(obj2, &val3);
6231 if (!SWIG_IsOK(ecode3)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6233 }
6234 arg3 = static_cast< int >(val3);
6235 }
6236 if (obj3) {
6237 ecode4 = SWIG_AsVal_int(obj3, &val4);
6238 if (!SWIG_IsOK(ecode4)) {
6239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6240 }
6241 arg4 = static_cast< int >(val4);
6242 }
6243 {
6244 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6245 if (PyErr_Occurred()) SWIG_fail;
6246 }
6247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6255 PyObject *resultobj = 0;
6256 wxPoint *arg1 = 0 ;
6257 wxPoint *arg2 = 0 ;
6258 wxRect *result = 0 ;
6259 wxPoint temp1 ;
6260 wxPoint temp2 ;
6261 PyObject * obj0 = 0 ;
6262 PyObject * obj1 = 0 ;
6263 char * kwnames[] = {
6264 (char *) "topLeft",(char *) "bottomRight", NULL
6265 };
6266
6267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6268 {
6269 arg1 = &temp1;
6270 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6271 }
6272 {
6273 arg2 = &temp2;
6274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6275 }
6276 {
6277 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj = 0;
6289 wxPoint *arg1 = 0 ;
6290 wxSize *arg2 = 0 ;
6291 wxRect *result = 0 ;
6292 wxPoint temp1 ;
6293 wxSize temp2 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char * kwnames[] = {
6297 (char *) "pos",(char *) "size", NULL
6298 };
6299
6300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6301 {
6302 arg1 = &temp1;
6303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6304 }
6305 {
6306 arg2 = &temp2;
6307 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6308 }
6309 {
6310 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6311 if (PyErr_Occurred()) SWIG_fail;
6312 }
6313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj = 0;
6322 wxSize *arg1 = 0 ;
6323 wxRect *result = 0 ;
6324 wxSize temp1 ;
6325 PyObject * obj0 = 0 ;
6326 char * kwnames[] = {
6327 (char *) "size", NULL
6328 };
6329
6330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6331 {
6332 arg1 = &temp1;
6333 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6334 }
6335 {
6336 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 delete arg1;
6362
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_Py_Void();
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int result;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 PyObject *swig_obj[1] ;
6379
6380 if (!args) SWIG_fail;
6381 swig_obj[0] = args;
6382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6385 }
6386 arg1 = reinterpret_cast< wxRect * >(argp1);
6387 {
6388 result = (int)((wxRect const *)arg1)->GetX();
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = SWIG_From_int(static_cast< int >(result));
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6399 PyObject *resultobj = 0;
6400 wxRect *arg1 = (wxRect *) 0 ;
6401 int arg2 ;
6402 void *argp1 = 0 ;
6403 int res1 = 0 ;
6404 int val2 ;
6405 int ecode2 = 0 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "self",(char *) "x", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6414 if (!SWIG_IsOK(res1)) {
6415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6416 }
6417 arg1 = reinterpret_cast< wxRect * >(argp1);
6418 ecode2 = SWIG_AsVal_int(obj1, &val2);
6419 if (!SWIG_IsOK(ecode2)) {
6420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6421 }
6422 arg2 = static_cast< int >(val2);
6423 {
6424 (arg1)->SetX(arg2);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = SWIG_Py_Void();
6428 return resultobj;
6429 fail:
6430 return NULL;
6431 }
6432
6433
6434 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6435 PyObject *resultobj = 0;
6436 wxRect *arg1 = (wxRect *) 0 ;
6437 int result;
6438 void *argp1 = 0 ;
6439 int res1 = 0 ;
6440 PyObject *swig_obj[1] ;
6441
6442 if (!args) SWIG_fail;
6443 swig_obj[0] = args;
6444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6445 if (!SWIG_IsOK(res1)) {
6446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6447 }
6448 arg1 = reinterpret_cast< wxRect * >(argp1);
6449 {
6450 result = (int)(arg1)->GetY();
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_From_int(static_cast< int >(result));
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int arg2 ;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 int val2 ;
6467 int ecode2 = 0 ;
6468 PyObject * obj0 = 0 ;
6469 PyObject * obj1 = 0 ;
6470 char * kwnames[] = {
6471 (char *) "self",(char *) "y", NULL
6472 };
6473
6474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6478 }
6479 arg1 = reinterpret_cast< wxRect * >(argp1);
6480 ecode2 = SWIG_AsVal_int(obj1, &val2);
6481 if (!SWIG_IsOK(ecode2)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6483 }
6484 arg2 = static_cast< int >(val2);
6485 {
6486 (arg1)->SetY(arg2);
6487 if (PyErr_Occurred()) SWIG_fail;
6488 }
6489 resultobj = SWIG_Py_Void();
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6497 PyObject *resultobj = 0;
6498 wxRect *arg1 = (wxRect *) 0 ;
6499 int result;
6500 void *argp1 = 0 ;
6501 int res1 = 0 ;
6502 PyObject *swig_obj[1] ;
6503
6504 if (!args) SWIG_fail;
6505 swig_obj[0] = args;
6506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6509 }
6510 arg1 = reinterpret_cast< wxRect * >(argp1);
6511 {
6512 result = (int)((wxRect const *)arg1)->GetWidth();
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 resultobj = SWIG_From_int(static_cast< int >(result));
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6523 PyObject *resultobj = 0;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 int arg2 ;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 int val2 ;
6529 int ecode2 = 0 ;
6530 PyObject * obj0 = 0 ;
6531 PyObject * obj1 = 0 ;
6532 char * kwnames[] = {
6533 (char *) "self",(char *) "w", NULL
6534 };
6535
6536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 ecode2 = SWIG_AsVal_int(obj1, &val2);
6543 if (!SWIG_IsOK(ecode2)) {
6544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6545 }
6546 arg2 = static_cast< int >(val2);
6547 {
6548 (arg1)->SetWidth(arg2);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 resultobj = SWIG_Py_Void();
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6559 PyObject *resultobj = 0;
6560 wxRect *arg1 = (wxRect *) 0 ;
6561 int result;
6562 void *argp1 = 0 ;
6563 int res1 = 0 ;
6564 PyObject *swig_obj[1] ;
6565
6566 if (!args) SWIG_fail;
6567 swig_obj[0] = args;
6568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 result = (int)((wxRect const *)arg1)->GetHeight();
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj = 0;
6586 wxRect *arg1 = (wxRect *) 0 ;
6587 int arg2 ;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 int val2 ;
6591 int ecode2 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 char * kwnames[] = {
6595 (char *) "self",(char *) "h", NULL
6596 };
6597
6598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 ecode2 = SWIG_AsVal_int(obj1, &val2);
6605 if (!SWIG_IsOK(ecode2)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6607 }
6608 arg2 = static_cast< int >(val2);
6609 {
6610 (arg1)->SetHeight(arg2);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_Py_Void();
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6621 PyObject *resultobj = 0;
6622 wxRect *arg1 = (wxRect *) 0 ;
6623 wxPoint result;
6624 void *argp1 = 0 ;
6625 int res1 = 0 ;
6626 PyObject *swig_obj[1] ;
6627
6628 if (!args) SWIG_fail;
6629 swig_obj[0] = args;
6630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6631 if (!SWIG_IsOK(res1)) {
6632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6633 }
6634 arg1 = reinterpret_cast< wxRect * >(argp1);
6635 {
6636 result = ((wxRect const *)arg1)->GetPosition();
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj = 0;
6648 wxRect *arg1 = (wxRect *) 0 ;
6649 wxPoint *arg2 = 0 ;
6650 void *argp1 = 0 ;
6651 int res1 = 0 ;
6652 wxPoint temp2 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 char * kwnames[] = {
6656 (char *) "self",(char *) "p", NULL
6657 };
6658
6659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6661 if (!SWIG_IsOK(res1)) {
6662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6663 }
6664 arg1 = reinterpret_cast< wxRect * >(argp1);
6665 {
6666 arg2 = &temp2;
6667 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6668 }
6669 {
6670 (arg1)->SetPosition((wxPoint const &)*arg2);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 resultobj = SWIG_Py_Void();
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxRect *arg1 = (wxRect *) 0 ;
6683 wxSize result;
6684 void *argp1 = 0 ;
6685 int res1 = 0 ;
6686 PyObject *swig_obj[1] ;
6687
6688 if (!args) SWIG_fail;
6689 swig_obj[0] = args;
6690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6691 if (!SWIG_IsOK(res1)) {
6692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6693 }
6694 arg1 = reinterpret_cast< wxRect * >(argp1);
6695 {
6696 result = ((wxRect const *)arg1)->GetSize();
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj = 0;
6708 wxRect *arg1 = (wxRect *) 0 ;
6709 wxSize *arg2 = 0 ;
6710 void *argp1 = 0 ;
6711 int res1 = 0 ;
6712 wxSize temp2 ;
6713 PyObject * obj0 = 0 ;
6714 PyObject * obj1 = 0 ;
6715 char * kwnames[] = {
6716 (char *) "self",(char *) "s", NULL
6717 };
6718
6719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6721 if (!SWIG_IsOK(res1)) {
6722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6723 }
6724 arg1 = reinterpret_cast< wxRect * >(argp1);
6725 {
6726 arg2 = &temp2;
6727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6728 }
6729 {
6730 (arg1)->SetSize((wxSize const &)*arg2);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 resultobj = SWIG_Py_Void();
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6741 PyObject *resultobj = 0;
6742 wxRect *arg1 = (wxRect *) 0 ;
6743 bool result;
6744 void *argp1 = 0 ;
6745 int res1 = 0 ;
6746 PyObject *swig_obj[1] ;
6747
6748 if (!args) SWIG_fail;
6749 swig_obj[0] = args;
6750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6751 if (!SWIG_IsOK(res1)) {
6752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6753 }
6754 arg1 = reinterpret_cast< wxRect * >(argp1);
6755 {
6756 result = (bool)((wxRect const *)arg1)->IsEmpty();
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 {
6760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6761 }
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6769 PyObject *resultobj = 0;
6770 wxRect *arg1 = (wxRect *) 0 ;
6771 wxPoint result;
6772 void *argp1 = 0 ;
6773 int res1 = 0 ;
6774 PyObject *swig_obj[1] ;
6775
6776 if (!args) SWIG_fail;
6777 swig_obj[0] = args;
6778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6779 if (!SWIG_IsOK(res1)) {
6780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6781 }
6782 arg1 = reinterpret_cast< wxRect * >(argp1);
6783 {
6784 result = ((wxRect const *)arg1)->GetTopLeft();
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj = 0;
6796 wxRect *arg1 = (wxRect *) 0 ;
6797 wxPoint *arg2 = 0 ;
6798 void *argp1 = 0 ;
6799 int res1 = 0 ;
6800 wxPoint temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char * kwnames[] = {
6804 (char *) "self",(char *) "p", NULL
6805 };
6806
6807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6809 if (!SWIG_IsOK(res1)) {
6810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6811 }
6812 arg1 = reinterpret_cast< wxRect * >(argp1);
6813 {
6814 arg2 = &temp2;
6815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6816 }
6817 {
6818 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 wxPoint result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 result = ((wxRect const *)arg1)->GetBottomRight();
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj = 0;
6856 wxRect *arg1 = (wxRect *) 0 ;
6857 wxPoint *arg2 = 0 ;
6858 void *argp1 = 0 ;
6859 int res1 = 0 ;
6860 wxPoint temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char * kwnames[] = {
6864 (char *) "self",(char *) "p", NULL
6865 };
6866
6867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 {
6874 arg2 = &temp2;
6875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6876 }
6877 {
6878 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_Py_Void();
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6889 PyObject *resultobj = 0;
6890 wxRect *arg1 = (wxRect *) 0 ;
6891 wxPoint result;
6892 void *argp1 = 0 ;
6893 int res1 = 0 ;
6894 PyObject *swig_obj[1] ;
6895
6896 if (!args) SWIG_fail;
6897 swig_obj[0] = args;
6898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 {
6904 result = ((wxRect const *)arg1)->GetTopRight();
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj = 0;
6916 wxRect *arg1 = (wxRect *) 0 ;
6917 wxPoint *arg2 = 0 ;
6918 void *argp1 = 0 ;
6919 int res1 = 0 ;
6920 wxPoint temp2 ;
6921 PyObject * obj0 = 0 ;
6922 PyObject * obj1 = 0 ;
6923 char * kwnames[] = {
6924 (char *) "self",(char *) "p", NULL
6925 };
6926
6927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6929 if (!SWIG_IsOK(res1)) {
6930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6931 }
6932 arg1 = reinterpret_cast< wxRect * >(argp1);
6933 {
6934 arg2 = &temp2;
6935 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6936 }
6937 {
6938 (arg1)->SetTopRight((wxPoint const &)*arg2);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 resultobj = SWIG_Py_Void();
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6949 PyObject *resultobj = 0;
6950 wxRect *arg1 = (wxRect *) 0 ;
6951 wxPoint result;
6952 void *argp1 = 0 ;
6953 int res1 = 0 ;
6954 PyObject *swig_obj[1] ;
6955
6956 if (!args) SWIG_fail;
6957 swig_obj[0] = args;
6958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 {
6964 result = ((wxRect const *)arg1)->GetBottomLeft();
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxRect *arg1 = (wxRect *) 0 ;
6977 wxPoint *arg2 = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 wxPoint temp2 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char * kwnames[] = {
6984 (char *) "self",(char *) "p", NULL
6985 };
6986
6987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 {
6994 arg2 = &temp2;
6995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6996 }
6997 {
6998 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_Py_Void();
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 wxRect *arg1 = (wxRect *) 0 ;
7011 int result;
7012 void *argp1 = 0 ;
7013 int res1 = 0 ;
7014 PyObject *swig_obj[1] ;
7015
7016 if (!args) SWIG_fail;
7017 swig_obj[0] = args;
7018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7019 if (!SWIG_IsOK(res1)) {
7020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7021 }
7022 arg1 = reinterpret_cast< wxRect * >(argp1);
7023 {
7024 result = (int)((wxRect const *)arg1)->GetLeft();
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_From_int(static_cast< int >(result));
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int result;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 PyObject *swig_obj[1] ;
7041
7042 if (!args) SWIG_fail;
7043 swig_obj[0] = args;
7044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 {
7050 result = (int)((wxRect const *)arg1)->GetTop();
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_From_int(static_cast< int >(result));
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7061 PyObject *resultobj = 0;
7062 wxRect *arg1 = (wxRect *) 0 ;
7063 int result;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 PyObject *swig_obj[1] ;
7067
7068 if (!args) SWIG_fail;
7069 swig_obj[0] = args;
7070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7071 if (!SWIG_IsOK(res1)) {
7072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7073 }
7074 arg1 = reinterpret_cast< wxRect * >(argp1);
7075 {
7076 result = (int)((wxRect const *)arg1)->GetBottom();
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_From_int(static_cast< int >(result));
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7087 PyObject *resultobj = 0;
7088 wxRect *arg1 = (wxRect *) 0 ;
7089 int result;
7090 void *argp1 = 0 ;
7091 int res1 = 0 ;
7092 PyObject *swig_obj[1] ;
7093
7094 if (!args) SWIG_fail;
7095 swig_obj[0] = args;
7096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 {
7102 result = (int)((wxRect const *)arg1)->GetRight();
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_From_int(static_cast< int >(result));
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj = 0;
7114 wxRect *arg1 = (wxRect *) 0 ;
7115 int arg2 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 int val2 ;
7119 int ecode2 = 0 ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "self",(char *) "left", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7128 if (!SWIG_IsOK(res1)) {
7129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7130 }
7131 arg1 = reinterpret_cast< wxRect * >(argp1);
7132 ecode2 = SWIG_AsVal_int(obj1, &val2);
7133 if (!SWIG_IsOK(ecode2)) {
7134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7135 }
7136 arg2 = static_cast< int >(val2);
7137 {
7138 (arg1)->SetLeft(arg2);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_Py_Void();
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 int arg2 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 int val2 ;
7155 int ecode2 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "right", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 {
7174 (arg1)->SetRight(arg2);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_Py_Void();
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxRect *arg1 = (wxRect *) 0 ;
7187 int arg2 ;
7188 void *argp1 = 0 ;
7189 int res1 = 0 ;
7190 int val2 ;
7191 int ecode2 = 0 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "self",(char *) "top", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7202 }
7203 arg1 = reinterpret_cast< wxRect * >(argp1);
7204 ecode2 = SWIG_AsVal_int(obj1, &val2);
7205 if (!SWIG_IsOK(ecode2)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7207 }
7208 arg2 = static_cast< int >(val2);
7209 {
7210 (arg1)->SetTop(arg2);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_Py_Void();
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxRect *arg1 = (wxRect *) 0 ;
7223 int arg2 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 int val2 ;
7227 int ecode2 = 0 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "bottom", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 ecode2 = SWIG_AsVal_int(obj1, &val2);
7241 if (!SWIG_IsOK(ecode2)) {
7242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7243 }
7244 arg2 = static_cast< int >(val2);
7245 {
7246 (arg1)->SetBottom(arg2);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 resultobj = SWIG_Py_Void();
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxRect *arg1 = (wxRect *) 0 ;
7259 int arg2 ;
7260 int arg3 ;
7261 wxRect *result = 0 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 int val2 ;
7265 int ecode2 = 0 ;
7266 int val3 ;
7267 int ecode3 = 0 ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 PyObject * obj2 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "dx",(char *) "dy", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 ecode2 = SWIG_AsVal_int(obj1, &val2);
7282 if (!SWIG_IsOK(ecode2)) {
7283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7284 }
7285 arg2 = static_cast< int >(val2);
7286 ecode3 = SWIG_AsVal_int(obj2, &val3);
7287 if (!SWIG_IsOK(ecode3)) {
7288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7289 }
7290 arg3 = static_cast< int >(val3);
7291 {
7292 {
7293 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7294 result = (wxRect *) &_result_ref;
7295 }
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj = 0;
7307 wxRect *arg1 = (wxRect *) 0 ;
7308 int arg2 ;
7309 int arg3 ;
7310 wxRect *result = 0 ;
7311 void *argp1 = 0 ;
7312 int res1 = 0 ;
7313 int val2 ;
7314 int ecode2 = 0 ;
7315 int val3 ;
7316 int ecode3 = 0 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 PyObject * obj2 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "dx",(char *) "dy", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 ecode2 = SWIG_AsVal_int(obj1, &val2);
7331 if (!SWIG_IsOK(ecode2)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7333 }
7334 arg2 = static_cast< int >(val2);
7335 ecode3 = SWIG_AsVal_int(obj2, &val3);
7336 if (!SWIG_IsOK(ecode3)) {
7337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7338 }
7339 arg3 = static_cast< int >(val3);
7340 {
7341 {
7342 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7343 result = (wxRect *) &_result_ref;
7344 }
7345 if (PyErr_Occurred()) SWIG_fail;
7346 }
7347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7348 return resultobj;
7349 fail:
7350 return NULL;
7351 }
7352
7353
7354 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7355 PyObject *resultobj = 0;
7356 wxRect *arg1 = (wxRect *) 0 ;
7357 int arg2 ;
7358 int arg3 ;
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_OffsetXY",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_OffsetXY" "', 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_OffsetXY" "', 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_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7386 }
7387 arg3 = static_cast< int >(val3);
7388 {
7389 (arg1)->Offset(arg2,arg3);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_Py_Void();
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxRect *arg1 = (wxRect *) 0 ;
7402 wxPoint *arg2 = 0 ;
7403 void *argp1 = 0 ;
7404 int res1 = 0 ;
7405 wxPoint temp2 ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 char * kwnames[] = {
7409 (char *) "self",(char *) "pt", NULL
7410 };
7411
7412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7416 }
7417 arg1 = reinterpret_cast< wxRect * >(argp1);
7418 {
7419 arg2 = &temp2;
7420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7421 }
7422 {
7423 (arg1)->Offset((wxPoint const &)*arg2);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 resultobj = SWIG_Py_Void();
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj = 0;
7435 wxRect *arg1 = (wxRect *) 0 ;
7436 wxRect *arg2 = 0 ;
7437 wxRect result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 wxRect temp2 ;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 char * kwnames[] = {
7444 (char *) "self",(char *) "rect", NULL
7445 };
7446
7447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7449 if (!SWIG_IsOK(res1)) {
7450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7451 }
7452 arg1 = reinterpret_cast< wxRect * >(argp1);
7453 {
7454 arg2 = &temp2;
7455 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7456 }
7457 {
7458 result = (arg1)->Intersect((wxRect const &)*arg2);
7459 if (PyErr_Occurred()) SWIG_fail;
7460 }
7461 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7462 return resultobj;
7463 fail:
7464 return NULL;
7465 }
7466
7467
7468 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7469 PyObject *resultobj = 0;
7470 wxRect *arg1 = (wxRect *) 0 ;
7471 wxRect *arg2 = 0 ;
7472 wxRect result;
7473 void *argp1 = 0 ;
7474 int res1 = 0 ;
7475 wxRect temp2 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 char * kwnames[] = {
7479 (char *) "self",(char *) "rect", NULL
7480 };
7481
7482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7486 }
7487 arg1 = reinterpret_cast< wxRect * >(argp1);
7488 {
7489 arg2 = &temp2;
7490 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7491 }
7492 {
7493 result = (arg1)->Union((wxRect const &)*arg2);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj = 0;
7505 wxRect *arg1 = (wxRect *) 0 ;
7506 wxRect *arg2 = 0 ;
7507 wxRect result;
7508 void *argp1 = 0 ;
7509 int res1 = 0 ;
7510 wxRect temp2 ;
7511 PyObject * obj0 = 0 ;
7512 PyObject * obj1 = 0 ;
7513 char * kwnames[] = {
7514 (char *) "self",(char *) "rect", NULL
7515 };
7516
7517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7519 if (!SWIG_IsOK(res1)) {
7520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7521 }
7522 arg1 = reinterpret_cast< wxRect * >(argp1);
7523 {
7524 arg2 = &temp2;
7525 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7526 }
7527 {
7528 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj = 0;
7540 wxRect *arg1 = (wxRect *) 0 ;
7541 wxRect *arg2 = 0 ;
7542 wxRect *result = 0 ;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 wxRect temp2 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char * kwnames[] = {
7549 (char *) "self",(char *) "rect", NULL
7550 };
7551
7552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 {
7559 arg2 = &temp2;
7560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7561 }
7562 {
7563 {
7564 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7565 result = (wxRect *) &_result_ref;
7566 }
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7577 PyObject *resultobj = 0;
7578 wxRect *arg1 = (wxRect *) 0 ;
7579 PyObject *arg2 = (PyObject *) 0 ;
7580 bool result;
7581 void *argp1 = 0 ;
7582 int res1 = 0 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char * kwnames[] = {
7586 (char *) "self",(char *) "other", NULL
7587 };
7588
7589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7593 }
7594 arg1 = reinterpret_cast< wxRect * >(argp1);
7595 arg2 = obj1;
7596 {
7597 result = (bool)wxRect___eq__(arg1,arg2);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 {
7601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7602 }
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj = 0;
7611 wxRect *arg1 = (wxRect *) 0 ;
7612 PyObject *arg2 = (PyObject *) 0 ;
7613 bool result;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 PyObject * obj0 = 0 ;
7617 PyObject * obj1 = 0 ;
7618 char * kwnames[] = {
7619 (char *) "self",(char *) "other", NULL
7620 };
7621
7622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7624 if (!SWIG_IsOK(res1)) {
7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7626 }
7627 arg1 = reinterpret_cast< wxRect * >(argp1);
7628 arg2 = obj1;
7629 {
7630 result = (bool)wxRect___ne__(arg1,arg2);
7631 if (PyErr_Occurred()) SWIG_fail;
7632 }
7633 {
7634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7635 }
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = 0;
7644 wxRect *arg1 = (wxRect *) 0 ;
7645 int arg2 ;
7646 int arg3 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 int val2 ;
7651 int ecode2 = 0 ;
7652 int val3 ;
7653 int ecode3 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 PyObject * obj2 = 0 ;
7657 char * kwnames[] = {
7658 (char *) "self",(char *) "x",(char *) "y", NULL
7659 };
7660
7661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(obj1, &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 ecode3 = SWIG_AsVal_int(obj2, &val3);
7673 if (!SWIG_IsOK(ecode3)) {
7674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7675 }
7676 arg3 = static_cast< int >(val3);
7677 {
7678 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj = 0;
7692 wxRect *arg1 = (wxRect *) 0 ;
7693 wxPoint *arg2 = 0 ;
7694 bool result;
7695 void *argp1 = 0 ;
7696 int res1 = 0 ;
7697 wxPoint temp2 ;
7698 PyObject * obj0 = 0 ;
7699 PyObject * obj1 = 0 ;
7700 char * kwnames[] = {
7701 (char *) "self",(char *) "pt", NULL
7702 };
7703
7704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7706 if (!SWIG_IsOK(res1)) {
7707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7708 }
7709 arg1 = reinterpret_cast< wxRect * >(argp1);
7710 {
7711 arg2 = &temp2;
7712 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7713 }
7714 {
7715 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7716 if (PyErr_Occurred()) SWIG_fail;
7717 }
7718 {
7719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7720 }
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj = 0;
7729 wxRect *arg1 = (wxRect *) 0 ;
7730 wxRect *arg2 = 0 ;
7731 bool result;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 wxRect temp2 ;
7735 PyObject * obj0 = 0 ;
7736 PyObject * obj1 = 0 ;
7737 char * kwnames[] = {
7738 (char *) "self",(char *) "rect", NULL
7739 };
7740
7741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7743 if (!SWIG_IsOK(res1)) {
7744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7745 }
7746 arg1 = reinterpret_cast< wxRect * >(argp1);
7747 {
7748 arg2 = &temp2;
7749 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7750 }
7751 {
7752 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7753 if (PyErr_Occurred()) SWIG_fail;
7754 }
7755 {
7756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7757 }
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj = 0;
7766 wxRect *arg1 = (wxRect *) 0 ;
7767 wxRect *arg2 = 0 ;
7768 bool result;
7769 void *argp1 = 0 ;
7770 int res1 = 0 ;
7771 wxRect temp2 ;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 char * kwnames[] = {
7775 (char *) "self",(char *) "rect", NULL
7776 };
7777
7778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7780 if (!SWIG_IsOK(res1)) {
7781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7782 }
7783 arg1 = reinterpret_cast< wxRect * >(argp1);
7784 {
7785 arg2 = &temp2;
7786 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7787 }
7788 {
7789 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7790 if (PyErr_Occurred()) SWIG_fail;
7791 }
7792 {
7793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7794 }
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj = 0;
7803 wxRect *arg1 = (wxRect *) 0 ;
7804 wxRect *arg2 = 0 ;
7805 int arg3 = (int) wxBOTH ;
7806 wxRect result;
7807 void *argp1 = 0 ;
7808 int res1 = 0 ;
7809 wxRect temp2 ;
7810 int val3 ;
7811 int ecode3 = 0 ;
7812 PyObject * obj0 = 0 ;
7813 PyObject * obj1 = 0 ;
7814 PyObject * obj2 = 0 ;
7815 char * kwnames[] = {
7816 (char *) "self",(char *) "r",(char *) "dir", NULL
7817 };
7818
7819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 {
7826 arg2 = &temp2;
7827 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7828 }
7829 if (obj2) {
7830 ecode3 = SWIG_AsVal_int(obj2, &val3);
7831 if (!SWIG_IsOK(ecode3)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7833 }
7834 arg3 = static_cast< int >(val3);
7835 }
7836 {
7837 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 PyObject *resultobj = 0;
7849 wxRect *arg1 = (wxRect *) 0 ;
7850 int arg2 ;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 int val2 ;
7854 int ecode2 = 0 ;
7855 PyObject *swig_obj[2] ;
7856
7857 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7861 }
7862 arg1 = reinterpret_cast< wxRect * >(argp1);
7863 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7864 if (!SWIG_IsOK(ecode2)) {
7865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7866 }
7867 arg2 = static_cast< int >(val2);
7868 if (arg1) (arg1)->x = arg2;
7869
7870 resultobj = SWIG_Py_Void();
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxRect *arg1 = (wxRect *) 0 ;
7880 int result;
7881 void *argp1 = 0 ;
7882 int res1 = 0 ;
7883 PyObject *swig_obj[1] ;
7884
7885 if (!args) SWIG_fail;
7886 swig_obj[0] = args;
7887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7890 }
7891 arg1 = reinterpret_cast< wxRect * >(argp1);
7892 result = (int) ((arg1)->x);
7893 resultobj = SWIG_From_int(static_cast< int >(result));
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901 PyObject *resultobj = 0;
7902 wxRect *arg1 = (wxRect *) 0 ;
7903 int arg2 ;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 int val2 ;
7907 int ecode2 = 0 ;
7908 PyObject *swig_obj[2] ;
7909
7910 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7912 if (!SWIG_IsOK(res1)) {
7913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7914 }
7915 arg1 = reinterpret_cast< wxRect * >(argp1);
7916 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7917 if (!SWIG_IsOK(ecode2)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7919 }
7920 arg2 = static_cast< int >(val2);
7921 if (arg1) (arg1)->y = arg2;
7922
7923 resultobj = SWIG_Py_Void();
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 PyObject *resultobj = 0;
7932 wxRect *arg1 = (wxRect *) 0 ;
7933 int result;
7934 void *argp1 = 0 ;
7935 int res1 = 0 ;
7936 PyObject *swig_obj[1] ;
7937
7938 if (!args) SWIG_fail;
7939 swig_obj[0] = args;
7940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7941 if (!SWIG_IsOK(res1)) {
7942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7943 }
7944 arg1 = reinterpret_cast< wxRect * >(argp1);
7945 result = (int) ((arg1)->y);
7946 resultobj = SWIG_From_int(static_cast< int >(result));
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7954 PyObject *resultobj = 0;
7955 wxRect *arg1 = (wxRect *) 0 ;
7956 int arg2 ;
7957 void *argp1 = 0 ;
7958 int res1 = 0 ;
7959 int val2 ;
7960 int ecode2 = 0 ;
7961 PyObject *swig_obj[2] ;
7962
7963 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7967 }
7968 arg1 = reinterpret_cast< wxRect * >(argp1);
7969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7970 if (!SWIG_IsOK(ecode2)) {
7971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7972 }
7973 arg2 = static_cast< int >(val2);
7974 if (arg1) (arg1)->width = arg2;
7975
7976 resultobj = SWIG_Py_Void();
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7984 PyObject *resultobj = 0;
7985 wxRect *arg1 = (wxRect *) 0 ;
7986 int result;
7987 void *argp1 = 0 ;
7988 int res1 = 0 ;
7989 PyObject *swig_obj[1] ;
7990
7991 if (!args) SWIG_fail;
7992 swig_obj[0] = args;
7993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7996 }
7997 arg1 = reinterpret_cast< wxRect * >(argp1);
7998 result = (int) ((arg1)->width);
7999 resultobj = SWIG_From_int(static_cast< int >(result));
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *resultobj = 0;
8008 wxRect *arg1 = (wxRect *) 0 ;
8009 int arg2 ;
8010 void *argp1 = 0 ;
8011 int res1 = 0 ;
8012 int val2 ;
8013 int ecode2 = 0 ;
8014 PyObject *swig_obj[2] ;
8015
8016 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8018 if (!SWIG_IsOK(res1)) {
8019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8020 }
8021 arg1 = reinterpret_cast< wxRect * >(argp1);
8022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8023 if (!SWIG_IsOK(ecode2)) {
8024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8025 }
8026 arg2 = static_cast< int >(val2);
8027 if (arg1) (arg1)->height = arg2;
8028
8029 resultobj = SWIG_Py_Void();
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8037 PyObject *resultobj = 0;
8038 wxRect *arg1 = (wxRect *) 0 ;
8039 int result;
8040 void *argp1 = 0 ;
8041 int res1 = 0 ;
8042 PyObject *swig_obj[1] ;
8043
8044 if (!args) SWIG_fail;
8045 swig_obj[0] = args;
8046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8047 if (!SWIG_IsOK(res1)) {
8048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8049 }
8050 arg1 = reinterpret_cast< wxRect * >(argp1);
8051 result = (int) ((arg1)->height);
8052 resultobj = SWIG_From_int(static_cast< int >(result));
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj = 0;
8061 wxRect *arg1 = (wxRect *) 0 ;
8062 int arg2 = (int) 0 ;
8063 int arg3 = (int) 0 ;
8064 int arg4 = (int) 0 ;
8065 int arg5 = (int) 0 ;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int val2 ;
8069 int ecode2 = 0 ;
8070 int val3 ;
8071 int ecode3 = 0 ;
8072 int val4 ;
8073 int ecode4 = 0 ;
8074 int val5 ;
8075 int ecode5 = 0 ;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 PyObject * obj2 = 0 ;
8079 PyObject * obj3 = 0 ;
8080 PyObject * obj4 = 0 ;
8081 char * kwnames[] = {
8082 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8083 };
8084
8085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8087 if (!SWIG_IsOK(res1)) {
8088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8089 }
8090 arg1 = reinterpret_cast< wxRect * >(argp1);
8091 if (obj1) {
8092 ecode2 = SWIG_AsVal_int(obj1, &val2);
8093 if (!SWIG_IsOK(ecode2)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8095 }
8096 arg2 = static_cast< int >(val2);
8097 }
8098 if (obj2) {
8099 ecode3 = SWIG_AsVal_int(obj2, &val3);
8100 if (!SWIG_IsOK(ecode3)) {
8101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8102 }
8103 arg3 = static_cast< int >(val3);
8104 }
8105 if (obj3) {
8106 ecode4 = SWIG_AsVal_int(obj3, &val4);
8107 if (!SWIG_IsOK(ecode4)) {
8108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8109 }
8110 arg4 = static_cast< int >(val4);
8111 }
8112 if (obj4) {
8113 ecode5 = SWIG_AsVal_int(obj4, &val5);
8114 if (!SWIG_IsOK(ecode5)) {
8115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8116 }
8117 arg5 = static_cast< int >(val5);
8118 }
8119 {
8120 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8121 if (PyErr_Occurred()) SWIG_fail;
8122 }
8123 resultobj = SWIG_Py_Void();
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 PyObject *result = 0 ;
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_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8143 }
8144 arg1 = reinterpret_cast< wxRect * >(argp1);
8145 {
8146 result = (PyObject *)wxRect_Get(arg1);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = result;
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *obj;
8158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8159 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8160 return SWIG_Py_Void();
8161 }
8162
8163 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8164 return SWIG_Python_InitShadowInstance(args);
8165 }
8166
8167 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj = 0;
8169 wxRect *arg1 = (wxRect *) 0 ;
8170 wxRect *arg2 = (wxRect *) 0 ;
8171 PyObject *result = 0 ;
8172 void *argp1 = 0 ;
8173 int res1 = 0 ;
8174 void *argp2 = 0 ;
8175 int res2 = 0 ;
8176 PyObject * obj0 = 0 ;
8177 PyObject * obj1 = 0 ;
8178 char * kwnames[] = {
8179 (char *) "r1",(char *) "r2", NULL
8180 };
8181
8182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8184 if (!SWIG_IsOK(res1)) {
8185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8186 }
8187 arg1 = reinterpret_cast< wxRect * >(argp1);
8188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8189 if (!SWIG_IsOK(res2)) {
8190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8191 }
8192 arg2 = reinterpret_cast< wxRect * >(argp2);
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (PyObject *)wxIntersectRect(arg1,arg2);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = result;
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj = 0;
8209 double arg1 = (double) 0.0 ;
8210 double arg2 = (double) 0.0 ;
8211 wxPoint2D *result = 0 ;
8212 double val1 ;
8213 int ecode1 = 0 ;
8214 double val2 ;
8215 int ecode2 = 0 ;
8216 PyObject * obj0 = 0 ;
8217 PyObject * obj1 = 0 ;
8218 char * kwnames[] = {
8219 (char *) "x",(char *) "y", NULL
8220 };
8221
8222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8223 if (obj0) {
8224 ecode1 = SWIG_AsVal_double(obj0, &val1);
8225 if (!SWIG_IsOK(ecode1)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8227 }
8228 arg1 = static_cast< double >(val1);
8229 }
8230 if (obj1) {
8231 ecode2 = SWIG_AsVal_double(obj1, &val2);
8232 if (!SWIG_IsOK(ecode2)) {
8233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8234 }
8235 arg2 = static_cast< double >(val2);
8236 }
8237 {
8238 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = 0;
8250 wxPoint2D *arg1 = 0 ;
8251 wxPoint2D *result = 0 ;
8252 wxPoint2D temp1 ;
8253 PyObject * obj0 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "pt", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8259 {
8260 arg1 = &temp1;
8261 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8262 }
8263 {
8264 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxPoint *arg1 = 0 ;
8277 wxPoint2D *result = 0 ;
8278 wxPoint temp1 ;
8279 PyObject * obj0 = 0 ;
8280 char * kwnames[] = {
8281 (char *) "pt", NULL
8282 };
8283
8284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8285 {
8286 arg1 = &temp1;
8287 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8288 }
8289 {
8290 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 void *argp1 = 0 ;
8304 int res1 = 0 ;
8305 PyObject *swig_obj[1] ;
8306
8307 if (!args) SWIG_fail;
8308 swig_obj[0] = args;
8309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8310 if (!SWIG_IsOK(res1)) {
8311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8312 }
8313 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8314 {
8315 delete arg1;
8316
8317 if (PyErr_Occurred()) SWIG_fail;
8318 }
8319 resultobj = SWIG_Py_Void();
8320 return resultobj;
8321 fail:
8322 return NULL;
8323 }
8324
8325
8326 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8327 PyObject *resultobj = 0;
8328 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8329 int *arg2 = (int *) 0 ;
8330 int *arg3 = (int *) 0 ;
8331 void *argp1 = 0 ;
8332 int res1 = 0 ;
8333 int temp2 ;
8334 int res2 = SWIG_TMPOBJ ;
8335 int temp3 ;
8336 int res3 = SWIG_TMPOBJ ;
8337 PyObject *swig_obj[1] ;
8338
8339 arg2 = &temp2;
8340 arg3 = &temp3;
8341 if (!args) SWIG_fail;
8342 swig_obj[0] = args;
8343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 if (SWIG_IsTmpObj(res2)) {
8354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8355 } else {
8356 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8358 }
8359 if (SWIG_IsTmpObj(res3)) {
8360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8361 } else {
8362 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8364 }
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8374 int *arg2 = (int *) 0 ;
8375 int *arg3 = (int *) 0 ;
8376 void *argp1 = 0 ;
8377 int res1 = 0 ;
8378 int temp2 ;
8379 int res2 = SWIG_TMPOBJ ;
8380 int temp3 ;
8381 int res3 = SWIG_TMPOBJ ;
8382 PyObject *swig_obj[1] ;
8383
8384 arg2 = &temp2;
8385 arg3 = &temp3;
8386 if (!args) SWIG_fail;
8387 swig_obj[0] = args;
8388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8389 if (!SWIG_IsOK(res1)) {
8390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8391 }
8392 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8393 {
8394 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_Py_Void();
8398 if (SWIG_IsTmpObj(res2)) {
8399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8400 } else {
8401 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8403 }
8404 if (SWIG_IsTmpObj(res3)) {
8405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8406 } else {
8407 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8409 }
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8417 PyObject *resultobj = 0;
8418 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8419 double result;
8420 void *argp1 = 0 ;
8421 int res1 = 0 ;
8422 PyObject *swig_obj[1] ;
8423
8424 if (!args) SWIG_fail;
8425 swig_obj[0] = args;
8426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8427 if (!SWIG_IsOK(res1)) {
8428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8429 }
8430 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8431 {
8432 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 resultobj = SWIG_From_double(static_cast< double >(result));
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8445 double result;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 PyObject *swig_obj[1] ;
8449
8450 if (!args) SWIG_fail;
8451 swig_obj[0] = args;
8452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8453 if (!SWIG_IsOK(res1)) {
8454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8455 }
8456 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8457 {
8458 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_From_double(static_cast< double >(result));
8462 return resultobj;
8463 fail:
8464 return NULL;
8465 }
8466
8467
8468 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8469 PyObject *resultobj = 0;
8470 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8471 double arg2 ;
8472 void *argp1 = 0 ;
8473 int res1 = 0 ;
8474 double val2 ;
8475 int ecode2 = 0 ;
8476 PyObject * obj0 = 0 ;
8477 PyObject * obj1 = 0 ;
8478 char * kwnames[] = {
8479 (char *) "self",(char *) "length", NULL
8480 };
8481
8482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8486 }
8487 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8488 ecode2 = SWIG_AsVal_double(obj1, &val2);
8489 if (!SWIG_IsOK(ecode2)) {
8490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8491 }
8492 arg2 = static_cast< double >(val2);
8493 {
8494 (arg1)->SetVectorLength(arg2);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 resultobj = SWIG_Py_Void();
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj = 0;
8506 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8507 double arg2 ;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 double val2 ;
8511 int ecode2 = 0 ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char * kwnames[] = {
8515 (char *) "self",(char *) "degrees", NULL
8516 };
8517
8518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8520 if (!SWIG_IsOK(res1)) {
8521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8522 }
8523 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8524 ecode2 = SWIG_AsVal_double(obj1, &val2);
8525 if (!SWIG_IsOK(ecode2)) {
8526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8527 }
8528 arg2 = static_cast< double >(val2);
8529 {
8530 (arg1)->SetVectorAngle(arg2);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 resultobj = SWIG_Py_Void();
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj = 0;
8542 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8543 wxPoint2D *arg2 = 0 ;
8544 double result;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 wxPoint2D temp2 ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char * kwnames[] = {
8551 (char *) "self",(char *) "pt", NULL
8552 };
8553
8554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 arg2 = &temp2;
8562 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8563 }
8564 {
8565 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_From_double(static_cast< double >(result));
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 double result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_From_double(static_cast< double >(result));
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj = 0;
8612 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8613 wxPoint2D *arg2 = 0 ;
8614 double result;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 wxPoint2D temp2 ;
8618 PyObject * obj0 = 0 ;
8619 PyObject * obj1 = 0 ;
8620 char * kwnames[] = {
8621 (char *) "self",(char *) "vec", NULL
8622 };
8623
8624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8626 if (!SWIG_IsOK(res1)) {
8627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8628 }
8629 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8630 {
8631 arg2 = &temp2;
8632 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8633 }
8634 {
8635 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_From_double(static_cast< double >(result));
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj = 0;
8647 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8648 wxPoint2D *arg2 = 0 ;
8649 double result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 wxPoint2D temp2 ;
8653 PyObject * obj0 = 0 ;
8654 PyObject * obj1 = 0 ;
8655 char * kwnames[] = {
8656 (char *) "self",(char *) "vec", NULL
8657 };
8658
8659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8661 if (!SWIG_IsOK(res1)) {
8662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8663 }
8664 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8665 {
8666 arg2 = &temp2;
8667 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8668 }
8669 {
8670 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 resultobj = SWIG_From_double(static_cast< double >(result));
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8681 PyObject *resultobj = 0;
8682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8683 wxPoint2D result;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 PyObject *swig_obj[1] ;
8687
8688 if (!args) SWIG_fail;
8689 swig_obj[0] = args;
8690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8693 }
8694 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8695 {
8696 result = (arg1)->operator -();
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8707 PyObject *resultobj = 0;
8708 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8709 wxPoint2D *arg2 = 0 ;
8710 wxPoint2D *result = 0 ;
8711 void *argp1 = 0 ;
8712 int res1 = 0 ;
8713 wxPoint2D temp2 ;
8714 PyObject * obj0 = 0 ;
8715 PyObject * obj1 = 0 ;
8716 char * kwnames[] = {
8717 (char *) "self",(char *) "pt", NULL
8718 };
8719
8720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8722 if (!SWIG_IsOK(res1)) {
8723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8724 }
8725 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8726 {
8727 arg2 = &temp2;
8728 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8729 }
8730 {
8731 {
8732 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8733 result = (wxPoint2D *) &_result_ref;
8734 }
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj = 0;
8746 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8747 wxPoint2D *arg2 = 0 ;
8748 wxPoint2D *result = 0 ;
8749 void *argp1 = 0 ;
8750 int res1 = 0 ;
8751 wxPoint2D temp2 ;
8752 PyObject * obj0 = 0 ;
8753 PyObject * obj1 = 0 ;
8754 char * kwnames[] = {
8755 (char *) "self",(char *) "pt", NULL
8756 };
8757
8758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8760 if (!SWIG_IsOK(res1)) {
8761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8762 }
8763 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8764 {
8765 arg2 = &temp2;
8766 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8767 }
8768 {
8769 {
8770 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8771 result = (wxPoint2D *) &_result_ref;
8772 }
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D *arg2 = 0 ;
8786 wxPoint2D *result = 0 ;
8787 void *argp1 = 0 ;
8788 int res1 = 0 ;
8789 wxPoint2D temp2 ;
8790 PyObject * obj0 = 0 ;
8791 PyObject * obj1 = 0 ;
8792 char * kwnames[] = {
8793 (char *) "self",(char *) "pt", NULL
8794 };
8795
8796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8798 if (!SWIG_IsOK(res1)) {
8799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8800 }
8801 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8802 {
8803 arg2 = &temp2;
8804 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8805 }
8806 {
8807 {
8808 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8809 result = (wxPoint2D *) &_result_ref;
8810 }
8811 if (PyErr_Occurred()) SWIG_fail;
8812 }
8813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8814 return resultobj;
8815 fail:
8816 return NULL;
8817 }
8818
8819
8820 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8821 PyObject *resultobj = 0;
8822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8823 wxPoint2D *arg2 = 0 ;
8824 wxPoint2D *result = 0 ;
8825 void *argp1 = 0 ;
8826 int res1 = 0 ;
8827 wxPoint2D temp2 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 char * kwnames[] = {
8831 (char *) "self",(char *) "pt", NULL
8832 };
8833
8834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 {
8841 arg2 = &temp2;
8842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8843 }
8844 {
8845 {
8846 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8847 result = (wxPoint2D *) &_result_ref;
8848 }
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj = 0;
8860 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8861 PyObject *arg2 = (PyObject *) 0 ;
8862 bool result;
8863 void *argp1 = 0 ;
8864 int res1 = 0 ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 char * kwnames[] = {
8868 (char *) "self",(char *) "other", NULL
8869 };
8870
8871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8873 if (!SWIG_IsOK(res1)) {
8874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8875 }
8876 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8877 arg2 = obj1;
8878 {
8879 result = (bool)wxPoint2D___eq__(arg1,arg2);
8880 if (PyErr_Occurred()) SWIG_fail;
8881 }
8882 {
8883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8884 }
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 PyObject *arg2 = (PyObject *) 0 ;
8895 bool result;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 PyObject * obj0 = 0 ;
8899 PyObject * obj1 = 0 ;
8900 char * kwnames[] = {
8901 (char *) "self",(char *) "other", NULL
8902 };
8903
8904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8906 if (!SWIG_IsOK(res1)) {
8907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8908 }
8909 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8910 arg2 = obj1;
8911 {
8912 result = (bool)wxPoint2D___ne__(arg1,arg2);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 {
8916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8925 PyObject *resultobj = 0;
8926 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8927 double arg2 ;
8928 void *argp1 = 0 ;
8929 int res1 = 0 ;
8930 double val2 ;
8931 int ecode2 = 0 ;
8932 PyObject *swig_obj[2] ;
8933
8934 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8938 }
8939 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8940 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8941 if (!SWIG_IsOK(ecode2)) {
8942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8943 }
8944 arg2 = static_cast< double >(val2);
8945 if (arg1) (arg1)->m_x = arg2;
8946
8947 resultobj = SWIG_Py_Void();
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8955 PyObject *resultobj = 0;
8956 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8957 double result;
8958 void *argp1 = 0 ;
8959 int res1 = 0 ;
8960 PyObject *swig_obj[1] ;
8961
8962 if (!args) SWIG_fail;
8963 swig_obj[0] = args;
8964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8965 if (!SWIG_IsOK(res1)) {
8966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8967 }
8968 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8969 result = (double) ((arg1)->m_x);
8970 resultobj = SWIG_From_double(static_cast< double >(result));
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 PyObject *resultobj = 0;
8979 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8980 double arg2 ;
8981 void *argp1 = 0 ;
8982 int res1 = 0 ;
8983 double val2 ;
8984 int ecode2 = 0 ;
8985 PyObject *swig_obj[2] ;
8986
8987 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8989 if (!SWIG_IsOK(res1)) {
8990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8991 }
8992 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8993 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8994 if (!SWIG_IsOK(ecode2)) {
8995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8996 }
8997 arg2 = static_cast< double >(val2);
8998 if (arg1) (arg1)->m_y = arg2;
8999
9000 resultobj = SWIG_Py_Void();
9001 return resultobj;
9002 fail:
9003 return NULL;
9004 }
9005
9006
9007 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9008 PyObject *resultobj = 0;
9009 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9010 double result;
9011 void *argp1 = 0 ;
9012 int res1 = 0 ;
9013 PyObject *swig_obj[1] ;
9014
9015 if (!args) SWIG_fail;
9016 swig_obj[0] = args;
9017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 result = (double) ((arg1)->m_y);
9023 resultobj = SWIG_From_double(static_cast< double >(result));
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9031 PyObject *resultobj = 0;
9032 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9033 double arg2 = (double) 0 ;
9034 double arg3 = (double) 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 double val2 ;
9038 int ecode2 = 0 ;
9039 double val3 ;
9040 int ecode3 = 0 ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 PyObject * obj2 = 0 ;
9044 char * kwnames[] = {
9045 (char *) "self",(char *) "x",(char *) "y", NULL
9046 };
9047
9048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9050 if (!SWIG_IsOK(res1)) {
9051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9052 }
9053 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9054 if (obj1) {
9055 ecode2 = SWIG_AsVal_double(obj1, &val2);
9056 if (!SWIG_IsOK(ecode2)) {
9057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9058 }
9059 arg2 = static_cast< double >(val2);
9060 }
9061 if (obj2) {
9062 ecode3 = SWIG_AsVal_double(obj2, &val3);
9063 if (!SWIG_IsOK(ecode3)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9065 }
9066 arg3 = static_cast< double >(val3);
9067 }
9068 {
9069 wxPoint2D_Set(arg1,arg2,arg3);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_Py_Void();
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9080 PyObject *resultobj = 0;
9081 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9082 PyObject *result = 0 ;
9083 void *argp1 = 0 ;
9084 int res1 = 0 ;
9085 PyObject *swig_obj[1] ;
9086
9087 if (!args) SWIG_fail;
9088 swig_obj[0] = args;
9089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9092 }
9093 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9094 {
9095 result = (PyObject *)wxPoint2D_Get(arg1);
9096 if (PyErr_Occurred()) SWIG_fail;
9097 }
9098 resultobj = result;
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *obj;
9107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9108 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9109 return SWIG_Py_Void();
9110 }
9111
9112 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9113 return SWIG_Python_InitShadowInstance(args);
9114 }
9115
9116 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxDouble arg1 = (wxDouble) 0.0 ;
9119 wxDouble arg2 = (wxDouble) 0.0 ;
9120 wxDouble arg3 = (wxDouble) 0.0 ;
9121 wxDouble arg4 = (wxDouble) 0.0 ;
9122 wxRect2D *result = 0 ;
9123 void *argp1 ;
9124 int res1 = 0 ;
9125 void *argp2 ;
9126 int res2 = 0 ;
9127 void *argp3 ;
9128 int res3 = 0 ;
9129 void *argp4 ;
9130 int res4 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 PyObject * obj2 = 0 ;
9134 PyObject * obj3 = 0 ;
9135 char * kwnames[] = {
9136 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9137 };
9138
9139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9140 if (obj0) {
9141 {
9142 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9145 }
9146 if (!argp1) {
9147 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9148 } else {
9149 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9150 arg1 = *temp;
9151 if (SWIG_IsNewObj(res1)) delete temp;
9152 }
9153 }
9154 }
9155 if (obj1) {
9156 {
9157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9158 if (!SWIG_IsOK(res2)) {
9159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9160 }
9161 if (!argp2) {
9162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9163 } else {
9164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9165 arg2 = *temp;
9166 if (SWIG_IsNewObj(res2)) delete temp;
9167 }
9168 }
9169 }
9170 if (obj2) {
9171 {
9172 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9173 if (!SWIG_IsOK(res3)) {
9174 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9175 }
9176 if (!argp3) {
9177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9178 } else {
9179 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9180 arg3 = *temp;
9181 if (SWIG_IsNewObj(res3)) delete temp;
9182 }
9183 }
9184 }
9185 if (obj3) {
9186 {
9187 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9188 if (!SWIG_IsOK(res4)) {
9189 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9190 }
9191 if (!argp4) {
9192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9193 } else {
9194 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9195 arg4 = *temp;
9196 if (SWIG_IsNewObj(res4)) delete temp;
9197 }
9198 }
9199 }
9200 {
9201 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9212 PyObject *resultobj = 0;
9213 wxRect2D *arg1 = (wxRect2D *) 0 ;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 PyObject *swig_obj[1] ;
9217
9218 if (!args) SWIG_fail;
9219 swig_obj[0] = args;
9220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9221 if (!SWIG_IsOK(res1)) {
9222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9223 }
9224 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9225 {
9226 delete arg1;
9227
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_Py_Void();
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *resultobj = 0;
9239 wxRect2D *arg1 = (wxRect2D *) 0 ;
9240 wxPoint2D result;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9250 }
9251 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9252 {
9253 result = (arg1)->GetPosition();
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9257 return resultobj;
9258 fail:
9259 return NULL;
9260 }
9261
9262
9263 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9264 PyObject *resultobj = 0;
9265 wxRect2D *arg1 = (wxRect2D *) 0 ;
9266 wxSize result;
9267 void *argp1 = 0 ;
9268 int res1 = 0 ;
9269 PyObject *swig_obj[1] ;
9270
9271 if (!args) SWIG_fail;
9272 swig_obj[0] = args;
9273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9274 if (!SWIG_IsOK(res1)) {
9275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9276 }
9277 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9278 {
9279 result = (arg1)->GetSize();
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9290 PyObject *resultobj = 0;
9291 wxRect2D *arg1 = (wxRect2D *) 0 ;
9292 wxDouble result;
9293 void *argp1 = 0 ;
9294 int res1 = 0 ;
9295 PyObject *swig_obj[1] ;
9296
9297 if (!args) SWIG_fail;
9298 swig_obj[0] = args;
9299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9300 if (!SWIG_IsOK(res1)) {
9301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9302 }
9303 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9304 {
9305 result = ((wxRect2D const *)arg1)->GetLeft();
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj = 0;
9317 wxRect2D *arg1 = (wxRect2D *) 0 ;
9318 wxDouble arg2 ;
9319 void *argp1 = 0 ;
9320 int res1 = 0 ;
9321 void *argp2 ;
9322 int res2 = 0 ;
9323 PyObject * obj0 = 0 ;
9324 PyObject * obj1 = 0 ;
9325 char * kwnames[] = {
9326 (char *) "self",(char *) "n", NULL
9327 };
9328
9329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9333 }
9334 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9335 {
9336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9337 if (!SWIG_IsOK(res2)) {
9338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9339 }
9340 if (!argp2) {
9341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9342 } else {
9343 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9344 arg2 = *temp;
9345 if (SWIG_IsNewObj(res2)) delete temp;
9346 }
9347 }
9348 {
9349 (arg1)->SetLeft(arg2);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_Py_Void();
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = 0;
9361 wxRect2D *arg1 = (wxRect2D *) 0 ;
9362 wxDouble arg2 ;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 void *argp2 ;
9366 int res2 = 0 ;
9367 PyObject * obj0 = 0 ;
9368 PyObject * obj1 = 0 ;
9369 char * kwnames[] = {
9370 (char *) "self",(char *) "n", NULL
9371 };
9372
9373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9375 if (!SWIG_IsOK(res1)) {
9376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9377 }
9378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9379 {
9380 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9381 if (!SWIG_IsOK(res2)) {
9382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9383 }
9384 if (!argp2) {
9385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9386 } else {
9387 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9388 arg2 = *temp;
9389 if (SWIG_IsNewObj(res2)) delete temp;
9390 }
9391 }
9392 {
9393 (arg1)->MoveLeftTo(arg2);
9394 if (PyErr_Occurred()) SWIG_fail;
9395 }
9396 resultobj = SWIG_Py_Void();
9397 return resultobj;
9398 fail:
9399 return NULL;
9400 }
9401
9402
9403 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9404 PyObject *resultobj = 0;
9405 wxRect2D *arg1 = (wxRect2D *) 0 ;
9406 wxDouble result;
9407 void *argp1 = 0 ;
9408 int res1 = 0 ;
9409 PyObject *swig_obj[1] ;
9410
9411 if (!args) SWIG_fail;
9412 swig_obj[0] = args;
9413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9414 if (!SWIG_IsOK(res1)) {
9415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9416 }
9417 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9418 {
9419 result = ((wxRect2D const *)arg1)->GetTop();
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 wxRect2D *arg1 = (wxRect2D *) 0 ;
9432 wxDouble arg2 ;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 void *argp2 ;
9436 int res2 = 0 ;
9437 PyObject * obj0 = 0 ;
9438 PyObject * obj1 = 0 ;
9439 char * kwnames[] = {
9440 (char *) "self",(char *) "n", NULL
9441 };
9442
9443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9445 if (!SWIG_IsOK(res1)) {
9446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9447 }
9448 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9449 {
9450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9451 if (!SWIG_IsOK(res2)) {
9452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9453 }
9454 if (!argp2) {
9455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9456 } else {
9457 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9458 arg2 = *temp;
9459 if (SWIG_IsNewObj(res2)) delete temp;
9460 }
9461 }
9462 {
9463 (arg1)->SetTop(arg2);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_Py_Void();
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj = 0;
9475 wxRect2D *arg1 = (wxRect2D *) 0 ;
9476 wxDouble arg2 ;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 void *argp2 ;
9480 int res2 = 0 ;
9481 PyObject * obj0 = 0 ;
9482 PyObject * obj1 = 0 ;
9483 char * kwnames[] = {
9484 (char *) "self",(char *) "n", NULL
9485 };
9486
9487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9491 }
9492 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9493 {
9494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9495 if (!SWIG_IsOK(res2)) {
9496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9497 }
9498 if (!argp2) {
9499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9500 } else {
9501 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9502 arg2 = *temp;
9503 if (SWIG_IsNewObj(res2)) delete temp;
9504 }
9505 }
9506 {
9507 (arg1)->MoveTopTo(arg2);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_Py_Void();
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9518 PyObject *resultobj = 0;
9519 wxRect2D *arg1 = (wxRect2D *) 0 ;
9520 wxDouble result;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 PyObject *swig_obj[1] ;
9524
9525 if (!args) SWIG_fail;
9526 swig_obj[0] = args;
9527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9528 if (!SWIG_IsOK(res1)) {
9529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9530 }
9531 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9532 {
9533 result = ((wxRect2D const *)arg1)->GetBottom();
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj = 0;
9545 wxRect2D *arg1 = (wxRect2D *) 0 ;
9546 wxDouble arg2 ;
9547 void *argp1 = 0 ;
9548 int res1 = 0 ;
9549 void *argp2 ;
9550 int res2 = 0 ;
9551 PyObject * obj0 = 0 ;
9552 PyObject * obj1 = 0 ;
9553 char * kwnames[] = {
9554 (char *) "self",(char *) "n", NULL
9555 };
9556
9557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9561 }
9562 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9563 {
9564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9565 if (!SWIG_IsOK(res2)) {
9566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9567 }
9568 if (!argp2) {
9569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9570 } else {
9571 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9572 arg2 = *temp;
9573 if (SWIG_IsNewObj(res2)) delete temp;
9574 }
9575 }
9576 {
9577 (arg1)->SetBottom(arg2);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_Py_Void();
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxRect2D *arg1 = (wxRect2D *) 0 ;
9590 wxDouble arg2 ;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 void *argp2 ;
9594 int res2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "n", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9605 }
9606 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9607 {
9608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9609 if (!SWIG_IsOK(res2)) {
9610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9611 }
9612 if (!argp2) {
9613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9614 } else {
9615 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9616 arg2 = *temp;
9617 if (SWIG_IsNewObj(res2)) delete temp;
9618 }
9619 }
9620 {
9621 (arg1)->MoveBottomTo(arg2);
9622 if (PyErr_Occurred()) SWIG_fail;
9623 }
9624 resultobj = SWIG_Py_Void();
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxRect2D *arg1 = (wxRect2D *) 0 ;
9634 wxDouble result;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject *swig_obj[1] ;
9638
9639 if (!args) SWIG_fail;
9640 swig_obj[0] = args;
9641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9644 }
9645 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9646 {
9647 result = ((wxRect2D const *)arg1)->GetRight();
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj = 0;
9659 wxRect2D *arg1 = (wxRect2D *) 0 ;
9660 wxDouble arg2 ;
9661 void *argp1 = 0 ;
9662 int res1 = 0 ;
9663 void *argp2 ;
9664 int res2 = 0 ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 char * kwnames[] = {
9668 (char *) "self",(char *) "n", NULL
9669 };
9670
9671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9673 if (!SWIG_IsOK(res1)) {
9674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9675 }
9676 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9677 {
9678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9679 if (!SWIG_IsOK(res2)) {
9680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9681 }
9682 if (!argp2) {
9683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9684 } else {
9685 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9686 arg2 = *temp;
9687 if (SWIG_IsNewObj(res2)) delete temp;
9688 }
9689 }
9690 {
9691 (arg1)->SetRight(arg2);
9692 if (PyErr_Occurred()) SWIG_fail;
9693 }
9694 resultobj = SWIG_Py_Void();
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxRect2D *arg1 = (wxRect2D *) 0 ;
9704 wxDouble arg2 ;
9705 void *argp1 = 0 ;
9706 int res1 = 0 ;
9707 void *argp2 ;
9708 int res2 = 0 ;
9709 PyObject * obj0 = 0 ;
9710 PyObject * obj1 = 0 ;
9711 char * kwnames[] = {
9712 (char *) "self",(char *) "n", NULL
9713 };
9714
9715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9717 if (!SWIG_IsOK(res1)) {
9718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9719 }
9720 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9721 {
9722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9723 if (!SWIG_IsOK(res2)) {
9724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9725 }
9726 if (!argp2) {
9727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9728 } else {
9729 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9730 arg2 = *temp;
9731 if (SWIG_IsNewObj(res2)) delete temp;
9732 }
9733 }
9734 {
9735 (arg1)->MoveRightTo(arg2);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxRect2D *arg1 = (wxRect2D *) 0 ;
9748 wxPoint2D result;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 PyObject *swig_obj[1] ;
9752
9753 if (!args) SWIG_fail;
9754 swig_obj[0] = args;
9755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9758 }
9759 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9760 {
9761 result = ((wxRect2D const *)arg1)->GetLeftTop();
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj = 0;
9773 wxRect2D *arg1 = (wxRect2D *) 0 ;
9774 wxPoint2D *arg2 = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 wxPoint2D temp2 ;
9778 PyObject * obj0 = 0 ;
9779 PyObject * obj1 = 0 ;
9780 char * kwnames[] = {
9781 (char *) "self",(char *) "pt", NULL
9782 };
9783
9784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9786 if (!SWIG_IsOK(res1)) {
9787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9788 }
9789 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9790 {
9791 arg2 = &temp2;
9792 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9793 }
9794 {
9795 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_Py_Void();
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9806 PyObject *resultobj = 0;
9807 wxRect2D *arg1 = (wxRect2D *) 0 ;
9808 wxPoint2D *arg2 = 0 ;
9809 void *argp1 = 0 ;
9810 int res1 = 0 ;
9811 wxPoint2D temp2 ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char * kwnames[] = {
9815 (char *) "self",(char *) "pt", NULL
9816 };
9817
9818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9820 if (!SWIG_IsOK(res1)) {
9821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9822 }
9823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9824 {
9825 arg2 = &temp2;
9826 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9827 }
9828 {
9829 (arg1)->MoveLeftTopTo((wxPoint2D const &)*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_GetLeftBottom(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_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9852 }
9853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9854 {
9855 result = ((wxRect2D const *)arg1)->GetLeftBottom();
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_SetLeftBottom(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_SetLeftBottom",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_SetLeftBottom" "', 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)->SetLeftBottom((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_MoveLeftBottomTo(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_MoveLeftBottomTo",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_MoveLeftBottomTo" "', 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)->MoveLeftBottomTo((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_GetRightTop(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_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9946 }
9947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9948 {
9949 result = ((wxRect2D const *)arg1)->GetRightTop();
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_SetRightTop(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_SetRightTop",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_SetRightTop" "', 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)->SetRightTop((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_MoveRightTopTo(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_MoveRightTopTo",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_MoveRightTopTo" "', 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)->MoveRightTopTo((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_GetRightBottom(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_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10040 }
10041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10042 {
10043 result = ((wxRect2D const *)arg1)->GetRightBottom();
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_SetRightBottom(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_SetRightBottom",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_SetRightBottom" "', 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)->SetRightBottom((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_MoveRightBottomTo(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_MoveRightBottomTo",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_MoveRightBottomTo" "', 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)->MoveRightBottomTo((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_GetCentre(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_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10134 }
10135 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10136 {
10137 result = ((wxRect2D const *)arg1)->GetCentre();
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_SetCentre(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_SetCentre",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_SetCentre" "', 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)->SetCentre((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_MoveCentreTo(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_MoveCentreTo",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_MoveCentreTo" "', 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)->MoveCentreTo((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_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10216 PyObject *resultobj = 0;
10217 wxRect2D *arg1 = (wxRect2D *) 0 ;
10218 wxPoint2D *arg2 = 0 ;
10219 wxOutCode result;
10220 void *argp1 = 0 ;
10221 int res1 = 0 ;
10222 wxPoint2D temp2 ;
10223 PyObject * obj0 = 0 ;
10224 PyObject * obj1 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "pt", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10233 }
10234 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10235 {
10236 arg2 = &temp2;
10237 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10238 }
10239 {
10240 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_From_int(static_cast< int >(result));
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxRect2D *arg1 = (wxRect2D *) 0 ;
10253 wxPoint2D *arg2 = 0 ;
10254 bool result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 wxPoint2D temp2 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "pt", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10268 }
10269 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10270 {
10271 arg2 = &temp2;
10272 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10273 }
10274 {
10275 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 {
10279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10280 }
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10288 PyObject *resultobj = 0;
10289 wxRect2D *arg1 = (wxRect2D *) 0 ;
10290 wxRect2D *arg2 = 0 ;
10291 bool result;
10292 void *argp1 = 0 ;
10293 int res1 = 0 ;
10294 wxRect2D temp2 ;
10295 PyObject * obj0 = 0 ;
10296 PyObject * obj1 = 0 ;
10297 char * kwnames[] = {
10298 (char *) "self",(char *) "rect", NULL
10299 };
10300
10301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10305 }
10306 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10307 {
10308 arg2 = &temp2;
10309 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10310 }
10311 {
10312 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 {
10316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10317 }
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10325 PyObject *resultobj = 0;
10326 wxRect2D *arg1 = (wxRect2D *) 0 ;
10327 bool result;
10328 void *argp1 = 0 ;
10329 int res1 = 0 ;
10330 PyObject *swig_obj[1] ;
10331
10332 if (!args) SWIG_fail;
10333 swig_obj[0] = args;
10334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10337 }
10338 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10339 {
10340 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 {
10344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10345 }
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj = 0;
10354 wxRect2D *arg1 = (wxRect2D *) 0 ;
10355 wxRect2D *arg2 = 0 ;
10356 bool result;
10357 void *argp1 = 0 ;
10358 int res1 = 0 ;
10359 wxRect2D temp2 ;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char * kwnames[] = {
10363 (char *) "self",(char *) "rect", NULL
10364 };
10365
10366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10368 if (!SWIG_IsOK(res1)) {
10369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10370 }
10371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10372 {
10373 arg2 = &temp2;
10374 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10375 }
10376 {
10377 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10390 PyObject *resultobj = 0;
10391 wxRect2D *arg1 = (wxRect2D *) 0 ;
10392 wxDouble arg2 ;
10393 wxDouble arg3 ;
10394 void *argp1 = 0 ;
10395 int res1 = 0 ;
10396 void *argp2 ;
10397 int res2 = 0 ;
10398 void *argp3 ;
10399 int res3 = 0 ;
10400
10401 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10405 }
10406 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10407 {
10408 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10409 if (!SWIG_IsOK(res2)) {
10410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10411 }
10412 if (!argp2) {
10413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10414 } else {
10415 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10416 arg2 = *temp;
10417 if (SWIG_IsNewObj(res2)) delete temp;
10418 }
10419 }
10420 {
10421 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10422 if (!SWIG_IsOK(res3)) {
10423 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10424 }
10425 if (!argp3) {
10426 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10427 } else {
10428 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10429 arg3 = *temp;
10430 if (SWIG_IsNewObj(res3)) delete temp;
10431 }
10432 }
10433 {
10434 (arg1)->Inset(arg2,arg3);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 resultobj = SWIG_Py_Void();
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10445 PyObject *resultobj = 0;
10446 wxRect2D *arg1 = (wxRect2D *) 0 ;
10447 wxDouble arg2 ;
10448 wxDouble arg3 ;
10449 wxDouble arg4 ;
10450 wxDouble arg5 ;
10451 void *argp1 = 0 ;
10452 int res1 = 0 ;
10453 void *argp2 ;
10454 int res2 = 0 ;
10455 void *argp3 ;
10456 int res3 = 0 ;
10457 void *argp4 ;
10458 int res4 = 0 ;
10459 void *argp5 ;
10460 int res5 = 0 ;
10461
10462 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10466 }
10467 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10468 {
10469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10470 if (!SWIG_IsOK(res2)) {
10471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10472 }
10473 if (!argp2) {
10474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10475 } else {
10476 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10477 arg2 = *temp;
10478 if (SWIG_IsNewObj(res2)) delete temp;
10479 }
10480 }
10481 {
10482 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10483 if (!SWIG_IsOK(res3)) {
10484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10485 }
10486 if (!argp3) {
10487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10488 } else {
10489 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10490 arg3 = *temp;
10491 if (SWIG_IsNewObj(res3)) delete temp;
10492 }
10493 }
10494 {
10495 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10496 if (!SWIG_IsOK(res4)) {
10497 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10498 }
10499 if (!argp4) {
10500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10501 } else {
10502 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10503 arg4 = *temp;
10504 if (SWIG_IsNewObj(res4)) delete temp;
10505 }
10506 }
10507 {
10508 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10509 if (!SWIG_IsOK(res5)) {
10510 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10511 }
10512 if (!argp5) {
10513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10514 } else {
10515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10516 arg5 = *temp;
10517 if (SWIG_IsNewObj(res5)) delete temp;
10518 }
10519 }
10520 {
10521 (arg1)->Inset(arg2,arg3,arg4,arg5);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_Py_Void();
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10532 int argc;
10533 PyObject *argv[6];
10534
10535 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10536 --argc;
10537 if (argc == 3) {
10538 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10539 }
10540 if (argc == 5) {
10541 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10542 }
10543
10544 fail:
10545 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10551 PyObject *resultobj = 0;
10552 wxRect2D *arg1 = (wxRect2D *) 0 ;
10553 wxPoint2D *arg2 = 0 ;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 wxPoint2D temp2 ;
10557 PyObject * obj0 = 0 ;
10558 PyObject * obj1 = 0 ;
10559 char * kwnames[] = {
10560 (char *) "self",(char *) "pt", NULL
10561 };
10562
10563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10565 if (!SWIG_IsOK(res1)) {
10566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10567 }
10568 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10569 {
10570 arg2 = &temp2;
10571 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10572 }
10573 {
10574 (arg1)->Offset((wxPoint2D const &)*arg2);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_Py_Void();
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj = 0;
10586 wxRect2D *arg1 = (wxRect2D *) 0 ;
10587 wxRect2D *arg2 = 0 ;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 wxRect2D temp2 ;
10591 PyObject * obj0 = 0 ;
10592 PyObject * obj1 = 0 ;
10593 char * kwnames[] = {
10594 (char *) "self",(char *) "rect", NULL
10595 };
10596
10597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10599 if (!SWIG_IsOK(res1)) {
10600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10601 }
10602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10603 {
10604 arg2 = &temp2;
10605 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10606 }
10607 {
10608 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10609 if (PyErr_Occurred()) SWIG_fail;
10610 }
10611 resultobj = SWIG_Py_Void();
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj = 0;
10620 wxRect2D *arg1 = (wxRect2D *) 0 ;
10621 int arg2 ;
10622 int arg3 ;
10623 wxPoint2D result;
10624 void *argp1 = 0 ;
10625 int res1 = 0 ;
10626 int val2 ;
10627 int ecode2 = 0 ;
10628 int val3 ;
10629 int ecode3 = 0 ;
10630 PyObject * obj0 = 0 ;
10631 PyObject * obj1 = 0 ;
10632 PyObject * obj2 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10641 }
10642 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10643 ecode2 = SWIG_AsVal_int(obj1, &val2);
10644 if (!SWIG_IsOK(ecode2)) {
10645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10646 }
10647 arg2 = static_cast< int >(val2);
10648 ecode3 = SWIG_AsVal_int(obj2, &val3);
10649 if (!SWIG_IsOK(ecode3)) {
10650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10651 }
10652 arg3 = static_cast< int >(val3);
10653 {
10654 result = (arg1)->Interpolate(arg2,arg3);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj = 0;
10666 wxRect2D *arg1 = (wxRect2D *) 0 ;
10667 wxRect2D *arg2 = 0 ;
10668 void *argp1 = 0 ;
10669 int res1 = 0 ;
10670 wxRect2D temp2 ;
10671 PyObject * obj0 = 0 ;
10672 PyObject * obj1 = 0 ;
10673 char * kwnames[] = {
10674 (char *) "self",(char *) "otherRect", NULL
10675 };
10676
10677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10679 if (!SWIG_IsOK(res1)) {
10680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10681 }
10682 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10683 {
10684 arg2 = &temp2;
10685 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10686 }
10687 {
10688 (arg1)->Intersect((wxRect2D const &)*arg2);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_Py_Void();
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj = 0;
10700 wxRect2D *arg1 = (wxRect2D *) 0 ;
10701 wxRect2D *arg2 = 0 ;
10702 wxRect2D result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 wxRect2D temp2 ;
10706 PyObject * obj0 = 0 ;
10707 PyObject * obj1 = 0 ;
10708 char * kwnames[] = {
10709 (char *) "self",(char *) "otherRect", NULL
10710 };
10711
10712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10714 if (!SWIG_IsOK(res1)) {
10715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10716 }
10717 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10718 {
10719 arg2 = &temp2;
10720 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10721 }
10722 {
10723 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10734 PyObject *resultobj = 0;
10735 wxRect2D *arg1 = (wxRect2D *) 0 ;
10736 wxRect2D *arg2 = 0 ;
10737 bool result;
10738 void *argp1 = 0 ;
10739 int res1 = 0 ;
10740 wxRect2D temp2 ;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "self",(char *) "rect", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10751 }
10752 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10753 {
10754 arg2 = &temp2;
10755 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10756 }
10757 {
10758 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10763 }
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj = 0;
10772 wxRect2D *arg1 = (wxRect2D *) 0 ;
10773 wxRect2D *arg2 = 0 ;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 wxRect2D temp2 ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "otherRect", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10787 }
10788 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10789 {
10790 arg2 = &temp2;
10791 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10792 }
10793 {
10794 (arg1)->Union((wxRect2D const &)*arg2);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 resultobj = SWIG_Py_Void();
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxRect2D *arg1 = (wxRect2D *) 0 ;
10807 wxRect2D *arg2 = 0 ;
10808 wxRect2D result;
10809 void *argp1 = 0 ;
10810 int res1 = 0 ;
10811 wxRect2D temp2 ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "otherRect", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10822 }
10823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10824 {
10825 arg2 = &temp2;
10826 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10827 }
10828 {
10829 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10840 PyObject *resultobj = 0;
10841 wxRect2D *arg1 = (wxRect2D *) 0 ;
10842 wxDouble arg2 ;
10843 void *argp1 = 0 ;
10844 int res1 = 0 ;
10845 void *argp2 ;
10846 int res2 = 0 ;
10847
10848 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10850 if (!SWIG_IsOK(res1)) {
10851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10852 }
10853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10854 {
10855 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10856 if (!SWIG_IsOK(res2)) {
10857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10858 }
10859 if (!argp2) {
10860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10861 } else {
10862 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10863 arg2 = *temp;
10864 if (SWIG_IsNewObj(res2)) delete temp;
10865 }
10866 }
10867 {
10868 (arg1)->Scale(arg2);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 resultobj = SWIG_Py_Void();
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10879 PyObject *resultobj = 0;
10880 wxRect2D *arg1 = (wxRect2D *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 void *argp1 = 0 ;
10884 int res1 = 0 ;
10885 int val2 ;
10886 int ecode2 = 0 ;
10887 int val3 ;
10888 int ecode3 = 0 ;
10889
10890 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10892 if (!SWIG_IsOK(res1)) {
10893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10894 }
10895 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10896 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10897 if (!SWIG_IsOK(ecode2)) {
10898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10899 }
10900 arg2 = static_cast< int >(val2);
10901 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10902 if (!SWIG_IsOK(ecode3)) {
10903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10904 }
10905 arg3 = static_cast< int >(val3);
10906 {
10907 (arg1)->Scale(arg2,arg3);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_Py_Void();
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10918 int argc;
10919 PyObject *argv[4];
10920
10921 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10922 --argc;
10923 if (argc == 2) {
10924 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10925 }
10926 if (argc == 3) {
10927 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10928 }
10929
10930 fail:
10931 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10932 return NULL;
10933 }
10934
10935
10936 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj = 0;
10938 wxRect2D *arg1 = (wxRect2D *) 0 ;
10939 PyObject *arg2 = (PyObject *) 0 ;
10940 bool result;
10941 void *argp1 = 0 ;
10942 int res1 = 0 ;
10943 PyObject * obj0 = 0 ;
10944 PyObject * obj1 = 0 ;
10945 char * kwnames[] = {
10946 (char *) "self",(char *) "other", NULL
10947 };
10948
10949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10951 if (!SWIG_IsOK(res1)) {
10952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10953 }
10954 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10955 arg2 = obj1;
10956 {
10957 result = (bool)wxRect2D___eq__(arg1,arg2);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 {
10961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10962 }
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj = 0;
10971 wxRect2D *arg1 = (wxRect2D *) 0 ;
10972 PyObject *arg2 = (PyObject *) 0 ;
10973 bool result;
10974 void *argp1 = 0 ;
10975 int res1 = 0 ;
10976 PyObject * obj0 = 0 ;
10977 PyObject * obj1 = 0 ;
10978 char * kwnames[] = {
10979 (char *) "self",(char *) "other", NULL
10980 };
10981
10982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10984 if (!SWIG_IsOK(res1)) {
10985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10986 }
10987 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10988 arg2 = obj1;
10989 {
10990 result = (bool)wxRect2D___ne__(arg1,arg2);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10995 }
10996 return resultobj;
10997 fail:
10998 return NULL;
10999 }
11000
11001
11002 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11003 PyObject *resultobj = 0;
11004 wxRect2D *arg1 = (wxRect2D *) 0 ;
11005 wxDouble arg2 ;
11006 void *argp1 = 0 ;
11007 int res1 = 0 ;
11008 void *argp2 ;
11009 int res2 = 0 ;
11010 PyObject *swig_obj[2] ;
11011
11012 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11014 if (!SWIG_IsOK(res1)) {
11015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11016 }
11017 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11018 {
11019 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11020 if (!SWIG_IsOK(res2)) {
11021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11022 }
11023 if (!argp2) {
11024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11025 } else {
11026 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11027 arg2 = *temp;
11028 if (SWIG_IsNewObj(res2)) delete temp;
11029 }
11030 }
11031 if (arg1) (arg1)->m_x = arg2;
11032
11033 resultobj = SWIG_Py_Void();
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11041 PyObject *resultobj = 0;
11042 wxRect2D *arg1 = (wxRect2D *) 0 ;
11043 wxDouble result;
11044 void *argp1 = 0 ;
11045 int res1 = 0 ;
11046 PyObject *swig_obj[1] ;
11047
11048 if (!args) SWIG_fail;
11049 swig_obj[0] = args;
11050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11051 if (!SWIG_IsOK(res1)) {
11052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11053 }
11054 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11055 result = ((arg1)->m_x);
11056 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11064 PyObject *resultobj = 0;
11065 wxRect2D *arg1 = (wxRect2D *) 0 ;
11066 wxDouble arg2 ;
11067 void *argp1 = 0 ;
11068 int res1 = 0 ;
11069 void *argp2 ;
11070 int res2 = 0 ;
11071 PyObject *swig_obj[2] ;
11072
11073 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11075 if (!SWIG_IsOK(res1)) {
11076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11077 }
11078 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11079 {
11080 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11081 if (!SWIG_IsOK(res2)) {
11082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11083 }
11084 if (!argp2) {
11085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11086 } else {
11087 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11088 arg2 = *temp;
11089 if (SWIG_IsNewObj(res2)) delete temp;
11090 }
11091 }
11092 if (arg1) (arg1)->m_y = arg2;
11093
11094 resultobj = SWIG_Py_Void();
11095 return resultobj;
11096 fail:
11097 return NULL;
11098 }
11099
11100
11101 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11102 PyObject *resultobj = 0;
11103 wxRect2D *arg1 = (wxRect2D *) 0 ;
11104 wxDouble result;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 PyObject *swig_obj[1] ;
11108
11109 if (!args) SWIG_fail;
11110 swig_obj[0] = args;
11111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11114 }
11115 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11116 result = ((arg1)->m_y);
11117 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125 PyObject *resultobj = 0;
11126 wxRect2D *arg1 = (wxRect2D *) 0 ;
11127 wxDouble arg2 ;
11128 void *argp1 = 0 ;
11129 int res1 = 0 ;
11130 void *argp2 ;
11131 int res2 = 0 ;
11132 PyObject *swig_obj[2] ;
11133
11134 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11136 if (!SWIG_IsOK(res1)) {
11137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11138 }
11139 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11140 {
11141 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11142 if (!SWIG_IsOK(res2)) {
11143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11144 }
11145 if (!argp2) {
11146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11147 } else {
11148 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11149 arg2 = *temp;
11150 if (SWIG_IsNewObj(res2)) delete temp;
11151 }
11152 }
11153 if (arg1) (arg1)->m_width = arg2;
11154
11155 resultobj = SWIG_Py_Void();
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163 PyObject *resultobj = 0;
11164 wxRect2D *arg1 = (wxRect2D *) 0 ;
11165 wxDouble result;
11166 void *argp1 = 0 ;
11167 int res1 = 0 ;
11168 PyObject *swig_obj[1] ;
11169
11170 if (!args) SWIG_fail;
11171 swig_obj[0] = args;
11172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11173 if (!SWIG_IsOK(res1)) {
11174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11175 }
11176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11177 result = ((arg1)->m_width);
11178 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186 PyObject *resultobj = 0;
11187 wxRect2D *arg1 = (wxRect2D *) 0 ;
11188 wxDouble arg2 ;
11189 void *argp1 = 0 ;
11190 int res1 = 0 ;
11191 void *argp2 ;
11192 int res2 = 0 ;
11193 PyObject *swig_obj[2] ;
11194
11195 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11197 if (!SWIG_IsOK(res1)) {
11198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11199 }
11200 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11201 {
11202 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11203 if (!SWIG_IsOK(res2)) {
11204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11205 }
11206 if (!argp2) {
11207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11208 } else {
11209 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11210 arg2 = *temp;
11211 if (SWIG_IsNewObj(res2)) delete temp;
11212 }
11213 }
11214 if (arg1) (arg1)->m_height = arg2;
11215
11216 resultobj = SWIG_Py_Void();
11217 return resultobj;
11218 fail:
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11224 PyObject *resultobj = 0;
11225 wxRect2D *arg1 = (wxRect2D *) 0 ;
11226 wxDouble result;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 PyObject *swig_obj[1] ;
11230
11231 if (!args) SWIG_fail;
11232 swig_obj[0] = args;
11233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11234 if (!SWIG_IsOK(res1)) {
11235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11236 }
11237 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11238 result = ((arg1)->m_height);
11239 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj = 0;
11248 wxRect2D *arg1 = (wxRect2D *) 0 ;
11249 wxDouble arg2 = (wxDouble) 0 ;
11250 wxDouble arg3 = (wxDouble) 0 ;
11251 wxDouble arg4 = (wxDouble) 0 ;
11252 wxDouble arg5 = (wxDouble) 0 ;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 void *argp2 ;
11256 int res2 = 0 ;
11257 void *argp3 ;
11258 int res3 = 0 ;
11259 void *argp4 ;
11260 int res4 = 0 ;
11261 void *argp5 ;
11262 int res5 = 0 ;
11263 PyObject * obj0 = 0 ;
11264 PyObject * obj1 = 0 ;
11265 PyObject * obj2 = 0 ;
11266 PyObject * obj3 = 0 ;
11267 PyObject * obj4 = 0 ;
11268 char * kwnames[] = {
11269 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11270 };
11271
11272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11274 if (!SWIG_IsOK(res1)) {
11275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11276 }
11277 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11278 if (obj1) {
11279 {
11280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11281 if (!SWIG_IsOK(res2)) {
11282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11283 }
11284 if (!argp2) {
11285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11286 } else {
11287 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11288 arg2 = *temp;
11289 if (SWIG_IsNewObj(res2)) delete temp;
11290 }
11291 }
11292 }
11293 if (obj2) {
11294 {
11295 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11296 if (!SWIG_IsOK(res3)) {
11297 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11298 }
11299 if (!argp3) {
11300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11301 } else {
11302 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11303 arg3 = *temp;
11304 if (SWIG_IsNewObj(res3)) delete temp;
11305 }
11306 }
11307 }
11308 if (obj3) {
11309 {
11310 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11311 if (!SWIG_IsOK(res4)) {
11312 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11313 }
11314 if (!argp4) {
11315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11316 } else {
11317 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11318 arg4 = *temp;
11319 if (SWIG_IsNewObj(res4)) delete temp;
11320 }
11321 }
11322 }
11323 if (obj4) {
11324 {
11325 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11326 if (!SWIG_IsOK(res5)) {
11327 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11328 }
11329 if (!argp5) {
11330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11331 } else {
11332 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11333 arg5 = *temp;
11334 if (SWIG_IsNewObj(res5)) delete temp;
11335 }
11336 }
11337 }
11338 {
11339 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 resultobj = SWIG_Py_Void();
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11350 PyObject *resultobj = 0;
11351 wxRect2D *arg1 = (wxRect2D *) 0 ;
11352 PyObject *result = 0 ;
11353 void *argp1 = 0 ;
11354 int res1 = 0 ;
11355 PyObject *swig_obj[1] ;
11356
11357 if (!args) SWIG_fail;
11358 swig_obj[0] = args;
11359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11360 if (!SWIG_IsOK(res1)) {
11361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11362 }
11363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11364 {
11365 result = (PyObject *)wxRect2D_Get(arg1);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 resultobj = result;
11369 return resultobj;
11370 fail:
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11376 PyObject *obj;
11377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11378 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11379 return SWIG_Py_Void();
11380 }
11381
11382 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11383 return SWIG_Python_InitShadowInstance(args);
11384 }
11385
11386 SWIGINTERN int DefaultPosition_set(PyObject *) {
11387 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11388 return 1;
11389 }
11390
11391
11392 SWIGINTERN PyObject *DefaultPosition_get(void) {
11393 PyObject *pyobj = 0;
11394
11395 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11396 return pyobj;
11397 }
11398
11399
11400 SWIGINTERN int DefaultSize_set(PyObject *) {
11401 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11402 return 1;
11403 }
11404
11405
11406 SWIGINTERN PyObject *DefaultSize_get(void) {
11407 PyObject *pyobj = 0;
11408
11409 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11410 return pyobj;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj = 0;
11416 PyObject *arg1 = (PyObject *) 0 ;
11417 wxPyInputStream *result = 0 ;
11418 PyObject * obj0 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "p", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11424 arg1 = obj0;
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11439 PyObject *resultobj = 0;
11440 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 PyObject *swig_obj[1] ;
11444
11445 if (!args) SWIG_fail;
11446 swig_obj[0] = args;
11447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11448 if (!SWIG_IsOK(res1)) {
11449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11450 }
11451 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 delete arg1;
11455
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_Py_Void();
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11467 PyObject *resultobj = 0;
11468 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11469 void *argp1 = 0 ;
11470 int res1 = 0 ;
11471 PyObject *swig_obj[1] ;
11472
11473 if (!args) SWIG_fail;
11474 swig_obj[0] = args;
11475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11476 if (!SWIG_IsOK(res1)) {
11477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11478 }
11479 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 (arg1)->close();
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 resultobj = SWIG_Py_Void();
11487 return resultobj;
11488 fail:
11489 return NULL;
11490 }
11491
11492
11493 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11494 PyObject *resultobj = 0;
11495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11496 void *argp1 = 0 ;
11497 int res1 = 0 ;
11498 PyObject *swig_obj[1] ;
11499
11500 if (!args) SWIG_fail;
11501 swig_obj[0] = args;
11502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11503 if (!SWIG_IsOK(res1)) {
11504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11505 }
11506 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11507 {
11508 PyThreadState* __tstate = wxPyBeginAllowThreads();
11509 (arg1)->flush();
11510 wxPyEndAllowThreads(__tstate);
11511 if (PyErr_Occurred()) SWIG_fail;
11512 }
11513 resultobj = SWIG_Py_Void();
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11521 PyObject *resultobj = 0;
11522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11523 bool result;
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_wxPyInputStream, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11533 }
11534 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)(arg1)->eof();
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 {
11542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11543 }
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj = 0;
11552 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11553 int arg2 = (int) -1 ;
11554 PyObject *result = 0 ;
11555 void *argp1 = 0 ;
11556 int res1 = 0 ;
11557 int val2 ;
11558 int ecode2 = 0 ;
11559 PyObject * obj0 = 0 ;
11560 PyObject * obj1 = 0 ;
11561 char * kwnames[] = {
11562 (char *) "self",(char *) "size", NULL
11563 };
11564
11565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11567 if (!SWIG_IsOK(res1)) {
11568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11569 }
11570 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11571 if (obj1) {
11572 ecode2 = SWIG_AsVal_int(obj1, &val2);
11573 if (!SWIG_IsOK(ecode2)) {
11574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11575 }
11576 arg2 = static_cast< int >(val2);
11577 }
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 result = (PyObject *)(arg1)->read(arg2);
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 resultobj = result;
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj = 0;
11593 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11594 int arg2 = (int) -1 ;
11595 PyObject *result = 0 ;
11596 void *argp1 = 0 ;
11597 int res1 = 0 ;
11598 int val2 ;
11599 int ecode2 = 0 ;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 char * kwnames[] = {
11603 (char *) "self",(char *) "size", NULL
11604 };
11605
11606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11608 if (!SWIG_IsOK(res1)) {
11609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11610 }
11611 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11612 if (obj1) {
11613 ecode2 = SWIG_AsVal_int(obj1, &val2);
11614 if (!SWIG_IsOK(ecode2)) {
11615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11616 }
11617 arg2 = static_cast< int >(val2);
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (PyObject *)(arg1)->readline(arg2);
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 resultobj = result;
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj = 0;
11634 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11635 int arg2 = (int) -1 ;
11636 PyObject *result = 0 ;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 int val2 ;
11640 int ecode2 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "sizehint", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11651 }
11652 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11653 if (obj1) {
11654 ecode2 = SWIG_AsVal_int(obj1, &val2);
11655 if (!SWIG_IsOK(ecode2)) {
11656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11657 }
11658 arg2 = static_cast< int >(val2);
11659 }
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (PyObject *)(arg1)->readlines(arg2);
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 resultobj = result;
11667 return resultobj;
11668 fail:
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11676 int arg2 ;
11677 int arg3 = (int) 0 ;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 int val2 ;
11681 int ecode2 = 0 ;
11682 int val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "offset",(char *) "whence", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11697 ecode2 = SWIG_AsVal_int(obj1, &val2);
11698 if (!SWIG_IsOK(ecode2)) {
11699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11700 }
11701 arg2 = static_cast< int >(val2);
11702 if (obj2) {
11703 ecode3 = SWIG_AsVal_int(obj2, &val3);
11704 if (!SWIG_IsOK(ecode3)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11706 }
11707 arg3 = static_cast< int >(val3);
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 (arg1)->seek(arg2,arg3);
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_Py_Void();
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11725 int result;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11735 }
11736 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (int)(arg1)->tell();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_From_int(static_cast< int >(result));
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11753 char result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject *swig_obj[1] ;
11757
11758 if (!args) SWIG_fail;
11759 swig_obj[0] = args;
11760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11763 }
11764 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (char)(arg1)->Peek();
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 resultobj = SWIG_From_char(static_cast< char >(result));
11772 return resultobj;
11773 fail:
11774 return NULL;
11775 }
11776
11777
11778 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11779 PyObject *resultobj = 0;
11780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11781 char result;
11782 void *argp1 = 0 ;
11783 int res1 = 0 ;
11784 PyObject *swig_obj[1] ;
11785
11786 if (!args) SWIG_fail;
11787 swig_obj[0] = args;
11788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11789 if (!SWIG_IsOK(res1)) {
11790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11791 }
11792 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (char)(arg1)->GetC();
11796 wxPyEndAllowThreads(__tstate);
11797 if (PyErr_Occurred()) SWIG_fail;
11798 }
11799 resultobj = SWIG_From_char(static_cast< char >(result));
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11809 size_t result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11819 }
11820 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (size_t)(arg1)->LastRead();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11837 bool result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11847 }
11848 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (bool)(arg1)->CanRead();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11867 bool result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11877 }
11878 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (bool)(arg1)->Eof();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj = 0;
11896 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11897 char arg2 ;
11898 bool result;
11899 void *argp1 = 0 ;
11900 int res1 = 0 ;
11901 char val2 ;
11902 int ecode2 = 0 ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 char * kwnames[] = {
11906 (char *) "self",(char *) "c", NULL
11907 };
11908
11909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11911 if (!SWIG_IsOK(res1)) {
11912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11913 }
11914 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11915 ecode2 = SWIG_AsVal_char(obj1, &val2);
11916 if (!SWIG_IsOK(ecode2)) {
11917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11918 }
11919 arg2 = static_cast< char >(val2);
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (bool)(arg1)->Ungetch(arg2);
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj = 0;
11937 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11938 long arg2 ;
11939 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11940 long result;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 long val2 ;
11944 int ecode2 = 0 ;
11945 int val3 ;
11946 int ecode3 = 0 ;
11947 PyObject * obj0 = 0 ;
11948 PyObject * obj1 = 0 ;
11949 PyObject * obj2 = 0 ;
11950 char * kwnames[] = {
11951 (char *) "self",(char *) "pos",(char *) "mode", NULL
11952 };
11953
11954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11956 if (!SWIG_IsOK(res1)) {
11957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11958 }
11959 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11960 ecode2 = SWIG_AsVal_long(obj1, &val2);
11961 if (!SWIG_IsOK(ecode2)) {
11962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11963 }
11964 arg2 = static_cast< long >(val2);
11965 if (obj2) {
11966 ecode3 = SWIG_AsVal_int(obj2, &val3);
11967 if (!SWIG_IsOK(ecode3)) {
11968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11969 }
11970 arg3 = static_cast< wxSeekMode >(val3);
11971 }
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (long)(arg1)->SeekI(arg2,arg3);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 resultobj = SWIG_From_long(static_cast< long >(result));
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 PyObject *resultobj = 0;
11987 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11988 long result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 PyObject *swig_obj[1] ;
11992
11993 if (!args) SWIG_fail;
11994 swig_obj[0] = args;
11995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11996 if (!SWIG_IsOK(res1)) {
11997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11998 }
11999 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (long)(arg1)->TellI();
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 resultobj = SWIG_From_long(static_cast< long >(result));
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12014 PyObject *obj;
12015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12016 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12017 return SWIG_Py_Void();
12018 }
12019
12020 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12021 return SWIG_Python_InitShadowInstance(args);
12022 }
12023
12024 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj = 0;
12026 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12027 PyObject *arg2 = (PyObject *) 0 ;
12028 void *argp1 = 0 ;
12029 int res1 = 0 ;
12030 PyObject * obj0 = 0 ;
12031 PyObject * obj1 = 0 ;
12032 char * kwnames[] = {
12033 (char *) "self",(char *) "obj", NULL
12034 };
12035
12036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12038 if (!SWIG_IsOK(res1)) {
12039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12040 }
12041 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12042 arg2 = obj1;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 wxOutputStream_write(arg1,arg2);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_Py_Void();
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 PyObject *resultobj = 0;
12058 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12059 size_t result;
12060 void *argp1 = 0 ;
12061 int res1 = 0 ;
12062 PyObject *swig_obj[1] ;
12063
12064 if (!args) SWIG_fail;
12065 swig_obj[0] = args;
12066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12069 }
12070 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *obj;
12086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12087 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12088 return SWIG_Py_Void();
12089 }
12090
12091 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj = 0;
12093 wxInputStream *arg1 = (wxInputStream *) 0 ;
12094 wxString *arg2 = 0 ;
12095 wxString *arg3 = 0 ;
12096 wxString *arg4 = 0 ;
12097 wxDateTime arg5 ;
12098 wxFSFile *result = 0 ;
12099 wxPyInputStream *temp1 ;
12100 bool temp2 = false ;
12101 bool temp3 = false ;
12102 bool temp4 = false ;
12103 void *argp5 ;
12104 int res5 = 0 ;
12105 PyObject * obj0 = 0 ;
12106 PyObject * obj1 = 0 ;
12107 PyObject * obj2 = 0 ;
12108 PyObject * obj3 = 0 ;
12109 PyObject * obj4 = 0 ;
12110 char * kwnames[] = {
12111 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12112 };
12113
12114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12115 {
12116 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12117 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12118 } else {
12119 PyErr_Clear(); // clear the failure of the wxPyConvert above
12120 arg1 = wxPyCBInputStream_create(obj0, true);
12121 if (arg1 == NULL) {
12122 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12123 SWIG_fail;
12124 }
12125 }
12126 }
12127 {
12128 arg2 = wxString_in_helper(obj1);
12129 if (arg2 == NULL) SWIG_fail;
12130 temp2 = true;
12131 }
12132 {
12133 arg3 = wxString_in_helper(obj2);
12134 if (arg3 == NULL) SWIG_fail;
12135 temp3 = true;
12136 }
12137 {
12138 arg4 = wxString_in_helper(obj3);
12139 if (arg4 == NULL) SWIG_fail;
12140 temp4 = true;
12141 }
12142 {
12143 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12144 if (!SWIG_IsOK(res5)) {
12145 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12146 }
12147 if (!argp5) {
12148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12149 } else {
12150 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12151 arg5 = *temp;
12152 if (SWIG_IsNewObj(res5)) delete temp;
12153 }
12154 }
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12162 {
12163 if (temp2)
12164 delete arg2;
12165 }
12166 {
12167 if (temp3)
12168 delete arg3;
12169 }
12170 {
12171 if (temp4)
12172 delete arg4;
12173 }
12174 return resultobj;
12175 fail:
12176 {
12177 if (temp2)
12178 delete arg2;
12179 }
12180 {
12181 if (temp3)
12182 delete arg3;
12183 }
12184 {
12185 if (temp4)
12186 delete arg4;
12187 }
12188 return NULL;
12189 }
12190
12191
12192 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12193 PyObject *resultobj = 0;
12194 wxFSFile *arg1 = (wxFSFile *) 0 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 PyObject *swig_obj[1] ;
12198
12199 if (!args) SWIG_fail;
12200 swig_obj[0] = args;
12201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12202 if (!SWIG_IsOK(res1)) {
12203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12204 }
12205 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 delete arg1;
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 resultobj = SWIG_Py_Void();
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12221 PyObject *resultobj = 0;
12222 wxFSFile *arg1 = (wxFSFile *) 0 ;
12223 wxInputStream *result = 0 ;
12224 void *argp1 = 0 ;
12225 int res1 = 0 ;
12226 PyObject *swig_obj[1] ;
12227
12228 if (!args) SWIG_fail;
12229 swig_obj[0] = args;
12230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12233 }
12234 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = (wxInputStream *)(arg1)->GetStream();
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 {
12242 wxPyInputStream * _ptr = NULL;
12243
12244 if (result) {
12245 _ptr = new wxPyInputStream(result);
12246 }
12247 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12256 PyObject *resultobj = 0;
12257 wxFSFile *arg1 = (wxFSFile *) 0 ;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 PyObject *swig_obj[1] ;
12261
12262 if (!args) SWIG_fail;
12263 swig_obj[0] = args;
12264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12265 if (!SWIG_IsOK(res1)) {
12266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12267 }
12268 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 (arg1)->DetachStream();
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_Py_Void();
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12283 PyObject *resultobj = 0;
12284 wxFSFile *arg1 = (wxFSFile *) 0 ;
12285 wxString *result = 0 ;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 PyObject *swig_obj[1] ;
12289
12290 if (!args) SWIG_fail;
12291 swig_obj[0] = args;
12292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12293 if (!SWIG_IsOK(res1)) {
12294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12295 }
12296 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 {
12300 wxString const &_result_ref = (arg1)->GetMimeType();
12301 result = (wxString *) &_result_ref;
12302 }
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 #if wxUSE_UNICODE
12308 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12309 #else
12310 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12311 #endif
12312 }
12313 return resultobj;
12314 fail:
12315 return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *resultobj = 0;
12321 wxFSFile *arg1 = (wxFSFile *) 0 ;
12322 wxString *result = 0 ;
12323 void *argp1 = 0 ;
12324 int res1 = 0 ;
12325 PyObject *swig_obj[1] ;
12326
12327 if (!args) SWIG_fail;
12328 swig_obj[0] = args;
12329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12332 }
12333 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 {
12337 wxString const &_result_ref = (arg1)->GetLocation();
12338 result = (wxString *) &_result_ref;
12339 }
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 {
12344 #if wxUSE_UNICODE
12345 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12346 #else
12347 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12348 #endif
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *resultobj = 0;
12358 wxFSFile *arg1 = (wxFSFile *) 0 ;
12359 wxString *result = 0 ;
12360 void *argp1 = 0 ;
12361 int res1 = 0 ;
12362 PyObject *swig_obj[1] ;
12363
12364 if (!args) SWIG_fail;
12365 swig_obj[0] = args;
12366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12367 if (!SWIG_IsOK(res1)) {
12368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12369 }
12370 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 {
12374 wxString const &_result_ref = (arg1)->GetAnchor();
12375 result = (wxString *) &_result_ref;
12376 }
12377 wxPyEndAllowThreads(__tstate);
12378 if (PyErr_Occurred()) SWIG_fail;
12379 }
12380 {
12381 #if wxUSE_UNICODE
12382 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12383 #else
12384 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12385 #endif
12386 }
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12394 PyObject *resultobj = 0;
12395 wxFSFile *arg1 = (wxFSFile *) 0 ;
12396 wxDateTime result;
12397 void *argp1 = 0 ;
12398 int res1 = 0 ;
12399 PyObject *swig_obj[1] ;
12400
12401 if (!args) SWIG_fail;
12402 swig_obj[0] = args;
12403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12404 if (!SWIG_IsOK(res1)) {
12405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12406 }
12407 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = (arg1)->GetModificationTime();
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12415 return resultobj;
12416 fail:
12417 return NULL;
12418 }
12419
12420
12421 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12422 PyObject *obj;
12423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12424 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12425 return SWIG_Py_Void();
12426 }
12427
12428 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 return SWIG_Python_InitShadowInstance(args);
12430 }
12431
12432 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12433 PyObject *resultobj = 0;
12434 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12435 void *argp1 = 0 ;
12436 int res1 = 0 ;
12437 PyObject *swig_obj[1] ;
12438
12439 if (!args) SWIG_fail;
12440 swig_obj[0] = args;
12441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12442 if (!SWIG_IsOK(res1)) {
12443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12444 }
12445 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 delete arg1;
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 resultobj = SWIG_Py_Void();
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461 PyObject *obj;
12462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12463 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12464 return SWIG_Py_Void();
12465 }
12466
12467 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 PyObject *resultobj = 0;
12469 wxPyFileSystemHandler *result = 0 ;
12470
12471 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj = 0;
12487 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12488 PyObject *arg2 = (PyObject *) 0 ;
12489 PyObject *arg3 = (PyObject *) 0 ;
12490 void *argp1 = 0 ;
12491 int res1 = 0 ;
12492 PyObject * obj0 = 0 ;
12493 PyObject * obj1 = 0 ;
12494 PyObject * obj2 = 0 ;
12495 char * kwnames[] = {
12496 (char *) "self",(char *) "self",(char *) "_class", NULL
12497 };
12498
12499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12501 if (!SWIG_IsOK(res1)) {
12502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12503 }
12504 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12505 arg2 = obj1;
12506 arg3 = obj2;
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 (arg1)->_setCallbackInfo(arg2,arg3);
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_Py_Void();
12514 return resultobj;
12515 fail:
12516 return NULL;
12517 }
12518
12519
12520 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12523 wxString *arg2 = 0 ;
12524 bool result;
12525 void *argp1 = 0 ;
12526 int res1 = 0 ;
12527 bool temp2 = false ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char * kwnames[] = {
12531 (char *) "self",(char *) "location", NULL
12532 };
12533
12534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12538 }
12539 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12540 {
12541 arg2 = wxString_in_helper(obj1);
12542 if (arg2 == NULL) SWIG_fail;
12543 temp2 = true;
12544 }
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12553 }
12554 {
12555 if (temp2)
12556 delete arg2;
12557 }
12558 return resultobj;
12559 fail:
12560 {
12561 if (temp2)
12562 delete arg2;
12563 }
12564 return NULL;
12565 }
12566
12567
12568 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12569 PyObject *resultobj = 0;
12570 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12571 wxFileSystem *arg2 = 0 ;
12572 wxString *arg3 = 0 ;
12573 wxFSFile *result = 0 ;
12574 void *argp1 = 0 ;
12575 int res1 = 0 ;
12576 void *argp2 = 0 ;
12577 int res2 = 0 ;
12578 bool temp3 = false ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 PyObject * obj2 = 0 ;
12582 char * kwnames[] = {
12583 (char *) "self",(char *) "fs",(char *) "location", NULL
12584 };
12585
12586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12588 if (!SWIG_IsOK(res1)) {
12589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12590 }
12591 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12592 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12593 if (!SWIG_IsOK(res2)) {
12594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12595 }
12596 if (!argp2) {
12597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12598 }
12599 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12600 {
12601 arg3 = wxString_in_helper(obj2);
12602 if (arg3 == NULL) SWIG_fail;
12603 temp3 = true;
12604 }
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12613 }
12614 {
12615 if (temp3)
12616 delete arg3;
12617 }
12618 return resultobj;
12619 fail:
12620 {
12621 if (temp3)
12622 delete arg3;
12623 }
12624 return NULL;
12625 }
12626
12627
12628 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj = 0;
12630 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12631 wxString *arg2 = 0 ;
12632 int arg3 = (int) 0 ;
12633 wxString result;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 bool temp2 = false ;
12637 int val3 ;
12638 int ecode3 = 0 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 char * kwnames[] = {
12643 (char *) "self",(char *) "spec",(char *) "flags", NULL
12644 };
12645
12646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12648 if (!SWIG_IsOK(res1)) {
12649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12650 }
12651 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12652 {
12653 arg2 = wxString_in_helper(obj1);
12654 if (arg2 == NULL) SWIG_fail;
12655 temp2 = true;
12656 }
12657 if (obj2) {
12658 ecode3 = SWIG_AsVal_int(obj2, &val3);
12659 if (!SWIG_IsOK(ecode3)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12661 }
12662 arg3 = static_cast< int >(val3);
12663 }
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 #if wxUSE_UNICODE
12672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12673 #else
12674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12675 #endif
12676 }
12677 {
12678 if (temp2)
12679 delete arg2;
12680 }
12681 return resultobj;
12682 fail:
12683 {
12684 if (temp2)
12685 delete arg2;
12686 }
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12692 PyObject *resultobj = 0;
12693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12694 wxString result;
12695 void *argp1 = 0 ;
12696 int res1 = 0 ;
12697 PyObject *swig_obj[1] ;
12698
12699 if (!args) SWIG_fail;
12700 swig_obj[0] = args;
12701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12702 if (!SWIG_IsOK(res1)) {
12703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12704 }
12705 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (arg1)->FindNext();
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 #if wxUSE_UNICODE
12714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12715 #else
12716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12717 #endif
12718 }
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12726 PyObject *resultobj = 0;
12727 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12728 wxString *arg2 = 0 ;
12729 wxString result;
12730 void *argp1 = 0 ;
12731 int res1 = 0 ;
12732 bool temp2 = false ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char * kwnames[] = {
12736 (char *) "self",(char *) "location", NULL
12737 };
12738
12739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12743 }
12744 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12745 {
12746 arg2 = wxString_in_helper(obj1);
12747 if (arg2 == NULL) SWIG_fail;
12748 temp2 = true;
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (arg1)->GetProtocol((wxString const &)*arg2);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 #if wxUSE_UNICODE
12758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12759 #else
12760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12761 #endif
12762 }
12763 {
12764 if (temp2)
12765 delete arg2;
12766 }
12767 return resultobj;
12768 fail:
12769 {
12770 if (temp2)
12771 delete arg2;
12772 }
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj = 0;
12779 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12780 wxString *arg2 = 0 ;
12781 wxString result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 bool temp2 = false ;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 char * kwnames[] = {
12788 (char *) "self",(char *) "location", NULL
12789 };
12790
12791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12793 if (!SWIG_IsOK(res1)) {
12794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12795 }
12796 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12797 {
12798 arg2 = wxString_in_helper(obj1);
12799 if (arg2 == NULL) SWIG_fail;
12800 temp2 = true;
12801 }
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 {
12809 #if wxUSE_UNICODE
12810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12811 #else
12812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12813 #endif
12814 }
12815 {
12816 if (temp2)
12817 delete arg2;
12818 }
12819 return resultobj;
12820 fail:
12821 {
12822 if (temp2)
12823 delete arg2;
12824 }
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12830 PyObject *resultobj = 0;
12831 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12832 wxString *arg2 = 0 ;
12833 wxString result;
12834 void *argp1 = 0 ;
12835 int res1 = 0 ;
12836 bool temp2 = false ;
12837 PyObject * obj0 = 0 ;
12838 PyObject * obj1 = 0 ;
12839 char * kwnames[] = {
12840 (char *) "self",(char *) "location", NULL
12841 };
12842
12843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12845 if (!SWIG_IsOK(res1)) {
12846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12847 }
12848 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12849 {
12850 arg2 = wxString_in_helper(obj1);
12851 if (arg2 == NULL) SWIG_fail;
12852 temp2 = true;
12853 }
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 result = (arg1)->GetAnchor((wxString const &)*arg2);
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 #if wxUSE_UNICODE
12862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12863 #else
12864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12865 #endif
12866 }
12867 {
12868 if (temp2)
12869 delete arg2;
12870 }
12871 return resultobj;
12872 fail:
12873 {
12874 if (temp2)
12875 delete arg2;
12876 }
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12882 PyObject *resultobj = 0;
12883 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12884 wxString *arg2 = 0 ;
12885 wxString result;
12886 void *argp1 = 0 ;
12887 int res1 = 0 ;
12888 bool temp2 = false ;
12889 PyObject * obj0 = 0 ;
12890 PyObject * obj1 = 0 ;
12891 char * kwnames[] = {
12892 (char *) "self",(char *) "location", NULL
12893 };
12894
12895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12897 if (!SWIG_IsOK(res1)) {
12898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12899 }
12900 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12901 {
12902 arg2 = wxString_in_helper(obj1);
12903 if (arg2 == NULL) SWIG_fail;
12904 temp2 = true;
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 {
12913 #if wxUSE_UNICODE
12914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12915 #else
12916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12917 #endif
12918 }
12919 {
12920 if (temp2)
12921 delete arg2;
12922 }
12923 return resultobj;
12924 fail:
12925 {
12926 if (temp2)
12927 delete arg2;
12928 }
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj = 0;
12935 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12936 wxString *arg2 = 0 ;
12937 wxString result;
12938 void *argp1 = 0 ;
12939 int res1 = 0 ;
12940 bool temp2 = false ;
12941 PyObject * obj0 = 0 ;
12942 PyObject * obj1 = 0 ;
12943 char * kwnames[] = {
12944 (char *) "self",(char *) "location", NULL
12945 };
12946
12947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12951 }
12952 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12953 {
12954 arg2 = wxString_in_helper(obj1);
12955 if (arg2 == NULL) SWIG_fail;
12956 temp2 = true;
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 {
12965 #if wxUSE_UNICODE
12966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12967 #else
12968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12969 #endif
12970 }
12971 {
12972 if (temp2)
12973 delete arg2;
12974 }
12975 return resultobj;
12976 fail:
12977 {
12978 if (temp2)
12979 delete arg2;
12980 }
12981 return NULL;
12982 }
12983
12984
12985 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12986 PyObject *obj;
12987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12989 return SWIG_Py_Void();
12990 }
12991
12992 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 return SWIG_Python_InitShadowInstance(args);
12994 }
12995
12996 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *resultobj = 0;
12998 wxFileSystem *result = 0 ;
12999
13000 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 result = (wxFileSystem *)new wxFileSystem();
13004 wxPyEndAllowThreads(__tstate);
13005 if (PyErr_Occurred()) SWIG_fail;
13006 }
13007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *resultobj = 0;
13016 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13017 void *argp1 = 0 ;
13018 int res1 = 0 ;
13019 PyObject *swig_obj[1] ;
13020
13021 if (!args) SWIG_fail;
13022 swig_obj[0] = args;
13023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13024 if (!SWIG_IsOK(res1)) {
13025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13026 }
13027 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13028 {
13029 PyThreadState* __tstate = wxPyBeginAllowThreads();
13030 delete arg1;
13031
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 resultobj = SWIG_Py_Void();
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj = 0;
13044 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13045 wxString *arg2 = 0 ;
13046 bool arg3 = (bool) false ;
13047 void *argp1 = 0 ;
13048 int res1 = 0 ;
13049 bool temp2 = false ;
13050 bool val3 ;
13051 int ecode3 = 0 ;
13052 PyObject * obj0 = 0 ;
13053 PyObject * obj1 = 0 ;
13054 PyObject * obj2 = 0 ;
13055 char * kwnames[] = {
13056 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13057 };
13058
13059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13061 if (!SWIG_IsOK(res1)) {
13062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13063 }
13064 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13065 {
13066 arg2 = wxString_in_helper(obj1);
13067 if (arg2 == NULL) SWIG_fail;
13068 temp2 = true;
13069 }
13070 if (obj2) {
13071 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13072 if (!SWIG_IsOK(ecode3)) {
13073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13074 }
13075 arg3 = static_cast< bool >(val3);
13076 }
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13080 wxPyEndAllowThreads(__tstate);
13081 if (PyErr_Occurred()) SWIG_fail;
13082 }
13083 resultobj = SWIG_Py_Void();
13084 {
13085 if (temp2)
13086 delete arg2;
13087 }
13088 return resultobj;
13089 fail:
13090 {
13091 if (temp2)
13092 delete arg2;
13093 }
13094 return NULL;
13095 }
13096
13097
13098 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *resultobj = 0;
13100 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13101 wxString result;
13102 void *argp1 = 0 ;
13103 int res1 = 0 ;
13104 PyObject *swig_obj[1] ;
13105
13106 if (!args) SWIG_fail;
13107 swig_obj[0] = args;
13108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13109 if (!SWIG_IsOK(res1)) {
13110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13111 }
13112 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = (arg1)->GetPath();
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 {
13120 #if wxUSE_UNICODE
13121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13122 #else
13123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13124 #endif
13125 }
13126 return resultobj;
13127 fail:
13128 return NULL;
13129 }
13130
13131
13132 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13133 PyObject *resultobj = 0;
13134 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13135 wxString *arg2 = 0 ;
13136 wxFSFile *result = 0 ;
13137 void *argp1 = 0 ;
13138 int res1 = 0 ;
13139 bool temp2 = false ;
13140 PyObject * obj0 = 0 ;
13141 PyObject * obj1 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "self",(char *) "location", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13150 }
13151 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13152 {
13153 arg2 = wxString_in_helper(obj1);
13154 if (arg2 == NULL) SWIG_fail;
13155 temp2 = true;
13156 }
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 {
13164 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13165 }
13166 {
13167 if (temp2)
13168 delete arg2;
13169 }
13170 return resultobj;
13171 fail:
13172 {
13173 if (temp2)
13174 delete arg2;
13175 }
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13183 wxString *arg2 = 0 ;
13184 int arg3 = (int) 0 ;
13185 wxString result;
13186 void *argp1 = 0 ;
13187 int res1 = 0 ;
13188 bool temp2 = false ;
13189 int val3 ;
13190 int ecode3 = 0 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 PyObject * obj2 = 0 ;
13194 char * kwnames[] = {
13195 (char *) "self",(char *) "spec",(char *) "flags", NULL
13196 };
13197
13198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13200 if (!SWIG_IsOK(res1)) {
13201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13202 }
13203 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13204 {
13205 arg2 = wxString_in_helper(obj1);
13206 if (arg2 == NULL) SWIG_fail;
13207 temp2 = true;
13208 }
13209 if (obj2) {
13210 ecode3 = SWIG_AsVal_int(obj2, &val3);
13211 if (!SWIG_IsOK(ecode3)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13213 }
13214 arg3 = static_cast< int >(val3);
13215 }
13216 {
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 {
13223 #if wxUSE_UNICODE
13224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13225 #else
13226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13227 #endif
13228 }
13229 {
13230 if (temp2)
13231 delete arg2;
13232 }
13233 return resultobj;
13234 fail:
13235 {
13236 if (temp2)
13237 delete arg2;
13238 }
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13244 PyObject *resultobj = 0;
13245 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13246 wxString result;
13247 void *argp1 = 0 ;
13248 int res1 = 0 ;
13249 PyObject *swig_obj[1] ;
13250
13251 if (!args) SWIG_fail;
13252 swig_obj[0] = args;
13253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13254 if (!SWIG_IsOK(res1)) {
13255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13256 }
13257 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = (arg1)->FindNext();
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 {
13265 #if wxUSE_UNICODE
13266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13267 #else
13268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13269 #endif
13270 }
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj = 0;
13279 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13280 int res1 = 0 ;
13281 PyObject * obj0 = 0 ;
13282 char * kwnames[] = {
13283 (char *) "handler", NULL
13284 };
13285
13286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13287 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13288 if (!SWIG_IsOK(res1)) {
13289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13290 }
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 wxFileSystem::AddHandler(arg1);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_Py_Void();
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13307 wxFileSystemHandler *result = 0 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 PyObject * obj0 = 0 ;
13311 char * kwnames[] = {
13312 (char *) "handler", NULL
13313 };
13314
13315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13317 if (!SWIG_IsOK(res1)) {
13318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13319 }
13320 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13335 PyObject *resultobj = 0;
13336
13337 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 wxFileSystem::CleanUpHandlers();
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_Py_Void();
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = 0;
13353 wxString *arg1 = 0 ;
13354 wxString result;
13355 bool temp1 = false ;
13356 PyObject * obj0 = 0 ;
13357 char * kwnames[] = {
13358 (char *) "filename", NULL
13359 };
13360
13361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13362 {
13363 arg1 = wxString_in_helper(obj0);
13364 if (arg1 == NULL) SWIG_fail;
13365 temp1 = true;
13366 }
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 {
13374 #if wxUSE_UNICODE
13375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13376 #else
13377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13378 #endif
13379 }
13380 {
13381 if (temp1)
13382 delete arg1;
13383 }
13384 return resultobj;
13385 fail:
13386 {
13387 if (temp1)
13388 delete arg1;
13389 }
13390 return NULL;
13391 }
13392
13393
13394 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13395 PyObject *resultobj = 0;
13396 wxString *arg1 = 0 ;
13397 wxString result;
13398 bool temp1 = false ;
13399 PyObject * obj0 = 0 ;
13400 char * kwnames[] = {
13401 (char *) "url", NULL
13402 };
13403
13404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13405 {
13406 arg1 = wxString_in_helper(obj0);
13407 if (arg1 == NULL) SWIG_fail;
13408 temp1 = true;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
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 (temp1)
13425 delete arg1;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp1)
13431 delete arg1;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *obj;
13439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13440 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13441 return SWIG_Py_Void();
13442 }
13443
13444 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 return SWIG_Python_InitShadowInstance(args);
13446 }
13447
13448 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *resultobj = 0;
13450 wxInternetFSHandler *result = 0 ;
13451
13452 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj = 0;
13468 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13469 wxString *arg2 = 0 ;
13470 bool result;
13471 void *argp1 = 0 ;
13472 int res1 = 0 ;
13473 bool temp2 = false ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 char * kwnames[] = {
13477 (char *) "self",(char *) "location", NULL
13478 };
13479
13480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13482 if (!SWIG_IsOK(res1)) {
13483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13484 }
13485 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13486 {
13487 arg2 = wxString_in_helper(obj1);
13488 if (arg2 == NULL) SWIG_fail;
13489 temp2 = true;
13490 }
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 {
13501 if (temp2)
13502 delete arg2;
13503 }
13504 return resultobj;
13505 fail:
13506 {
13507 if (temp2)
13508 delete arg2;
13509 }
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj = 0;
13516 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13517 wxFileSystem *arg2 = 0 ;
13518 wxString *arg3 = 0 ;
13519 wxFSFile *result = 0 ;
13520 void *argp1 = 0 ;
13521 int res1 = 0 ;
13522 void *argp2 = 0 ;
13523 int res2 = 0 ;
13524 bool temp3 = false ;
13525 PyObject * obj0 = 0 ;
13526 PyObject * obj1 = 0 ;
13527 PyObject * obj2 = 0 ;
13528 char * kwnames[] = {
13529 (char *) "self",(char *) "fs",(char *) "location", NULL
13530 };
13531
13532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13534 if (!SWIG_IsOK(res1)) {
13535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13536 }
13537 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13539 if (!SWIG_IsOK(res2)) {
13540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13541 }
13542 if (!argp2) {
13543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13544 }
13545 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13546 {
13547 arg3 = wxString_in_helper(obj2);
13548 if (arg3 == NULL) SWIG_fail;
13549 temp3 = true;
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 {
13558 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13559 }
13560 {
13561 if (temp3)
13562 delete arg3;
13563 }
13564 return resultobj;
13565 fail:
13566 {
13567 if (temp3)
13568 delete arg3;
13569 }
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13575 PyObject *obj;
13576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13577 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13578 return SWIG_Py_Void();
13579 }
13580
13581 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13582 return SWIG_Python_InitShadowInstance(args);
13583 }
13584
13585 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586 PyObject *resultobj = 0;
13587 wxZipFSHandler *result = 0 ;
13588
13589 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13590 {
13591 PyThreadState* __tstate = wxPyBeginAllowThreads();
13592 result = (wxZipFSHandler *)new wxZipFSHandler();
13593 wxPyEndAllowThreads(__tstate);
13594 if (PyErr_Occurred()) SWIG_fail;
13595 }
13596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = 0;
13605 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13606 wxString *arg2 = 0 ;
13607 bool result;
13608 void *argp1 = 0 ;
13609 int res1 = 0 ;
13610 bool temp2 = false ;
13611 PyObject * obj0 = 0 ;
13612 PyObject * obj1 = 0 ;
13613 char * kwnames[] = {
13614 (char *) "self",(char *) "location", NULL
13615 };
13616
13617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13619 if (!SWIG_IsOK(res1)) {
13620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13621 }
13622 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13623 {
13624 arg2 = wxString_in_helper(obj1);
13625 if (arg2 == NULL) SWIG_fail;
13626 temp2 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 {
13635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13636 }
13637 {
13638 if (temp2)
13639 delete arg2;
13640 }
13641 return resultobj;
13642 fail:
13643 {
13644 if (temp2)
13645 delete arg2;
13646 }
13647 return NULL;
13648 }
13649
13650
13651 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj = 0;
13653 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13654 wxFileSystem *arg2 = 0 ;
13655 wxString *arg3 = 0 ;
13656 wxFSFile *result = 0 ;
13657 void *argp1 = 0 ;
13658 int res1 = 0 ;
13659 void *argp2 = 0 ;
13660 int res2 = 0 ;
13661 bool temp3 = false ;
13662 PyObject * obj0 = 0 ;
13663 PyObject * obj1 = 0 ;
13664 PyObject * obj2 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "self",(char *) "fs",(char *) "location", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13673 }
13674 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13675 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13676 if (!SWIG_IsOK(res2)) {
13677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13678 }
13679 if (!argp2) {
13680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13681 }
13682 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13683 {
13684 arg3 = wxString_in_helper(obj2);
13685 if (arg3 == NULL) SWIG_fail;
13686 temp3 = true;
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13691 wxPyEndAllowThreads(__tstate);
13692 if (PyErr_Occurred()) SWIG_fail;
13693 }
13694 {
13695 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13696 }
13697 {
13698 if (temp3)
13699 delete arg3;
13700 }
13701 return resultobj;
13702 fail:
13703 {
13704 if (temp3)
13705 delete arg3;
13706 }
13707 return NULL;
13708 }
13709
13710
13711 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj = 0;
13713 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13714 wxString *arg2 = 0 ;
13715 int arg3 = (int) 0 ;
13716 wxString result;
13717 void *argp1 = 0 ;
13718 int res1 = 0 ;
13719 bool temp2 = false ;
13720 int val3 ;
13721 int ecode3 = 0 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "self",(char *) "spec",(char *) "flags", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13731 if (!SWIG_IsOK(res1)) {
13732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13733 }
13734 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13735 {
13736 arg2 = wxString_in_helper(obj1);
13737 if (arg2 == NULL) SWIG_fail;
13738 temp2 = true;
13739 }
13740 if (obj2) {
13741 ecode3 = SWIG_AsVal_int(obj2, &val3);
13742 if (!SWIG_IsOK(ecode3)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13744 }
13745 arg3 = static_cast< int >(val3);
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 {
13754 #if wxUSE_UNICODE
13755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13756 #else
13757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13758 #endif
13759 }
13760 {
13761 if (temp2)
13762 delete arg2;
13763 }
13764 return resultobj;
13765 fail:
13766 {
13767 if (temp2)
13768 delete arg2;
13769 }
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775 PyObject *resultobj = 0;
13776 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13777 wxString result;
13778 void *argp1 = 0 ;
13779 int res1 = 0 ;
13780 PyObject *swig_obj[1] ;
13781
13782 if (!args) SWIG_fail;
13783 swig_obj[0] = args;
13784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13787 }
13788 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 result = (arg1)->FindNext();
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 {
13796 #if wxUSE_UNICODE
13797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13798 #else
13799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13800 #endif
13801 }
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13809 PyObject *obj;
13810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13811 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13812 return SWIG_Py_Void();
13813 }
13814
13815 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13816 return SWIG_Python_InitShadowInstance(args);
13817 }
13818
13819 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13820 PyObject *resultobj = 0;
13821 wxString *arg1 = 0 ;
13822 wxImage *arg2 = 0 ;
13823 long arg3 ;
13824 bool temp1 = false ;
13825 void *argp2 = 0 ;
13826 int res2 = 0 ;
13827 long val3 ;
13828 int ecode3 = 0 ;
13829 PyObject * obj0 = 0 ;
13830 PyObject * obj1 = 0 ;
13831 PyObject * obj2 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "filename",(char *) "image",(char *) "type", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13837 {
13838 arg1 = wxString_in_helper(obj0);
13839 if (arg1 == NULL) SWIG_fail;
13840 temp1 = true;
13841 }
13842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13843 if (!SWIG_IsOK(res2)) {
13844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13845 }
13846 if (!argp2) {
13847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13848 }
13849 arg2 = reinterpret_cast< wxImage * >(argp2);
13850 ecode3 = SWIG_AsVal_long(obj2, &val3);
13851 if (!SWIG_IsOK(ecode3)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13853 }
13854 arg3 = static_cast< long >(val3);
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 resultobj = SWIG_Py_Void();
13862 {
13863 if (temp1)
13864 delete arg1;
13865 }
13866 return resultobj;
13867 fail:
13868 {
13869 if (temp1)
13870 delete arg1;
13871 }
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxString *arg1 = 0 ;
13879 wxBitmap *arg2 = 0 ;
13880 long arg3 ;
13881 bool temp1 = false ;
13882 void *argp2 = 0 ;
13883 int res2 = 0 ;
13884 long val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 {
13895 arg1 = wxString_in_helper(obj0);
13896 if (arg1 == NULL) SWIG_fail;
13897 temp1 = true;
13898 }
13899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13900 if (!SWIG_IsOK(res2)) {
13901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13902 }
13903 if (!argp2) {
13904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13905 }
13906 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13907 ecode3 = SWIG_AsVal_long(obj2, &val3);
13908 if (!SWIG_IsOK(ecode3)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13910 }
13911 arg3 = static_cast< long >(val3);
13912 {
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 resultobj = SWIG_Py_Void();
13919 {
13920 if (temp1)
13921 delete arg1;
13922 }
13923 return resultobj;
13924 fail:
13925 {
13926 if (temp1)
13927 delete arg1;
13928 }
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13934 PyObject *resultobj = 0;
13935 wxString *arg1 = 0 ;
13936 PyObject *arg2 = (PyObject *) 0 ;
13937 bool temp1 = false ;
13938 PyObject * obj0 = 0 ;
13939 PyObject * obj1 = 0 ;
13940 char * kwnames[] = {
13941 (char *) "filename",(char *) "data", NULL
13942 };
13943
13944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13945 {
13946 arg1 = wxString_in_helper(obj0);
13947 if (arg1 == NULL) SWIG_fail;
13948 temp1 = true;
13949 }
13950 arg2 = obj1;
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13954 wxPyEndAllowThreads(__tstate);
13955 if (PyErr_Occurred()) SWIG_fail;
13956 }
13957 resultobj = SWIG_Py_Void();
13958 {
13959 if (temp1)
13960 delete arg1;
13961 }
13962 return resultobj;
13963 fail:
13964 {
13965 if (temp1)
13966 delete arg1;
13967 }
13968 return NULL;
13969 }
13970
13971
13972 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13973 PyObject *resultobj = 0;
13974 wxMemoryFSHandler *result = 0 ;
13975
13976 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13984 return resultobj;
13985 fail:
13986 return NULL;
13987 }
13988
13989
13990 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13991 PyObject *resultobj = 0;
13992 wxString *arg1 = 0 ;
13993 bool temp1 = false ;
13994 PyObject * obj0 = 0 ;
13995 char * kwnames[] = {
13996 (char *) "filename", NULL
13997 };
13998
13999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14000 {
14001 arg1 = wxString_in_helper(obj0);
14002 if (arg1 == NULL) SWIG_fail;
14003 temp1 = true;
14004 }
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 return resultobj;
14017 fail:
14018 {
14019 if (temp1)
14020 delete arg1;
14021 }
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14029 wxString *arg2 = 0 ;
14030 bool result;
14031 void *argp1 = 0 ;
14032 int res1 = 0 ;
14033 bool temp2 = false ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 char * kwnames[] = {
14037 (char *) "self",(char *) "location", NULL
14038 };
14039
14040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14042 if (!SWIG_IsOK(res1)) {
14043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14044 }
14045 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14046 {
14047 arg2 = wxString_in_helper(obj1);
14048 if (arg2 == NULL) SWIG_fail;
14049 temp2 = true;
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14059 }
14060 {
14061 if (temp2)
14062 delete arg2;
14063 }
14064 return resultobj;
14065 fail:
14066 {
14067 if (temp2)
14068 delete arg2;
14069 }
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14077 wxFileSystem *arg2 = 0 ;
14078 wxString *arg3 = 0 ;
14079 wxFSFile *result = 0 ;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 void *argp2 = 0 ;
14083 int res2 = 0 ;
14084 bool temp3 = false ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 PyObject * obj2 = 0 ;
14088 char * kwnames[] = {
14089 (char *) "self",(char *) "fs",(char *) "location", NULL
14090 };
14091
14092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14094 if (!SWIG_IsOK(res1)) {
14095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14096 }
14097 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14099 if (!SWIG_IsOK(res2)) {
14100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14101 }
14102 if (!argp2) {
14103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14104 }
14105 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14106 {
14107 arg3 = wxString_in_helper(obj2);
14108 if (arg3 == NULL) SWIG_fail;
14109 temp3 = true;
14110 }
14111 {
14112 PyThreadState* __tstate = wxPyBeginAllowThreads();
14113 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 {
14118 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14119 }
14120 {
14121 if (temp3)
14122 delete arg3;
14123 }
14124 return resultobj;
14125 fail:
14126 {
14127 if (temp3)
14128 delete arg3;
14129 }
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14137 wxString *arg2 = 0 ;
14138 int arg3 = (int) 0 ;
14139 wxString result;
14140 void *argp1 = 0 ;
14141 int res1 = 0 ;
14142 bool temp2 = false ;
14143 int val3 ;
14144 int ecode3 = 0 ;
14145 PyObject * obj0 = 0 ;
14146 PyObject * obj1 = 0 ;
14147 PyObject * obj2 = 0 ;
14148 char * kwnames[] = {
14149 (char *) "self",(char *) "spec",(char *) "flags", NULL
14150 };
14151
14152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14154 if (!SWIG_IsOK(res1)) {
14155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14156 }
14157 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14158 {
14159 arg2 = wxString_in_helper(obj1);
14160 if (arg2 == NULL) SWIG_fail;
14161 temp2 = true;
14162 }
14163 if (obj2) {
14164 ecode3 = SWIG_AsVal_int(obj2, &val3);
14165 if (!SWIG_IsOK(ecode3)) {
14166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14167 }
14168 arg3 = static_cast< int >(val3);
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 {
14177 #if wxUSE_UNICODE
14178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14179 #else
14180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14181 #endif
14182 }
14183 {
14184 if (temp2)
14185 delete arg2;
14186 }
14187 return resultobj;
14188 fail:
14189 {
14190 if (temp2)
14191 delete arg2;
14192 }
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14198 PyObject *resultobj = 0;
14199 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14200 wxString result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 PyObject *swig_obj[1] ;
14204
14205 if (!args) SWIG_fail;
14206 swig_obj[0] = args;
14207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14208 if (!SWIG_IsOK(res1)) {
14209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14210 }
14211 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 result = (arg1)->FindNext();
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 #if wxUSE_UNICODE
14220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14221 #else
14222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14223 #endif
14224 }
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 PyObject *obj;
14233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14234 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14235 return SWIG_Py_Void();
14236 }
14237
14238 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 return SWIG_Python_InitShadowInstance(args);
14240 }
14241
14242 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *resultobj = 0;
14244 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14245 wxString result;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 PyObject *swig_obj[1] ;
14249
14250 if (!args) SWIG_fail;
14251 swig_obj[0] = args;
14252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14253 if (!SWIG_IsOK(res1)) {
14254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14255 }
14256 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (arg1)->GetName();
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 #if wxUSE_UNICODE
14265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14266 #else
14267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14268 #endif
14269 }
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14277 PyObject *resultobj = 0;
14278 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14279 wxString result;
14280 void *argp1 = 0 ;
14281 int res1 = 0 ;
14282 PyObject *swig_obj[1] ;
14283
14284 if (!args) SWIG_fail;
14285 swig_obj[0] = args;
14286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14287 if (!SWIG_IsOK(res1)) {
14288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14289 }
14290 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (arg1)->GetExtension();
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 {
14298 #if wxUSE_UNICODE
14299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14300 #else
14301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14302 #endif
14303 }
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14311 PyObject *resultobj = 0;
14312 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14313 long result;
14314 void *argp1 = 0 ;
14315 int res1 = 0 ;
14316 PyObject *swig_obj[1] ;
14317
14318 if (!args) SWIG_fail;
14319 swig_obj[0] = args;
14320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14321 if (!SWIG_IsOK(res1)) {
14322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14323 }
14324 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (long)(arg1)->GetType();
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_From_long(static_cast< long >(result));
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14339 PyObject *resultobj = 0;
14340 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14341 wxString result;
14342 void *argp1 = 0 ;
14343 int res1 = 0 ;
14344 PyObject *swig_obj[1] ;
14345
14346 if (!args) SWIG_fail;
14347 swig_obj[0] = args;
14348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14349 if (!SWIG_IsOK(res1)) {
14350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14351 }
14352 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (arg1)->GetMimeType();
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 {
14360 #if wxUSE_UNICODE
14361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14362 #else
14363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14364 #endif
14365 }
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj = 0;
14374 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14375 wxString *arg2 = 0 ;
14376 bool result;
14377 void *argp1 = 0 ;
14378 int res1 = 0 ;
14379 bool temp2 = false ;
14380 PyObject * obj0 = 0 ;
14381 PyObject * obj1 = 0 ;
14382 char * kwnames[] = {
14383 (char *) "self",(char *) "name", NULL
14384 };
14385
14386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14388 if (!SWIG_IsOK(res1)) {
14389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14390 }
14391 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14392 {
14393 arg2 = wxString_in_helper(obj1);
14394 if (arg2 == NULL) SWIG_fail;
14395 temp2 = true;
14396 }
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14405 }
14406 {
14407 if (temp2)
14408 delete arg2;
14409 }
14410 return resultobj;
14411 fail:
14412 {
14413 if (temp2)
14414 delete arg2;
14415 }
14416 return NULL;
14417 }
14418
14419
14420 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14421 PyObject *resultobj = 0;
14422 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14423 wxInputStream *arg2 = 0 ;
14424 bool result;
14425 void *argp1 = 0 ;
14426 int res1 = 0 ;
14427 wxPyInputStream *temp2 ;
14428 bool created2 ;
14429 PyObject * obj0 = 0 ;
14430 PyObject * obj1 = 0 ;
14431 char * kwnames[] = {
14432 (char *) "self",(char *) "stream", NULL
14433 };
14434
14435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14437 if (!SWIG_IsOK(res1)) {
14438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14439 }
14440 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14441 {
14442 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14443 arg2 = temp2->m_wxis;
14444 created2 = false;
14445 } else {
14446 PyErr_Clear(); // clear the failure of the wxPyConvert above
14447 arg2 = wxPyCBInputStream_create(obj1, false);
14448 if (arg2 == NULL) {
14449 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14450 SWIG_fail;
14451 }
14452 created2 = true;
14453 }
14454 }
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 result = (bool)(arg1)->CanRead(*arg2);
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 {
14462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14463 }
14464 {
14465 if (created2) delete arg2;
14466 }
14467 return resultobj;
14468 fail:
14469 {
14470 if (created2) delete arg2;
14471 }
14472 return NULL;
14473 }
14474
14475
14476 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj = 0;
14478 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14479 wxString *arg2 = 0 ;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 bool temp2 = false ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "name", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14495 {
14496 arg2 = wxString_in_helper(obj1);
14497 if (arg2 == NULL) SWIG_fail;
14498 temp2 = true;
14499 }
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 (arg1)->SetName((wxString const &)*arg2);
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 resultobj = SWIG_Py_Void();
14507 {
14508 if (temp2)
14509 delete arg2;
14510 }
14511 return resultobj;
14512 fail:
14513 {
14514 if (temp2)
14515 delete arg2;
14516 }
14517 return NULL;
14518 }
14519
14520
14521 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14522 PyObject *resultobj = 0;
14523 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14524 wxString *arg2 = 0 ;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 bool temp2 = false ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 char * kwnames[] = {
14531 (char *) "self",(char *) "extension", NULL
14532 };
14533
14534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14536 if (!SWIG_IsOK(res1)) {
14537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14538 }
14539 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14540 {
14541 arg2 = wxString_in_helper(obj1);
14542 if (arg2 == NULL) SWIG_fail;
14543 temp2 = true;
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 (arg1)->SetExtension((wxString const &)*arg2);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_Py_Void();
14552 {
14553 if (temp2)
14554 delete arg2;
14555 }
14556 return resultobj;
14557 fail:
14558 {
14559 if (temp2)
14560 delete arg2;
14561 }
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj = 0;
14568 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14569 long arg2 ;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 long val2 ;
14573 int ecode2 = 0 ;
14574 PyObject * obj0 = 0 ;
14575 PyObject * obj1 = 0 ;
14576 char * kwnames[] = {
14577 (char *) "self",(char *) "type", NULL
14578 };
14579
14580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14582 if (!SWIG_IsOK(res1)) {
14583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14584 }
14585 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14586 ecode2 = SWIG_AsVal_long(obj1, &val2);
14587 if (!SWIG_IsOK(ecode2)) {
14588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14589 }
14590 arg2 = static_cast< long >(val2);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 (arg1)->SetType(arg2);
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 resultobj = SWIG_Py_Void();
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj = 0;
14606 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14607 wxString *arg2 = 0 ;
14608 void *argp1 = 0 ;
14609 int res1 = 0 ;
14610 bool temp2 = false ;
14611 PyObject * obj0 = 0 ;
14612 PyObject * obj1 = 0 ;
14613 char * kwnames[] = {
14614 (char *) "self",(char *) "mimetype", NULL
14615 };
14616
14617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14621 }
14622 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14623 {
14624 arg2 = wxString_in_helper(obj1);
14625 if (arg2 == NULL) SWIG_fail;
14626 temp2 = true;
14627 }
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 (arg1)->SetMimeType((wxString const &)*arg2);
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_Py_Void();
14635 {
14636 if (temp2)
14637 delete arg2;
14638 }
14639 return resultobj;
14640 fail:
14641 {
14642 if (temp2)
14643 delete arg2;
14644 }
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14650 PyObject *obj;
14651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14652 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14653 return SWIG_Py_Void();
14654 }
14655
14656 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657 PyObject *resultobj = 0;
14658 wxPyImageHandler *result = 0 ;
14659
14660 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (wxPyImageHandler *)new wxPyImageHandler();
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj = 0;
14676 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14677 PyObject *arg2 = (PyObject *) 0 ;
14678 void *argp1 = 0 ;
14679 int res1 = 0 ;
14680 PyObject * obj0 = 0 ;
14681 PyObject * obj1 = 0 ;
14682 char * kwnames[] = {
14683 (char *) "self",(char *) "self", NULL
14684 };
14685
14686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14690 }
14691 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14692 arg2 = obj1;
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 (arg1)->_SetSelf(arg2);
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 resultobj = SWIG_Py_Void();
14700 return resultobj;
14701 fail:
14702 return NULL;
14703 }
14704
14705
14706 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14707 PyObject *obj;
14708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14709 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14710 return SWIG_Py_Void();
14711 }
14712
14713 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14714 return SWIG_Python_InitShadowInstance(args);
14715 }
14716
14717 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *resultobj = 0;
14719 wxImageHistogram *result = 0 ;
14720
14721 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (wxImageHistogram *)new wxImageHistogram();
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 byte arg1 ;
14738 byte arg2 ;
14739 byte arg3 ;
14740 unsigned long result;
14741 unsigned char val1 ;
14742 int ecode1 = 0 ;
14743 unsigned char val2 ;
14744 int ecode2 = 0 ;
14745 unsigned char val3 ;
14746 int ecode3 = 0 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 char * kwnames[] = {
14751 (char *) "r",(char *) "g",(char *) "b", NULL
14752 };
14753
14754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14755 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14756 if (!SWIG_IsOK(ecode1)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14758 }
14759 arg1 = static_cast< byte >(val1);
14760 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14761 if (!SWIG_IsOK(ecode2)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14763 }
14764 arg2 = static_cast< byte >(val2);
14765 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14766 if (!SWIG_IsOK(ecode3)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14768 }
14769 arg3 = static_cast< byte >(val3);
14770 {
14771 PyThreadState* __tstate = wxPyBeginAllowThreads();
14772 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14784 PyObject *resultobj = 0;
14785 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14786 byte *arg2 = (byte *) 0 ;
14787 byte *arg3 = (byte *) 0 ;
14788 byte *arg4 = (byte *) 0 ;
14789 byte arg5 = (byte) 1 ;
14790 byte arg6 = (byte) 0 ;
14791 byte arg7 = (byte) 0 ;
14792 bool result;
14793 void *argp1 = 0 ;
14794 int res1 = 0 ;
14795 byte temp2 ;
14796 int res2 = SWIG_TMPOBJ ;
14797 byte temp3 ;
14798 int res3 = SWIG_TMPOBJ ;
14799 byte temp4 ;
14800 int res4 = SWIG_TMPOBJ ;
14801 unsigned char val5 ;
14802 int ecode5 = 0 ;
14803 unsigned char val6 ;
14804 int ecode6 = 0 ;
14805 unsigned char val7 ;
14806 int ecode7 = 0 ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 PyObject * obj3 = 0 ;
14811 char * kwnames[] = {
14812 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14813 };
14814
14815 arg2 = &temp2;
14816 arg3 = &temp3;
14817 arg4 = &temp4;
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14824 if (obj1) {
14825 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14826 if (!SWIG_IsOK(ecode5)) {
14827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14828 }
14829 arg5 = static_cast< byte >(val5);
14830 }
14831 if (obj2) {
14832 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14833 if (!SWIG_IsOK(ecode6)) {
14834 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14835 }
14836 arg6 = static_cast< byte >(val6);
14837 }
14838 if (obj3) {
14839 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14840 if (!SWIG_IsOK(ecode7)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14842 }
14843 arg7 = static_cast< byte >(val7);
14844 }
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 if (SWIG_IsTmpObj(res2)) {
14855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14856 } else {
14857 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14859 }
14860 if (SWIG_IsTmpObj(res3)) {
14861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14862 } else {
14863 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14865 }
14866 if (SWIG_IsTmpObj(res4)) {
14867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14868 } else {
14869 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14871 }
14872 return resultobj;
14873 fail:
14874 return NULL;
14875 }
14876
14877
14878 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj = 0;
14880 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14881 unsigned long arg2 ;
14882 unsigned long result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 unsigned long val2 ;
14886 int ecode2 = 0 ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "self",(char *) "key", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14899 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14900 if (!SWIG_IsOK(ecode2)) {
14901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14902 }
14903 arg2 = static_cast< unsigned long >(val2);
14904 {
14905 PyThreadState* __tstate = wxPyBeginAllowThreads();
14906 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj = 0;
14919 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14920 byte arg2 ;
14921 byte arg3 ;
14922 byte arg4 ;
14923 unsigned long result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 unsigned char val2 ;
14927 int ecode2 = 0 ;
14928 unsigned char val3 ;
14929 int ecode3 = 0 ;
14930 unsigned char val4 ;
14931 int ecode4 = 0 ;
14932 PyObject * obj0 = 0 ;
14933 PyObject * obj1 = 0 ;
14934 PyObject * obj2 = 0 ;
14935 PyObject * obj3 = 0 ;
14936 char * kwnames[] = {
14937 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14938 };
14939
14940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14944 }
14945 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14946 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14947 if (!SWIG_IsOK(ecode2)) {
14948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14949 }
14950 arg2 = static_cast< byte >(val2);
14951 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14952 if (!SWIG_IsOK(ecode3)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14954 }
14955 arg3 = static_cast< byte >(val3);
14956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14957 if (!SWIG_IsOK(ecode4)) {
14958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14959 }
14960 arg4 = static_cast< byte >(val4);
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14977 wxColour *arg2 = 0 ;
14978 unsigned long result;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 wxColour temp2 ;
14982 PyObject * obj0 = 0 ;
14983 PyObject * obj1 = 0 ;
14984 char * kwnames[] = {
14985 (char *) "self",(char *) "colour", NULL
14986 };
14987
14988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14990 if (!SWIG_IsOK(res1)) {
14991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14992 }
14993 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14994 {
14995 arg2 = &temp2;
14996 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14997 }
14998 {
14999 PyThreadState* __tstate = wxPyBeginAllowThreads();
15000 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15001 wxPyEndAllowThreads(__tstate);
15002 if (PyErr_Occurred()) SWIG_fail;
15003 }
15004 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15005 return resultobj;
15006 fail:
15007 return NULL;
15008 }
15009
15010
15011 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15012 PyObject *obj;
15013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15014 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15015 return SWIG_Py_Void();
15016 }
15017
15018 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15019 return SWIG_Python_InitShadowInstance(args);
15020 }
15021
15022 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj = 0;
15024 byte arg1 = (byte) 0 ;
15025 byte arg2 = (byte) 0 ;
15026 byte arg3 = (byte) 0 ;
15027 wxImage_RGBValue *result = 0 ;
15028 unsigned char val1 ;
15029 int ecode1 = 0 ;
15030 unsigned char val2 ;
15031 int ecode2 = 0 ;
15032 unsigned char val3 ;
15033 int ecode3 = 0 ;
15034 PyObject * obj0 = 0 ;
15035 PyObject * obj1 = 0 ;
15036 PyObject * obj2 = 0 ;
15037 char * kwnames[] = {
15038 (char *) "r",(char *) "g",(char *) "b", NULL
15039 };
15040
15041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15042 if (obj0) {
15043 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15044 if (!SWIG_IsOK(ecode1)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15046 }
15047 arg1 = static_cast< byte >(val1);
15048 }
15049 if (obj1) {
15050 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15051 if (!SWIG_IsOK(ecode2)) {
15052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15053 }
15054 arg2 = static_cast< byte >(val2);
15055 }
15056 if (obj2) {
15057 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15058 if (!SWIG_IsOK(ecode3)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15060 }
15061 arg3 = static_cast< byte >(val3);
15062 }
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *resultobj = 0;
15078 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15079 byte arg2 ;
15080 void *argp1 = 0 ;
15081 int res1 = 0 ;
15082 unsigned char val2 ;
15083 int ecode2 = 0 ;
15084 PyObject *swig_obj[2] ;
15085
15086 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15088 if (!SWIG_IsOK(res1)) {
15089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15090 }
15091 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15092 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15093 if (!SWIG_IsOK(ecode2)) {
15094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15095 }
15096 arg2 = static_cast< byte >(val2);
15097 if (arg1) (arg1)->red = arg2;
15098
15099 resultobj = SWIG_Py_Void();
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15107 PyObject *resultobj = 0;
15108 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15109 byte result;
15110 void *argp1 = 0 ;
15111 int res1 = 0 ;
15112 PyObject *swig_obj[1] ;
15113
15114 if (!args) SWIG_fail;
15115 swig_obj[0] = args;
15116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15117 if (!SWIG_IsOK(res1)) {
15118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15119 }
15120 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15121 result = (byte) ((arg1)->red);
15122 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15123 return resultobj;
15124 fail:
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15130 PyObject *resultobj = 0;
15131 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15132 byte arg2 ;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 unsigned char val2 ;
15136 int ecode2 = 0 ;
15137 PyObject *swig_obj[2] ;
15138
15139 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15141 if (!SWIG_IsOK(res1)) {
15142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15143 }
15144 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15145 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15146 if (!SWIG_IsOK(ecode2)) {
15147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15148 }
15149 arg2 = static_cast< byte >(val2);
15150 if (arg1) (arg1)->green = arg2;
15151
15152 resultobj = SWIG_Py_Void();
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15162 byte result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15172 }
15173 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15174 result = (byte) ((arg1)->green);
15175 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15183 PyObject *resultobj = 0;
15184 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15185 byte arg2 ;
15186 void *argp1 = 0 ;
15187 int res1 = 0 ;
15188 unsigned char val2 ;
15189 int ecode2 = 0 ;
15190 PyObject *swig_obj[2] ;
15191
15192 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15194 if (!SWIG_IsOK(res1)) {
15195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15196 }
15197 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15198 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15199 if (!SWIG_IsOK(ecode2)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15201 }
15202 arg2 = static_cast< byte >(val2);
15203 if (arg1) (arg1)->blue = arg2;
15204
15205 resultobj = SWIG_Py_Void();
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15213 PyObject *resultobj = 0;
15214 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15215 byte result;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 PyObject *swig_obj[1] ;
15219
15220 if (!args) SWIG_fail;
15221 swig_obj[0] = args;
15222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15223 if (!SWIG_IsOK(res1)) {
15224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15225 }
15226 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15227 result = (byte) ((arg1)->blue);
15228 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15236 PyObject *obj;
15237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15238 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15239 return SWIG_Py_Void();
15240 }
15241
15242 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15243 return SWIG_Python_InitShadowInstance(args);
15244 }
15245
15246 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj = 0;
15248 double arg1 = (double) 0.0 ;
15249 double arg2 = (double) 0.0 ;
15250 double arg3 = (double) 0.0 ;
15251 wxImage_HSVValue *result = 0 ;
15252 double val1 ;
15253 int ecode1 = 0 ;
15254 double val2 ;
15255 int ecode2 = 0 ;
15256 double val3 ;
15257 int ecode3 = 0 ;
15258 PyObject * obj0 = 0 ;
15259 PyObject * obj1 = 0 ;
15260 PyObject * obj2 = 0 ;
15261 char * kwnames[] = {
15262 (char *) "h",(char *) "s",(char *) "v", NULL
15263 };
15264
15265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15266 if (obj0) {
15267 ecode1 = SWIG_AsVal_double(obj0, &val1);
15268 if (!SWIG_IsOK(ecode1)) {
15269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15270 }
15271 arg1 = static_cast< double >(val1);
15272 }
15273 if (obj1) {
15274 ecode2 = SWIG_AsVal_double(obj1, &val2);
15275 if (!SWIG_IsOK(ecode2)) {
15276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15277 }
15278 arg2 = static_cast< double >(val2);
15279 }
15280 if (obj2) {
15281 ecode3 = SWIG_AsVal_double(obj2, &val3);
15282 if (!SWIG_IsOK(ecode3)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15284 }
15285 arg3 = static_cast< double >(val3);
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15303 double arg2 ;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 double val2 ;
15307 int ecode2 = 0 ;
15308 PyObject *swig_obj[2] ;
15309
15310 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15316 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15317 if (!SWIG_IsOK(ecode2)) {
15318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15319 }
15320 arg2 = static_cast< double >(val2);
15321 if (arg1) (arg1)->hue = arg2;
15322
15323 resultobj = SWIG_Py_Void();
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *resultobj = 0;
15332 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15333 double result;
15334 void *argp1 = 0 ;
15335 int res1 = 0 ;
15336 PyObject *swig_obj[1] ;
15337
15338 if (!args) SWIG_fail;
15339 swig_obj[0] = args;
15340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15341 if (!SWIG_IsOK(res1)) {
15342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15343 }
15344 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15345 result = (double) ((arg1)->hue);
15346 resultobj = SWIG_From_double(static_cast< double >(result));
15347 return resultobj;
15348 fail:
15349 return NULL;
15350 }
15351
15352
15353 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15354 PyObject *resultobj = 0;
15355 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15356 double arg2 ;
15357 void *argp1 = 0 ;
15358 int res1 = 0 ;
15359 double val2 ;
15360 int ecode2 = 0 ;
15361 PyObject *swig_obj[2] ;
15362
15363 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15367 }
15368 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15369 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15370 if (!SWIG_IsOK(ecode2)) {
15371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15372 }
15373 arg2 = static_cast< double >(val2);
15374 if (arg1) (arg1)->saturation = arg2;
15375
15376 resultobj = SWIG_Py_Void();
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15386 double result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15398 result = (double) ((arg1)->saturation);
15399 resultobj = SWIG_From_double(static_cast< double >(result));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15407 PyObject *resultobj = 0;
15408 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15409 double arg2 ;
15410 void *argp1 = 0 ;
15411 int res1 = 0 ;
15412 double val2 ;
15413 int ecode2 = 0 ;
15414 PyObject *swig_obj[2] ;
15415
15416 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15418 if (!SWIG_IsOK(res1)) {
15419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15420 }
15421 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15422 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15423 if (!SWIG_IsOK(ecode2)) {
15424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15425 }
15426 arg2 = static_cast< double >(val2);
15427 if (arg1) (arg1)->value = arg2;
15428
15429 resultobj = SWIG_Py_Void();
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15439 double result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15451 result = (double) ((arg1)->value);
15452 resultobj = SWIG_From_double(static_cast< double >(result));
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *obj;
15461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15462 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15463 return SWIG_Py_Void();
15464 }
15465
15466 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15467 return SWIG_Python_InitShadowInstance(args);
15468 }
15469
15470 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj = 0;
15472 wxString *arg1 = 0 ;
15473 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15474 int arg3 = (int) -1 ;
15475 wxImage *result = 0 ;
15476 bool temp1 = false ;
15477 long val2 ;
15478 int ecode2 = 0 ;
15479 int val3 ;
15480 int ecode3 = 0 ;
15481 PyObject * obj0 = 0 ;
15482 PyObject * obj1 = 0 ;
15483 PyObject * obj2 = 0 ;
15484 char * kwnames[] = {
15485 (char *) "name",(char *) "type",(char *) "index", NULL
15486 };
15487
15488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15489 {
15490 arg1 = wxString_in_helper(obj0);
15491 if (arg1 == NULL) SWIG_fail;
15492 temp1 = true;
15493 }
15494 if (obj1) {
15495 ecode2 = SWIG_AsVal_long(obj1, &val2);
15496 if (!SWIG_IsOK(ecode2)) {
15497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15498 }
15499 arg2 = static_cast< long >(val2);
15500 }
15501 if (obj2) {
15502 ecode3 = SWIG_AsVal_int(obj2, &val3);
15503 if (!SWIG_IsOK(ecode3)) {
15504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15505 }
15506 arg3 = static_cast< int >(val3);
15507 }
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15515 {
15516 if (temp1)
15517 delete arg1;
15518 }
15519 return resultobj;
15520 fail:
15521 {
15522 if (temp1)
15523 delete arg1;
15524 }
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15530 PyObject *resultobj = 0;
15531 wxImage *arg1 = (wxImage *) 0 ;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 PyObject *swig_obj[1] ;
15535
15536 if (!args) SWIG_fail;
15537 swig_obj[0] = args;
15538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15541 }
15542 arg1 = reinterpret_cast< wxImage * >(argp1);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 delete arg1;
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = SWIG_Py_Void();
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj = 0;
15559 wxString *arg1 = 0 ;
15560 wxString *arg2 = 0 ;
15561 int arg3 = (int) -1 ;
15562 wxImage *result = 0 ;
15563 bool temp1 = false ;
15564 bool temp2 = false ;
15565 int val3 ;
15566 int ecode3 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 PyObject * obj2 = 0 ;
15570 char * kwnames[] = {
15571 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15572 };
15573
15574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15575 {
15576 arg1 = wxString_in_helper(obj0);
15577 if (arg1 == NULL) SWIG_fail;
15578 temp1 = true;
15579 }
15580 {
15581 arg2 = wxString_in_helper(obj1);
15582 if (arg2 == NULL) SWIG_fail;
15583 temp2 = true;
15584 }
15585 if (obj2) {
15586 ecode3 = SWIG_AsVal_int(obj2, &val3);
15587 if (!SWIG_IsOK(ecode3)) {
15588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15589 }
15590 arg3 = static_cast< int >(val3);
15591 }
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15599 {
15600 if (temp1)
15601 delete arg1;
15602 }
15603 {
15604 if (temp2)
15605 delete arg2;
15606 }
15607 return resultobj;
15608 fail:
15609 {
15610 if (temp1)
15611 delete arg1;
15612 }
15613 {
15614 if (temp2)
15615 delete arg2;
15616 }
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj = 0;
15623 wxInputStream *arg1 = 0 ;
15624 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15625 int arg3 = (int) -1 ;
15626 wxImage *result = 0 ;
15627 wxPyInputStream *temp1 ;
15628 bool created1 ;
15629 long val2 ;
15630 int ecode2 = 0 ;
15631 int val3 ;
15632 int ecode3 = 0 ;
15633 PyObject * obj0 = 0 ;
15634 PyObject * obj1 = 0 ;
15635 PyObject * obj2 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "stream",(char *) "type",(char *) "index", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15641 {
15642 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15643 arg1 = temp1->m_wxis;
15644 created1 = false;
15645 } else {
15646 PyErr_Clear(); // clear the failure of the wxPyConvert above
15647 arg1 = wxPyCBInputStream_create(obj0, false);
15648 if (arg1 == NULL) {
15649 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15650 SWIG_fail;
15651 }
15652 created1 = true;
15653 }
15654 }
15655 if (obj1) {
15656 ecode2 = SWIG_AsVal_long(obj1, &val2);
15657 if (!SWIG_IsOK(ecode2)) {
15658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15659 }
15660 arg2 = static_cast< long >(val2);
15661 }
15662 if (obj2) {
15663 ecode3 = SWIG_AsVal_int(obj2, &val3);
15664 if (!SWIG_IsOK(ecode3)) {
15665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15666 }
15667 arg3 = static_cast< int >(val3);
15668 }
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15676 {
15677 if (created1) delete arg1;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (created1) delete arg1;
15683 }
15684 return NULL;
15685 }
15686
15687
15688 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15689 PyObject *resultobj = 0;
15690 wxInputStream *arg1 = 0 ;
15691 wxString *arg2 = 0 ;
15692 int arg3 = (int) -1 ;
15693 wxImage *result = 0 ;
15694 wxPyInputStream *temp1 ;
15695 bool created1 ;
15696 bool temp2 = false ;
15697 int val3 ;
15698 int ecode3 = 0 ;
15699 PyObject * obj0 = 0 ;
15700 PyObject * obj1 = 0 ;
15701 PyObject * obj2 = 0 ;
15702 char * kwnames[] = {
15703 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15704 };
15705
15706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15707 {
15708 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15709 arg1 = temp1->m_wxis;
15710 created1 = false;
15711 } else {
15712 PyErr_Clear(); // clear the failure of the wxPyConvert above
15713 arg1 = wxPyCBInputStream_create(obj0, false);
15714 if (arg1 == NULL) {
15715 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15716 SWIG_fail;
15717 }
15718 created1 = true;
15719 }
15720 }
15721 {
15722 arg2 = wxString_in_helper(obj1);
15723 if (arg2 == NULL) SWIG_fail;
15724 temp2 = true;
15725 }
15726 if (obj2) {
15727 ecode3 = SWIG_AsVal_int(obj2, &val3);
15728 if (!SWIG_IsOK(ecode3)) {
15729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15730 }
15731 arg3 = static_cast< int >(val3);
15732 }
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15740 {
15741 if (created1) delete arg1;
15742 }
15743 {
15744 if (temp2)
15745 delete arg2;
15746 }
15747 return resultobj;
15748 fail:
15749 {
15750 if (created1) delete arg1;
15751 }
15752 {
15753 if (temp2)
15754 delete arg2;
15755 }
15756 return NULL;
15757 }
15758
15759
15760 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15761 PyObject *resultobj = 0;
15762 int arg1 = (int) 0 ;
15763 int arg2 = (int) 0 ;
15764 bool arg3 = (bool) true ;
15765 wxImage *result = 0 ;
15766 int val1 ;
15767 int ecode1 = 0 ;
15768 int val2 ;
15769 int ecode2 = 0 ;
15770 bool val3 ;
15771 int ecode3 = 0 ;
15772 PyObject * obj0 = 0 ;
15773 PyObject * obj1 = 0 ;
15774 PyObject * obj2 = 0 ;
15775 char * kwnames[] = {
15776 (char *) "width",(char *) "height",(char *) "clear", NULL
15777 };
15778
15779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15780 if (obj0) {
15781 ecode1 = SWIG_AsVal_int(obj0, &val1);
15782 if (!SWIG_IsOK(ecode1)) {
15783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15784 }
15785 arg1 = static_cast< int >(val1);
15786 }
15787 if (obj1) {
15788 ecode2 = SWIG_AsVal_int(obj1, &val2);
15789 if (!SWIG_IsOK(ecode2)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15791 }
15792 arg2 = static_cast< int >(val2);
15793 }
15794 if (obj2) {
15795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15796 if (!SWIG_IsOK(ecode3)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15798 }
15799 arg3 = static_cast< bool >(val3);
15800 }
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj = 0;
15816 wxBitmap *arg1 = 0 ;
15817 wxImage *result = 0 ;
15818 void *argp1 = 0 ;
15819 int res1 = 0 ;
15820 PyObject * obj0 = 0 ;
15821 char * kwnames[] = {
15822 (char *) "bitmap", NULL
15823 };
15824
15825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15826 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15827 if (!SWIG_IsOK(res1)) {
15828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15829 }
15830 if (!argp1) {
15831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15832 }
15833 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15834 {
15835 if (!wxPyCheckForApp()) SWIG_fail;
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 int arg1 ;
15851 int arg2 ;
15852 buffer arg3 ;
15853 int arg4 ;
15854 wxImage *result = 0 ;
15855 int val1 ;
15856 int ecode1 = 0 ;
15857 int val2 ;
15858 int ecode2 = 0 ;
15859 Py_ssize_t temp3 ;
15860 PyObject * obj0 = 0 ;
15861 PyObject * obj1 = 0 ;
15862 PyObject * obj2 = 0 ;
15863 char * kwnames[] = {
15864 (char *) "width",(char *) "height",(char *) "data", NULL
15865 };
15866
15867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15868 ecode1 = SWIG_AsVal_int(obj0, &val1);
15869 if (!SWIG_IsOK(ecode1)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15871 }
15872 arg1 = static_cast< int >(val1);
15873 ecode2 = SWIG_AsVal_int(obj1, &val2);
15874 if (!SWIG_IsOK(ecode2)) {
15875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15876 }
15877 arg2 = static_cast< int >(val2);
15878 {
15879 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15880 arg4 = (int)temp3;
15881 }
15882 {
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj = 0;
15897 int arg1 ;
15898 int arg2 ;
15899 buffer arg3 ;
15900 int arg4 ;
15901 buffer arg5 ;
15902 int arg6 ;
15903 wxImage *result = 0 ;
15904 int val1 ;
15905 int ecode1 = 0 ;
15906 int val2 ;
15907 int ecode2 = 0 ;
15908 Py_ssize_t temp3 ;
15909 Py_ssize_t temp5 ;
15910 PyObject * obj0 = 0 ;
15911 PyObject * obj1 = 0 ;
15912 PyObject * obj2 = 0 ;
15913 PyObject * obj3 = 0 ;
15914 char * kwnames[] = {
15915 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15916 };
15917
15918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15919 ecode1 = SWIG_AsVal_int(obj0, &val1);
15920 if (!SWIG_IsOK(ecode1)) {
15921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15922 }
15923 arg1 = static_cast< int >(val1);
15924 ecode2 = SWIG_AsVal_int(obj1, &val2);
15925 if (!SWIG_IsOK(ecode2)) {
15926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15927 }
15928 arg2 = static_cast< int >(val2);
15929 {
15930 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15931 arg4 = (int)temp3;
15932 }
15933 {
15934 if (obj3 != Py_None) {
15935 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15936 arg6 = (int)temp5;
15937 }
15938 }
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj = 0;
15954 wxImage *arg1 = (wxImage *) 0 ;
15955 int arg2 ;
15956 int arg3 ;
15957 bool arg4 = (bool) true ;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 int val2 ;
15961 int ecode2 = 0 ;
15962 int val3 ;
15963 int ecode3 = 0 ;
15964 bool val4 ;
15965 int ecode4 = 0 ;
15966 PyObject * obj0 = 0 ;
15967 PyObject * obj1 = 0 ;
15968 PyObject * obj2 = 0 ;
15969 PyObject * obj3 = 0 ;
15970 char * kwnames[] = {
15971 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15972 };
15973
15974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15976 if (!SWIG_IsOK(res1)) {
15977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15978 }
15979 arg1 = reinterpret_cast< wxImage * >(argp1);
15980 ecode2 = SWIG_AsVal_int(obj1, &val2);
15981 if (!SWIG_IsOK(ecode2)) {
15982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15983 }
15984 arg2 = static_cast< int >(val2);
15985 ecode3 = SWIG_AsVal_int(obj2, &val3);
15986 if (!SWIG_IsOK(ecode3)) {
15987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15988 }
15989 arg3 = static_cast< int >(val3);
15990 if (obj3) {
15991 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15992 if (!SWIG_IsOK(ecode4)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15994 }
15995 arg4 = static_cast< bool >(val4);
15996 }
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->Create(arg2,arg3,arg4);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16011 PyObject *resultobj = 0;
16012 wxImage *arg1 = (wxImage *) 0 ;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16022 }
16023 arg1 = reinterpret_cast< wxImage * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 (arg1)->Destroy();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_Py_Void();
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj = 0;
16039 wxImage *arg1 = (wxImage *) 0 ;
16040 int arg2 ;
16041 int arg3 ;
16042 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16043 SwigValueWrapper<wxImage > result;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 int val2 ;
16047 int ecode2 = 0 ;
16048 int val3 ;
16049 int ecode3 = 0 ;
16050 int val4 ;
16051 int ecode4 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 PyObject * obj2 = 0 ;
16055 PyObject * obj3 = 0 ;
16056 char * kwnames[] = {
16057 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16058 };
16059
16060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16062 if (!SWIG_IsOK(res1)) {
16063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16064 }
16065 arg1 = reinterpret_cast< wxImage * >(argp1);
16066 ecode2 = SWIG_AsVal_int(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16069 }
16070 arg2 = static_cast< int >(val2);
16071 ecode3 = SWIG_AsVal_int(obj2, &val3);
16072 if (!SWIG_IsOK(ecode3)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16074 }
16075 arg3 = static_cast< int >(val3);
16076 if (obj3) {
16077 ecode4 = SWIG_AsVal_int(obj3, &val4);
16078 if (!SWIG_IsOK(ecode4)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16080 }
16081 arg4 = static_cast< int >(val4);
16082 }
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 result = (arg1)->Scale(arg2,arg3,arg4);
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16097 PyObject *resultobj = 0;
16098 wxImage *arg1 = (wxImage *) 0 ;
16099 int arg2 ;
16100 int arg3 ;
16101 SwigValueWrapper<wxImage > result;
16102 void *argp1 = 0 ;
16103 int res1 = 0 ;
16104 int val2 ;
16105 int ecode2 = 0 ;
16106 int val3 ;
16107 int ecode3 = 0 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 PyObject * obj2 = 0 ;
16111 char * kwnames[] = {
16112 (char *) "self",(char *) "width",(char *) "height", NULL
16113 };
16114
16115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16117 if (!SWIG_IsOK(res1)) {
16118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16119 }
16120 arg1 = reinterpret_cast< wxImage * >(argp1);
16121 ecode2 = SWIG_AsVal_int(obj1, &val2);
16122 if (!SWIG_IsOK(ecode2)) {
16123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16124 }
16125 arg2 = static_cast< int >(val2);
16126 ecode3 = SWIG_AsVal_int(obj2, &val3);
16127 if (!SWIG_IsOK(ecode3)) {
16128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16129 }
16130 arg3 = static_cast< int >(val3);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16138 return resultobj;
16139 fail:
16140 return NULL;
16141 }
16142
16143
16144 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj = 0;
16146 wxImage *arg1 = (wxImage *) 0 ;
16147 int arg2 ;
16148 int arg3 ;
16149 SwigValueWrapper<wxImage > result;
16150 void *argp1 = 0 ;
16151 int res1 = 0 ;
16152 int val2 ;
16153 int ecode2 = 0 ;
16154 int val3 ;
16155 int ecode3 = 0 ;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 PyObject * obj2 = 0 ;
16159 char * kwnames[] = {
16160 (char *) "self",(char *) "width",(char *) "height", NULL
16161 };
16162
16163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16165 if (!SWIG_IsOK(res1)) {
16166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16167 }
16168 arg1 = reinterpret_cast< wxImage * >(argp1);
16169 ecode2 = SWIG_AsVal_int(obj1, &val2);
16170 if (!SWIG_IsOK(ecode2)) {
16171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16172 }
16173 arg2 = static_cast< int >(val2);
16174 ecode3 = SWIG_AsVal_int(obj2, &val3);
16175 if (!SWIG_IsOK(ecode3)) {
16176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16177 }
16178 arg3 = static_cast< int >(val3);
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj = 0;
16194 wxImage *arg1 = (wxImage *) 0 ;
16195 int arg2 ;
16196 SwigValueWrapper<wxImage > result;
16197 void *argp1 = 0 ;
16198 int res1 = 0 ;
16199 int val2 ;
16200 int ecode2 = 0 ;
16201 PyObject * obj0 = 0 ;
16202 PyObject * obj1 = 0 ;
16203 char * kwnames[] = {
16204 (char *) "self",(char *) "radius", NULL
16205 };
16206
16207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16209 if (!SWIG_IsOK(res1)) {
16210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16211 }
16212 arg1 = reinterpret_cast< wxImage * >(argp1);
16213 ecode2 = SWIG_AsVal_int(obj1, &val2);
16214 if (!SWIG_IsOK(ecode2)) {
16215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16216 }
16217 arg2 = static_cast< int >(val2);
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = (arg1)->Blur(arg2);
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 int arg2 ;
16235 SwigValueWrapper<wxImage > result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 int val2 ;
16239 int ecode2 = 0 ;
16240 PyObject * obj0 = 0 ;
16241 PyObject * obj1 = 0 ;
16242 char * kwnames[] = {
16243 (char *) "self",(char *) "radius", NULL
16244 };
16245
16246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16248 if (!SWIG_IsOK(res1)) {
16249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16250 }
16251 arg1 = reinterpret_cast< wxImage * >(argp1);
16252 ecode2 = SWIG_AsVal_int(obj1, &val2);
16253 if (!SWIG_IsOK(ecode2)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16255 }
16256 arg2 = static_cast< int >(val2);
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 result = (arg1)->BlurHorizontal(arg2);
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16264 return resultobj;
16265 fail:
16266 return NULL;
16267 }
16268
16269
16270 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16271 PyObject *resultobj = 0;
16272 wxImage *arg1 = (wxImage *) 0 ;
16273 int arg2 ;
16274 SwigValueWrapper<wxImage > result;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 int val2 ;
16278 int ecode2 = 0 ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 char * kwnames[] = {
16282 (char *) "self",(char *) "radius", NULL
16283 };
16284
16285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16289 }
16290 arg1 = reinterpret_cast< wxImage * >(argp1);
16291 ecode2 = SWIG_AsVal_int(obj1, &val2);
16292 if (!SWIG_IsOK(ecode2)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16294 }
16295 arg2 = static_cast< int >(val2);
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (arg1)->BlurVertical(arg2);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = 0;
16311 wxImage *arg1 = (wxImage *) 0 ;
16312 int arg2 ;
16313 int arg3 ;
16314 SwigValueWrapper<wxImage > result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 int val2 ;
16318 int ecode2 = 0 ;
16319 int val3 ;
16320 int ecode3 = 0 ;
16321 PyObject * obj0 = 0 ;
16322 PyObject * obj1 = 0 ;
16323 PyObject * obj2 = 0 ;
16324 char * kwnames[] = {
16325 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16326 };
16327
16328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16330 if (!SWIG_IsOK(res1)) {
16331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16332 }
16333 arg1 = reinterpret_cast< wxImage * >(argp1);
16334 ecode2 = SWIG_AsVal_int(obj1, &val2);
16335 if (!SWIG_IsOK(ecode2)) {
16336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16337 }
16338 arg2 = static_cast< int >(val2);
16339 ecode3 = SWIG_AsVal_int(obj2, &val3);
16340 if (!SWIG_IsOK(ecode3)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16342 }
16343 arg3 = static_cast< int >(val3);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 int arg2 ;
16361 int arg3 ;
16362 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16363 wxImage *result = 0 ;
16364 void *argp1 = 0 ;
16365 int res1 = 0 ;
16366 int val2 ;
16367 int ecode2 = 0 ;
16368 int val3 ;
16369 int ecode3 = 0 ;
16370 int val4 ;
16371 int ecode4 = 0 ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 PyObject * obj3 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16384 }
16385 arg1 = reinterpret_cast< wxImage * >(argp1);
16386 ecode2 = SWIG_AsVal_int(obj1, &val2);
16387 if (!SWIG_IsOK(ecode2)) {
16388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16389 }
16390 arg2 = static_cast< int >(val2);
16391 ecode3 = SWIG_AsVal_int(obj2, &val3);
16392 if (!SWIG_IsOK(ecode3)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16394 }
16395 arg3 = static_cast< int >(val3);
16396 if (obj3) {
16397 ecode4 = SWIG_AsVal_int(obj3, &val4);
16398 if (!SWIG_IsOK(ecode4)) {
16399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16400 }
16401 arg4 = static_cast< int >(val4);
16402 }
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 {
16406 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16407 result = (wxImage *) &_result_ref;
16408 }
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxImage *arg1 = (wxImage *) 0 ;
16422 wxSize *arg2 = 0 ;
16423 wxPoint *arg3 = 0 ;
16424 int arg4 = (int) -1 ;
16425 int arg5 = (int) -1 ;
16426 int arg6 = (int) -1 ;
16427 wxImage *result = 0 ;
16428 void *argp1 = 0 ;
16429 int res1 = 0 ;
16430 wxSize temp2 ;
16431 wxPoint temp3 ;
16432 int val4 ;
16433 int ecode4 = 0 ;
16434 int val5 ;
16435 int ecode5 = 0 ;
16436 int val6 ;
16437 int ecode6 = 0 ;
16438 PyObject * obj0 = 0 ;
16439 PyObject * obj1 = 0 ;
16440 PyObject * obj2 = 0 ;
16441 PyObject * obj3 = 0 ;
16442 PyObject * obj4 = 0 ;
16443 PyObject * obj5 = 0 ;
16444 char * kwnames[] = {
16445 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16446 };
16447
16448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16450 if (!SWIG_IsOK(res1)) {
16451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16452 }
16453 arg1 = reinterpret_cast< wxImage * >(argp1);
16454 {
16455 arg2 = &temp2;
16456 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16457 }
16458 {
16459 arg3 = &temp3;
16460 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16461 }
16462 if (obj3) {
16463 ecode4 = SWIG_AsVal_int(obj3, &val4);
16464 if (!SWIG_IsOK(ecode4)) {
16465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16466 }
16467 arg4 = static_cast< int >(val4);
16468 }
16469 if (obj4) {
16470 ecode5 = SWIG_AsVal_int(obj4, &val5);
16471 if (!SWIG_IsOK(ecode5)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16473 }
16474 arg5 = static_cast< int >(val5);
16475 }
16476 if (obj5) {
16477 ecode6 = SWIG_AsVal_int(obj5, &val6);
16478 if (!SWIG_IsOK(ecode6)) {
16479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16480 }
16481 arg6 = static_cast< int >(val6);
16482 }
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 {
16486 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16487 result = (wxImage *) &_result_ref;
16488 }
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16493 return resultobj;
16494 fail:
16495 return NULL;
16496 }
16497
16498
16499 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16500 PyObject *resultobj = 0;
16501 wxImage *arg1 = (wxImage *) 0 ;
16502 int arg2 ;
16503 int arg3 ;
16504 byte arg4 ;
16505 byte arg5 ;
16506 byte arg6 ;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 int val2 ;
16510 int ecode2 = 0 ;
16511 int val3 ;
16512 int ecode3 = 0 ;
16513 unsigned char val4 ;
16514 int ecode4 = 0 ;
16515 unsigned char val5 ;
16516 int ecode5 = 0 ;
16517 unsigned char val6 ;
16518 int ecode6 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 PyObject * obj1 = 0 ;
16521 PyObject * obj2 = 0 ;
16522 PyObject * obj3 = 0 ;
16523 PyObject * obj4 = 0 ;
16524 PyObject * obj5 = 0 ;
16525 char * kwnames[] = {
16526 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16527 };
16528
16529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16531 if (!SWIG_IsOK(res1)) {
16532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16533 }
16534 arg1 = reinterpret_cast< wxImage * >(argp1);
16535 ecode2 = SWIG_AsVal_int(obj1, &val2);
16536 if (!SWIG_IsOK(ecode2)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16538 }
16539 arg2 = static_cast< int >(val2);
16540 ecode3 = SWIG_AsVal_int(obj2, &val3);
16541 if (!SWIG_IsOK(ecode3)) {
16542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16543 }
16544 arg3 = static_cast< int >(val3);
16545 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16546 if (!SWIG_IsOK(ecode4)) {
16547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16548 }
16549 arg4 = static_cast< byte >(val4);
16550 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16551 if (!SWIG_IsOK(ecode5)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16553 }
16554 arg5 = static_cast< byte >(val5);
16555 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16556 if (!SWIG_IsOK(ecode6)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16558 }
16559 arg6 = static_cast< byte >(val6);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_Py_Void();
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxRect *arg2 = 0 ;
16577 byte arg3 ;
16578 byte arg4 ;
16579 byte arg5 ;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 wxRect temp2 ;
16583 unsigned char val3 ;
16584 int ecode3 = 0 ;
16585 unsigned char val4 ;
16586 int ecode4 = 0 ;
16587 unsigned char val5 ;
16588 int ecode5 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 PyObject * obj4 = 0 ;
16594 char * kwnames[] = {
16595 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16596 };
16597
16598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16602 }
16603 arg1 = reinterpret_cast< wxImage * >(argp1);
16604 {
16605 arg2 = &temp2;
16606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16607 }
16608 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16611 }
16612 arg3 = static_cast< byte >(val3);
16613 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16614 if (!SWIG_IsOK(ecode4)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16616 }
16617 arg4 = static_cast< byte >(val4);
16618 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16619 if (!SWIG_IsOK(ecode5)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16621 }
16622 arg5 = static_cast< byte >(val5);
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 resultobj = SWIG_Py_Void();
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj = 0;
16638 wxImage *arg1 = (wxImage *) 0 ;
16639 int arg2 ;
16640 int arg3 ;
16641 byte result;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 int val2 ;
16645 int ecode2 = 0 ;
16646 int val3 ;
16647 int ecode3 = 0 ;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 PyObject * obj2 = 0 ;
16651 char * kwnames[] = {
16652 (char *) "self",(char *) "x",(char *) "y", NULL
16653 };
16654
16655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16659 }
16660 arg1 = reinterpret_cast< wxImage * >(argp1);
16661 ecode2 = SWIG_AsVal_int(obj1, &val2);
16662 if (!SWIG_IsOK(ecode2)) {
16663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16664 }
16665 arg2 = static_cast< int >(val2);
16666 ecode3 = SWIG_AsVal_int(obj2, &val3);
16667 if (!SWIG_IsOK(ecode3)) {
16668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16669 }
16670 arg3 = static_cast< int >(val3);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (byte)(arg1)->GetRed(arg2,arg3);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxImage *arg1 = (wxImage *) 0 ;
16687 int arg2 ;
16688 int arg3 ;
16689 byte result;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 int val2 ;
16693 int ecode2 = 0 ;
16694 int val3 ;
16695 int ecode3 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 char * kwnames[] = {
16700 (char *) "self",(char *) "x",(char *) "y", NULL
16701 };
16702
16703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16707 }
16708 arg1 = reinterpret_cast< wxImage * >(argp1);
16709 ecode2 = SWIG_AsVal_int(obj1, &val2);
16710 if (!SWIG_IsOK(ecode2)) {
16711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16712 }
16713 arg2 = static_cast< int >(val2);
16714 ecode3 = SWIG_AsVal_int(obj2, &val3);
16715 if (!SWIG_IsOK(ecode3)) {
16716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16717 }
16718 arg3 = static_cast< int >(val3);
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (byte)(arg1)->GetGreen(arg2,arg3);
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16726 return resultobj;
16727 fail:
16728 return NULL;
16729 }
16730
16731
16732 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = 0;
16734 wxImage *arg1 = (wxImage *) 0 ;
16735 int arg2 ;
16736 int arg3 ;
16737 byte result;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 int val2 ;
16741 int ecode2 = 0 ;
16742 int val3 ;
16743 int ecode3 = 0 ;
16744 PyObject * obj0 = 0 ;
16745 PyObject * obj1 = 0 ;
16746 PyObject * obj2 = 0 ;
16747 char * kwnames[] = {
16748 (char *) "self",(char *) "x",(char *) "y", NULL
16749 };
16750
16751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16753 if (!SWIG_IsOK(res1)) {
16754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16755 }
16756 arg1 = reinterpret_cast< wxImage * >(argp1);
16757 ecode2 = SWIG_AsVal_int(obj1, &val2);
16758 if (!SWIG_IsOK(ecode2)) {
16759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16760 }
16761 arg2 = static_cast< int >(val2);
16762 ecode3 = SWIG_AsVal_int(obj2, &val3);
16763 if (!SWIG_IsOK(ecode3)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16765 }
16766 arg3 = static_cast< int >(val3);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (byte)(arg1)->GetBlue(arg2,arg3);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage *arg1 = (wxImage *) 0 ;
16783 int arg2 ;
16784 int arg3 ;
16785 byte arg4 ;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 int val2 ;
16789 int ecode2 = 0 ;
16790 int val3 ;
16791 int ecode3 = 0 ;
16792 unsigned char val4 ;
16793 int ecode4 = 0 ;
16794 PyObject * obj0 = 0 ;
16795 PyObject * obj1 = 0 ;
16796 PyObject * obj2 = 0 ;
16797 PyObject * obj3 = 0 ;
16798 char * kwnames[] = {
16799 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16800 };
16801
16802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16806 }
16807 arg1 = reinterpret_cast< wxImage * >(argp1);
16808 ecode2 = SWIG_AsVal_int(obj1, &val2);
16809 if (!SWIG_IsOK(ecode2)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16811 }
16812 arg2 = static_cast< int >(val2);
16813 ecode3 = SWIG_AsVal_int(obj2, &val3);
16814 if (!SWIG_IsOK(ecode3)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16816 }
16817 arg3 = static_cast< int >(val3);
16818 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16819 if (!SWIG_IsOK(ecode4)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16821 }
16822 arg4 = static_cast< byte >(val4);
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 (arg1)->SetAlpha(arg2,arg3,arg4);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_Py_Void();
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxImage *arg1 = (wxImage *) 0 ;
16839 int arg2 ;
16840 int arg3 ;
16841 byte result;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 int val2 ;
16845 int ecode2 = 0 ;
16846 int val3 ;
16847 int ecode3 = 0 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 PyObject * obj2 = 0 ;
16851 char * kwnames[] = {
16852 (char *) "self",(char *) "x",(char *) "y", NULL
16853 };
16854
16855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16857 if (!SWIG_IsOK(res1)) {
16858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16859 }
16860 arg1 = reinterpret_cast< wxImage * >(argp1);
16861 ecode2 = SWIG_AsVal_int(obj1, &val2);
16862 if (!SWIG_IsOK(ecode2)) {
16863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16864 }
16865 arg2 = static_cast< int >(val2);
16866 ecode3 = SWIG_AsVal_int(obj2, &val3);
16867 if (!SWIG_IsOK(ecode3)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16869 }
16870 arg3 = static_cast< int >(val3);
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16885 PyObject *resultobj = 0;
16886 wxImage *arg1 = (wxImage *) 0 ;
16887 bool result;
16888 void *argp1 = 0 ;
16889 int res1 = 0 ;
16890 PyObject *swig_obj[1] ;
16891
16892 if (!args) SWIG_fail;
16893 swig_obj[0] = args;
16894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16897 }
16898 arg1 = reinterpret_cast< wxImage * >(argp1);
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (bool)(arg1)->HasAlpha();
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16907 }
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16915 PyObject *resultobj = 0;
16916 wxImage *arg1 = (wxImage *) 0 ;
16917 void *argp1 = 0 ;
16918 int res1 = 0 ;
16919 PyObject *swig_obj[1] ;
16920
16921 if (!args) SWIG_fail;
16922 swig_obj[0] = args;
16923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16924 if (!SWIG_IsOK(res1)) {
16925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16926 }
16927 arg1 = reinterpret_cast< wxImage * >(argp1);
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 (arg1)->InitAlpha();
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 resultobj = SWIG_Py_Void();
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj = 0;
16943 wxImage *arg1 = (wxImage *) 0 ;
16944 int arg2 ;
16945 int arg3 ;
16946 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16947 bool result;
16948 void *argp1 = 0 ;
16949 int res1 = 0 ;
16950 int val2 ;
16951 int ecode2 = 0 ;
16952 int val3 ;
16953 int ecode3 = 0 ;
16954 unsigned char val4 ;
16955 int ecode4 = 0 ;
16956 PyObject * obj0 = 0 ;
16957 PyObject * obj1 = 0 ;
16958 PyObject * obj2 = 0 ;
16959 PyObject * obj3 = 0 ;
16960 char * kwnames[] = {
16961 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16962 };
16963
16964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16968 }
16969 arg1 = reinterpret_cast< wxImage * >(argp1);
16970 ecode2 = SWIG_AsVal_int(obj1, &val2);
16971 if (!SWIG_IsOK(ecode2)) {
16972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16973 }
16974 arg2 = static_cast< int >(val2);
16975 ecode3 = SWIG_AsVal_int(obj2, &val3);
16976 if (!SWIG_IsOK(ecode3)) {
16977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16978 }
16979 arg3 = static_cast< int >(val3);
16980 if (obj3) {
16981 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16982 if (!SWIG_IsOK(ecode4)) {
16983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16984 }
16985 arg4 = static_cast< byte >(val4);
16986 }
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxImage *arg1 = (wxImage *) 0 ;
17005 byte *arg2 = (byte *) 0 ;
17006 byte *arg3 = (byte *) 0 ;
17007 byte *arg4 = (byte *) 0 ;
17008 byte arg5 = (byte) 0 ;
17009 byte arg6 = (byte) 0 ;
17010 byte arg7 = (byte) 0 ;
17011 bool result;
17012 void *argp1 = 0 ;
17013 int res1 = 0 ;
17014 byte temp2 ;
17015 int res2 = SWIG_TMPOBJ ;
17016 byte temp3 ;
17017 int res3 = SWIG_TMPOBJ ;
17018 byte temp4 ;
17019 int res4 = SWIG_TMPOBJ ;
17020 unsigned char val5 ;
17021 int ecode5 = 0 ;
17022 unsigned char val6 ;
17023 int ecode6 = 0 ;
17024 unsigned char val7 ;
17025 int ecode7 = 0 ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 PyObject * obj2 = 0 ;
17029 PyObject * obj3 = 0 ;
17030 char * kwnames[] = {
17031 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17032 };
17033
17034 arg2 = &temp2;
17035 arg3 = &temp3;
17036 arg4 = &temp4;
17037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17039 if (!SWIG_IsOK(res1)) {
17040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17041 }
17042 arg1 = reinterpret_cast< wxImage * >(argp1);
17043 if (obj1) {
17044 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17045 if (!SWIG_IsOK(ecode5)) {
17046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17047 }
17048 arg5 = static_cast< byte >(val5);
17049 }
17050 if (obj2) {
17051 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17052 if (!SWIG_IsOK(ecode6)) {
17053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17054 }
17055 arg6 = static_cast< byte >(val6);
17056 }
17057 if (obj3) {
17058 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17059 if (!SWIG_IsOK(ecode7)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17061 }
17062 arg7 = static_cast< byte >(val7);
17063 }
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 {
17071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17072 }
17073 if (SWIG_IsTmpObj(res2)) {
17074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17075 } else {
17076 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17078 }
17079 if (SWIG_IsTmpObj(res3)) {
17080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17081 } else {
17082 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17084 }
17085 if (SWIG_IsTmpObj(res4)) {
17086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17087 } else {
17088 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17090 }
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj = 0;
17099 wxImage *arg1 = (wxImage *) 0 ;
17100 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17101 bool result;
17102 void *argp1 = 0 ;
17103 int res1 = 0 ;
17104 unsigned char val2 ;
17105 int ecode2 = 0 ;
17106 PyObject * obj0 = 0 ;
17107 PyObject * obj1 = 0 ;
17108 char * kwnames[] = {
17109 (char *) "self",(char *) "threshold", NULL
17110 };
17111
17112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17114 if (!SWIG_IsOK(res1)) {
17115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17116 }
17117 arg1 = reinterpret_cast< wxImage * >(argp1);
17118 if (obj1) {
17119 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17120 if (!SWIG_IsOK(ecode2)) {
17121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17122 }
17123 arg2 = static_cast< byte >(val2);
17124 }
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 {
17132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17133 }
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj = 0;
17142 wxImage *arg1 = (wxImage *) 0 ;
17143 byte arg2 ;
17144 byte arg3 ;
17145 byte arg4 ;
17146 bool result;
17147 void *argp1 = 0 ;
17148 int res1 = 0 ;
17149 unsigned char val2 ;
17150 int ecode2 = 0 ;
17151 unsigned char val3 ;
17152 int ecode3 = 0 ;
17153 unsigned char val4 ;
17154 int ecode4 = 0 ;
17155 PyObject * obj0 = 0 ;
17156 PyObject * obj1 = 0 ;
17157 PyObject * obj2 = 0 ;
17158 PyObject * obj3 = 0 ;
17159 char * kwnames[] = {
17160 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17161 };
17162
17163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17165 if (!SWIG_IsOK(res1)) {
17166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17167 }
17168 arg1 = reinterpret_cast< wxImage * >(argp1);
17169 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17170 if (!SWIG_IsOK(ecode2)) {
17171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17172 }
17173 arg2 = static_cast< byte >(val2);
17174 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17175 if (!SWIG_IsOK(ecode3)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17177 }
17178 arg3 = static_cast< byte >(val3);
17179 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17180 if (!SWIG_IsOK(ecode4)) {
17181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17182 }
17183 arg4 = static_cast< byte >(val4);
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 {
17191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17192 }
17193 return resultobj;
17194 fail:
17195 return NULL;
17196 }
17197
17198
17199 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17200 PyObject *resultobj = 0;
17201 wxImage *arg1 = (wxImage *) 0 ;
17202 wxImage *arg2 = 0 ;
17203 byte arg3 ;
17204 byte arg4 ;
17205 byte arg5 ;
17206 bool result;
17207 void *argp1 = 0 ;
17208 int res1 = 0 ;
17209 void *argp2 = 0 ;
17210 int res2 = 0 ;
17211 unsigned char val3 ;
17212 int ecode3 = 0 ;
17213 unsigned char val4 ;
17214 int ecode4 = 0 ;
17215 unsigned char val5 ;
17216 int ecode5 = 0 ;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17219 PyObject * obj2 = 0 ;
17220 PyObject * obj3 = 0 ;
17221 PyObject * obj4 = 0 ;
17222 char * kwnames[] = {
17223 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17224 };
17225
17226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17228 if (!SWIG_IsOK(res1)) {
17229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17230 }
17231 arg1 = reinterpret_cast< wxImage * >(argp1);
17232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17233 if (!SWIG_IsOK(res2)) {
17234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17235 }
17236 if (!argp2) {
17237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17238 }
17239 arg2 = reinterpret_cast< wxImage * >(argp2);
17240 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17241 if (!SWIG_IsOK(ecode3)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17243 }
17244 arg3 = static_cast< byte >(val3);
17245 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17246 if (!SWIG_IsOK(ecode4)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17248 }
17249 arg4 = static_cast< byte >(val4);
17250 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17251 if (!SWIG_IsOK(ecode5)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17253 }
17254 arg5 = static_cast< byte >(val5);
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj = 0;
17272 wxString *arg1 = 0 ;
17273 bool result;
17274 bool temp1 = false ;
17275 PyObject * obj0 = 0 ;
17276 char * kwnames[] = {
17277 (char *) "filename", NULL
17278 };
17279
17280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17281 {
17282 arg1 = wxString_in_helper(obj0);
17283 if (arg1 == NULL) SWIG_fail;
17284 temp1 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17294 }
17295 {
17296 if (temp1)
17297 delete arg1;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp1)
17303 delete arg1;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxString *arg1 = 0 ;
17312 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17313 int result;
17314 bool temp1 = false ;
17315 long val2 ;
17316 int ecode2 = 0 ;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 char * kwnames[] = {
17320 (char *) "filename",(char *) "type", NULL
17321 };
17322
17323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17324 {
17325 arg1 = wxString_in_helper(obj0);
17326 if (arg1 == NULL) SWIG_fail;
17327 temp1 = true;
17328 }
17329 if (obj1) {
17330 ecode2 = SWIG_AsVal_long(obj1, &val2);
17331 if (!SWIG_IsOK(ecode2)) {
17332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17333 }
17334 arg2 = static_cast< long >(val2);
17335 }
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_From_int(static_cast< int >(result));
17343 {
17344 if (temp1)
17345 delete arg1;
17346 }
17347 return resultobj;
17348 fail:
17349 {
17350 if (temp1)
17351 delete arg1;
17352 }
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = 0;
17359 wxImage *arg1 = (wxImage *) 0 ;
17360 wxString *arg2 = 0 ;
17361 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17362 int arg4 = (int) -1 ;
17363 bool result;
17364 void *argp1 = 0 ;
17365 int res1 = 0 ;
17366 bool temp2 = false ;
17367 long val3 ;
17368 int ecode3 = 0 ;
17369 int val4 ;
17370 int ecode4 = 0 ;
17371 PyObject * obj0 = 0 ;
17372 PyObject * obj1 = 0 ;
17373 PyObject * obj2 = 0 ;
17374 PyObject * obj3 = 0 ;
17375 char * kwnames[] = {
17376 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17377 };
17378
17379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17381 if (!SWIG_IsOK(res1)) {
17382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17383 }
17384 arg1 = reinterpret_cast< wxImage * >(argp1);
17385 {
17386 arg2 = wxString_in_helper(obj1);
17387 if (arg2 == NULL) SWIG_fail;
17388 temp2 = true;
17389 }
17390 if (obj2) {
17391 ecode3 = SWIG_AsVal_long(obj2, &val3);
17392 if (!SWIG_IsOK(ecode3)) {
17393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17394 }
17395 arg3 = static_cast< long >(val3);
17396 }
17397 if (obj3) {
17398 ecode4 = SWIG_AsVal_int(obj3, &val4);
17399 if (!SWIG_IsOK(ecode4)) {
17400 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17401 }
17402 arg4 = static_cast< int >(val4);
17403 }
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17412 }
17413 {
17414 if (temp2)
17415 delete arg2;
17416 }
17417 return resultobj;
17418 fail:
17419 {
17420 if (temp2)
17421 delete arg2;
17422 }
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17428 PyObject *resultobj = 0;
17429 wxImage *arg1 = (wxImage *) 0 ;
17430 wxString *arg2 = 0 ;
17431 wxString *arg3 = 0 ;
17432 int arg4 = (int) -1 ;
17433 bool result;
17434 void *argp1 = 0 ;
17435 int res1 = 0 ;
17436 bool temp2 = false ;
17437 bool temp3 = false ;
17438 int val4 ;
17439 int ecode4 = 0 ;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 PyObject * obj2 = 0 ;
17443 PyObject * obj3 = 0 ;
17444 char * kwnames[] = {
17445 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17446 };
17447
17448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17450 if (!SWIG_IsOK(res1)) {
17451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17452 }
17453 arg1 = reinterpret_cast< wxImage * >(argp1);
17454 {
17455 arg2 = wxString_in_helper(obj1);
17456 if (arg2 == NULL) SWIG_fail;
17457 temp2 = true;
17458 }
17459 {
17460 arg3 = wxString_in_helper(obj2);
17461 if (arg3 == NULL) SWIG_fail;
17462 temp3 = true;
17463 }
17464 if (obj3) {
17465 ecode4 = SWIG_AsVal_int(obj3, &val4);
17466 if (!SWIG_IsOK(ecode4)) {
17467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17468 }
17469 arg4 = static_cast< int >(val4);
17470 }
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17479 }
17480 {
17481 if (temp2)
17482 delete arg2;
17483 }
17484 {
17485 if (temp3)
17486 delete arg3;
17487 }
17488 return resultobj;
17489 fail:
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 {
17495 if (temp3)
17496 delete arg3;
17497 }
17498 return NULL;
17499 }
17500
17501
17502 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17503 PyObject *resultobj = 0;
17504 wxImage *arg1 = (wxImage *) 0 ;
17505 wxString *arg2 = 0 ;
17506 int arg3 ;
17507 bool result;
17508 void *argp1 = 0 ;
17509 int res1 = 0 ;
17510 bool temp2 = false ;
17511 int val3 ;
17512 int ecode3 = 0 ;
17513 PyObject * obj0 = 0 ;
17514 PyObject * obj1 = 0 ;
17515 PyObject * obj2 = 0 ;
17516 char * kwnames[] = {
17517 (char *) "self",(char *) "name",(char *) "type", NULL
17518 };
17519
17520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17522 if (!SWIG_IsOK(res1)) {
17523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17524 }
17525 arg1 = reinterpret_cast< wxImage * >(argp1);
17526 {
17527 arg2 = wxString_in_helper(obj1);
17528 if (arg2 == NULL) SWIG_fail;
17529 temp2 = true;
17530 }
17531 ecode3 = SWIG_AsVal_int(obj2, &val3);
17532 if (!SWIG_IsOK(ecode3)) {
17533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17534 }
17535 arg3 = static_cast< int >(val3);
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17544 }
17545 {
17546 if (temp2)
17547 delete arg2;
17548 }
17549 return resultobj;
17550 fail:
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxImage *arg1 = (wxImage *) 0 ;
17562 wxString *arg2 = 0 ;
17563 wxString *arg3 = 0 ;
17564 bool result;
17565 void *argp1 = 0 ;
17566 int res1 = 0 ;
17567 bool temp2 = false ;
17568 bool temp3 = false ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 PyObject * obj2 = 0 ;
17572 char * kwnames[] = {
17573 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17574 };
17575
17576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17578 if (!SWIG_IsOK(res1)) {
17579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17580 }
17581 arg1 = reinterpret_cast< wxImage * >(argp1);
17582 {
17583 arg2 = wxString_in_helper(obj1);
17584 if (arg2 == NULL) SWIG_fail;
17585 temp2 = true;
17586 }
17587 {
17588 arg3 = wxString_in_helper(obj2);
17589 if (arg3 == NULL) SWIG_fail;
17590 temp3 = true;
17591 }
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 {
17599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17600 }
17601 {
17602 if (temp2)
17603 delete arg2;
17604 }
17605 {
17606 if (temp3)
17607 delete arg3;
17608 }
17609 return resultobj;
17610 fail:
17611 {
17612 if (temp2)
17613 delete arg2;
17614 }
17615 {
17616 if (temp3)
17617 delete arg3;
17618 }
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj = 0;
17625 wxInputStream *arg1 = 0 ;
17626 bool result;
17627 wxPyInputStream *temp1 ;
17628 bool created1 ;
17629 PyObject * obj0 = 0 ;
17630 char * kwnames[] = {
17631 (char *) "stream", NULL
17632 };
17633
17634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17635 {
17636 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17637 arg1 = temp1->m_wxis;
17638 created1 = false;
17639 } else {
17640 PyErr_Clear(); // clear the failure of the wxPyConvert above
17641 arg1 = wxPyCBInputStream_create(obj0, false);
17642 if (arg1 == NULL) {
17643 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17644 SWIG_fail;
17645 }
17646 created1 = true;
17647 }
17648 }
17649 {
17650 PyThreadState* __tstate = wxPyBeginAllowThreads();
17651 result = (bool)wxImage::CanRead(*arg1);
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 {
17656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17657 }
17658 {
17659 if (created1) delete arg1;
17660 }
17661 return resultobj;
17662 fail:
17663 {
17664 if (created1) delete arg1;
17665 }
17666 return NULL;
17667 }
17668
17669
17670 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17671 PyObject *resultobj = 0;
17672 wxImage *arg1 = (wxImage *) 0 ;
17673 wxInputStream *arg2 = 0 ;
17674 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17675 int arg4 = (int) -1 ;
17676 bool result;
17677 void *argp1 = 0 ;
17678 int res1 = 0 ;
17679 wxPyInputStream *temp2 ;
17680 bool created2 ;
17681 long val3 ;
17682 int ecode3 = 0 ;
17683 int val4 ;
17684 int ecode4 = 0 ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17687 PyObject * obj2 = 0 ;
17688 PyObject * obj3 = 0 ;
17689 char * kwnames[] = {
17690 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17691 };
17692
17693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17695 if (!SWIG_IsOK(res1)) {
17696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17697 }
17698 arg1 = reinterpret_cast< wxImage * >(argp1);
17699 {
17700 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17701 arg2 = temp2->m_wxis;
17702 created2 = false;
17703 } else {
17704 PyErr_Clear(); // clear the failure of the wxPyConvert above
17705 arg2 = wxPyCBInputStream_create(obj1, false);
17706 if (arg2 == NULL) {
17707 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17708 SWIG_fail;
17709 }
17710 created2 = true;
17711 }
17712 }
17713 if (obj2) {
17714 ecode3 = SWIG_AsVal_long(obj2, &val3);
17715 if (!SWIG_IsOK(ecode3)) {
17716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17717 }
17718 arg3 = static_cast< long >(val3);
17719 }
17720 if (obj3) {
17721 ecode4 = SWIG_AsVal_int(obj3, &val4);
17722 if (!SWIG_IsOK(ecode4)) {
17723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17724 }
17725 arg4 = static_cast< int >(val4);
17726 }
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 {
17734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17735 }
17736 {
17737 if (created2) delete arg2;
17738 }
17739 return resultobj;
17740 fail:
17741 {
17742 if (created2) delete arg2;
17743 }
17744 return NULL;
17745 }
17746
17747
17748 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = 0;
17750 wxImage *arg1 = (wxImage *) 0 ;
17751 wxInputStream *arg2 = 0 ;
17752 wxString *arg3 = 0 ;
17753 int arg4 = (int) -1 ;
17754 bool result;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 wxPyInputStream *temp2 ;
17758 bool created2 ;
17759 bool temp3 = false ;
17760 int val4 ;
17761 int ecode4 = 0 ;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 PyObject * obj2 = 0 ;
17765 PyObject * obj3 = 0 ;
17766 char * kwnames[] = {
17767 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17768 };
17769
17770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17774 }
17775 arg1 = reinterpret_cast< wxImage * >(argp1);
17776 {
17777 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17778 arg2 = temp2->m_wxis;
17779 created2 = false;
17780 } else {
17781 PyErr_Clear(); // clear the failure of the wxPyConvert above
17782 arg2 = wxPyCBInputStream_create(obj1, false);
17783 if (arg2 == NULL) {
17784 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17785 SWIG_fail;
17786 }
17787 created2 = true;
17788 }
17789 }
17790 {
17791 arg3 = wxString_in_helper(obj2);
17792 if (arg3 == NULL) SWIG_fail;
17793 temp3 = true;
17794 }
17795 if (obj3) {
17796 ecode4 = SWIG_AsVal_int(obj3, &val4);
17797 if (!SWIG_IsOK(ecode4)) {
17798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17799 }
17800 arg4 = static_cast< int >(val4);
17801 }
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 {
17809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17810 }
17811 {
17812 if (created2) delete arg2;
17813 }
17814 {
17815 if (temp3)
17816 delete arg3;
17817 }
17818 return resultobj;
17819 fail:
17820 {
17821 if (created2) delete arg2;
17822 }
17823 {
17824 if (temp3)
17825 delete arg3;
17826 }
17827 return NULL;
17828 }
17829
17830
17831 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17832 PyObject *resultobj = 0;
17833 wxImage *arg1 = (wxImage *) 0 ;
17834 bool result;
17835 void *argp1 = 0 ;
17836 int res1 = 0 ;
17837 PyObject *swig_obj[1] ;
17838
17839 if (!args) SWIG_fail;
17840 swig_obj[0] = args;
17841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17842 if (!SWIG_IsOK(res1)) {
17843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17844 }
17845 arg1 = reinterpret_cast< wxImage * >(argp1);
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->IsOk();
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 {
17853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17854 }
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17862 PyObject *resultobj = 0;
17863 wxImage *arg1 = (wxImage *) 0 ;
17864 int result;
17865 void *argp1 = 0 ;
17866 int res1 = 0 ;
17867 PyObject *swig_obj[1] ;
17868
17869 if (!args) SWIG_fail;
17870 swig_obj[0] = args;
17871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17872 if (!SWIG_IsOK(res1)) {
17873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17874 }
17875 arg1 = reinterpret_cast< wxImage * >(argp1);
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (int)(arg1)->GetWidth();
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 resultobj = SWIG_From_int(static_cast< int >(result));
17883 return resultobj;
17884 fail:
17885 return NULL;
17886 }
17887
17888
17889 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17890 PyObject *resultobj = 0;
17891 wxImage *arg1 = (wxImage *) 0 ;
17892 int result;
17893 void *argp1 = 0 ;
17894 int res1 = 0 ;
17895 PyObject *swig_obj[1] ;
17896
17897 if (!args) SWIG_fail;
17898 swig_obj[0] = args;
17899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17900 if (!SWIG_IsOK(res1)) {
17901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17902 }
17903 arg1 = reinterpret_cast< wxImage * >(argp1);
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 result = (int)(arg1)->GetHeight();
17907 wxPyEndAllowThreads(__tstate);
17908 if (PyErr_Occurred()) SWIG_fail;
17909 }
17910 resultobj = SWIG_From_int(static_cast< int >(result));
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 PyObject *resultobj = 0;
17919 wxImage *arg1 = (wxImage *) 0 ;
17920 wxSize result;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 PyObject *swig_obj[1] ;
17924
17925 if (!args) SWIG_fail;
17926 swig_obj[0] = args;
17927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17930 }
17931 arg1 = reinterpret_cast< wxImage * >(argp1);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = wxImage_GetSize(arg1);
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj = 0;
17947 wxImage *arg1 = (wxImage *) 0 ;
17948 wxRect *arg2 = 0 ;
17949 SwigValueWrapper<wxImage > result;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 wxRect temp2 ;
17953 PyObject * obj0 = 0 ;
17954 PyObject * obj1 = 0 ;
17955 char * kwnames[] = {
17956 (char *) "self",(char *) "rect", NULL
17957 };
17958
17959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17961 if (!SWIG_IsOK(res1)) {
17962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17963 }
17964 arg1 = reinterpret_cast< wxImage * >(argp1);
17965 {
17966 arg2 = &temp2;
17967 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17968 }
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj = 0;
17984 wxImage *arg1 = (wxImage *) 0 ;
17985 wxSize *arg2 = 0 ;
17986 wxPoint *arg3 = 0 ;
17987 int arg4 = (int) -1 ;
17988 int arg5 = (int) -1 ;
17989 int arg6 = (int) -1 ;
17990 SwigValueWrapper<wxImage > result;
17991 void *argp1 = 0 ;
17992 int res1 = 0 ;
17993 wxSize temp2 ;
17994 wxPoint temp3 ;
17995 int val4 ;
17996 int ecode4 = 0 ;
17997 int val5 ;
17998 int ecode5 = 0 ;
17999 int val6 ;
18000 int ecode6 = 0 ;
18001 PyObject * obj0 = 0 ;
18002 PyObject * obj1 = 0 ;
18003 PyObject * obj2 = 0 ;
18004 PyObject * obj3 = 0 ;
18005 PyObject * obj4 = 0 ;
18006 PyObject * obj5 = 0 ;
18007 char * kwnames[] = {
18008 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18009 };
18010
18011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18013 if (!SWIG_IsOK(res1)) {
18014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18015 }
18016 arg1 = reinterpret_cast< wxImage * >(argp1);
18017 {
18018 arg2 = &temp2;
18019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18020 }
18021 {
18022 arg3 = &temp3;
18023 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18024 }
18025 if (obj3) {
18026 ecode4 = SWIG_AsVal_int(obj3, &val4);
18027 if (!SWIG_IsOK(ecode4)) {
18028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18029 }
18030 arg4 = static_cast< int >(val4);
18031 }
18032 if (obj4) {
18033 ecode5 = SWIG_AsVal_int(obj4, &val5);
18034 if (!SWIG_IsOK(ecode5)) {
18035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18036 }
18037 arg5 = static_cast< int >(val5);
18038 }
18039 if (obj5) {
18040 ecode6 = SWIG_AsVal_int(obj5, &val6);
18041 if (!SWIG_IsOK(ecode6)) {
18042 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18043 }
18044 arg6 = static_cast< int >(val6);
18045 }
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 PyObject *resultobj = 0;
18061 wxImage *arg1 = (wxImage *) 0 ;
18062 SwigValueWrapper<wxImage > result;
18063 void *argp1 = 0 ;
18064 int res1 = 0 ;
18065 PyObject *swig_obj[1] ;
18066
18067 if (!args) SWIG_fail;
18068 swig_obj[0] = args;
18069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18072 }
18073 arg1 = reinterpret_cast< wxImage * >(argp1);
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (arg1)->Copy();
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj = 0;
18089 wxImage *arg1 = (wxImage *) 0 ;
18090 wxImage *arg2 = 0 ;
18091 int arg3 ;
18092 int arg4 ;
18093 void *argp1 = 0 ;
18094 int res1 = 0 ;
18095 void *argp2 = 0 ;
18096 int res2 = 0 ;
18097 int val3 ;
18098 int ecode3 = 0 ;
18099 int val4 ;
18100 int ecode4 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 PyObject * obj2 = 0 ;
18104 PyObject * obj3 = 0 ;
18105 char * kwnames[] = {
18106 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18107 };
18108
18109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18113 }
18114 arg1 = reinterpret_cast< wxImage * >(argp1);
18115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18116 if (!SWIG_IsOK(res2)) {
18117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18118 }
18119 if (!argp2) {
18120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18121 }
18122 arg2 = reinterpret_cast< wxImage * >(argp2);
18123 ecode3 = SWIG_AsVal_int(obj2, &val3);
18124 if (!SWIG_IsOK(ecode3)) {
18125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18126 }
18127 arg3 = static_cast< int >(val3);
18128 ecode4 = SWIG_AsVal_int(obj3, &val4);
18129 if (!SWIG_IsOK(ecode4)) {
18130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18131 }
18132 arg4 = static_cast< int >(val4);
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_Py_Void();
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 PyObject *resultobj = 0;
18148 wxImage *arg1 = (wxImage *) 0 ;
18149 PyObject *result = 0 ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 PyObject *swig_obj[1] ;
18153
18154 if (!args) SWIG_fail;
18155 swig_obj[0] = args;
18156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18157 if (!SWIG_IsOK(res1)) {
18158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18159 }
18160 arg1 = reinterpret_cast< wxImage * >(argp1);
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (PyObject *)wxImage_GetData(arg1);
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = result;
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj = 0;
18176 wxImage *arg1 = (wxImage *) 0 ;
18177 buffer arg2 ;
18178 int arg3 ;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 Py_ssize_t temp2 ;
18182 PyObject * obj0 = 0 ;
18183 PyObject * obj1 = 0 ;
18184 char * kwnames[] = {
18185 (char *) "self",(char *) "data", NULL
18186 };
18187
18188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18190 if (!SWIG_IsOK(res1)) {
18191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18192 }
18193 arg1 = reinterpret_cast< wxImage * >(argp1);
18194 {
18195 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18196 arg3 = (int)temp2;
18197 }
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 wxImage_SetData(arg1,arg2,arg3);
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 resultobj = SWIG_Py_Void();
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18212 PyObject *resultobj = 0;
18213 wxImage *arg1 = (wxImage *) 0 ;
18214 PyObject *result = 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 PyObject *swig_obj[1] ;
18218
18219 if (!args) SWIG_fail;
18220 swig_obj[0] = args;
18221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18222 if (!SWIG_IsOK(res1)) {
18223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18224 }
18225 arg1 = reinterpret_cast< wxImage * >(argp1);
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = result;
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18240 PyObject *resultobj = 0;
18241 wxImage *arg1 = (wxImage *) 0 ;
18242 buffer arg2 ;
18243 int arg3 ;
18244 void *argp1 = 0 ;
18245 int res1 = 0 ;
18246 Py_ssize_t temp2 ;
18247 PyObject * obj0 = 0 ;
18248 PyObject * obj1 = 0 ;
18249 char * kwnames[] = {
18250 (char *) "self",(char *) "data", NULL
18251 };
18252
18253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18255 if (!SWIG_IsOK(res1)) {
18256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18257 }
18258 arg1 = reinterpret_cast< wxImage * >(argp1);
18259 {
18260 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18261 arg3 = (int)temp2;
18262 }
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 wxImage_SetDataBuffer(arg1,arg2,arg3);
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = SWIG_Py_Void();
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18277 PyObject *resultobj = 0;
18278 wxImage *arg1 = (wxImage *) 0 ;
18279 PyObject *result = 0 ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 PyObject *swig_obj[1] ;
18283
18284 if (!args) SWIG_fail;
18285 swig_obj[0] = args;
18286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18287 if (!SWIG_IsOK(res1)) {
18288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18289 }
18290 arg1 = reinterpret_cast< wxImage * >(argp1);
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (PyObject *)wxImage_GetAlphaData(arg1);
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 resultobj = result;
18298 return resultobj;
18299 fail:
18300 return NULL;
18301 }
18302
18303
18304 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj = 0;
18306 wxImage *arg1 = (wxImage *) 0 ;
18307 buffer arg2 ;
18308 int arg3 ;
18309 void *argp1 = 0 ;
18310 int res1 = 0 ;
18311 Py_ssize_t temp2 ;
18312 PyObject * obj0 = 0 ;
18313 PyObject * obj1 = 0 ;
18314 char * kwnames[] = {
18315 (char *) "self",(char *) "alpha", NULL
18316 };
18317
18318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18320 if (!SWIG_IsOK(res1)) {
18321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18322 }
18323 arg1 = reinterpret_cast< wxImage * >(argp1);
18324 {
18325 if (obj1 != Py_None) {
18326 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18327 arg3 = (int)temp2;
18328 }
18329 }
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 wxImage_SetAlphaData(arg1,arg2,arg3);
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 resultobj = SWIG_Py_Void();
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18344 PyObject *resultobj = 0;
18345 wxImage *arg1 = (wxImage *) 0 ;
18346 PyObject *result = 0 ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 PyObject *swig_obj[1] ;
18350
18351 if (!args) SWIG_fail;
18352 swig_obj[0] = args;
18353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18354 if (!SWIG_IsOK(res1)) {
18355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18356 }
18357 arg1 = reinterpret_cast< wxImage * >(argp1);
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 resultobj = result;
18365 return resultobj;
18366 fail:
18367 return NULL;
18368 }
18369
18370
18371 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj = 0;
18373 wxImage *arg1 = (wxImage *) 0 ;
18374 buffer arg2 ;
18375 int arg3 ;
18376 void *argp1 = 0 ;
18377 int res1 = 0 ;
18378 Py_ssize_t temp2 ;
18379 PyObject * obj0 = 0 ;
18380 PyObject * obj1 = 0 ;
18381 char * kwnames[] = {
18382 (char *) "self",(char *) "alpha", NULL
18383 };
18384
18385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18387 if (!SWIG_IsOK(res1)) {
18388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18389 }
18390 arg1 = reinterpret_cast< wxImage * >(argp1);
18391 {
18392 if (obj1 != Py_None) {
18393 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18394 arg3 = (int)temp2;
18395 }
18396 }
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 resultobj = SWIG_Py_Void();
18404 return resultobj;
18405 fail:
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj = 0;
18412 wxImage *arg1 = (wxImage *) 0 ;
18413 byte arg2 ;
18414 byte arg3 ;
18415 byte arg4 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 unsigned char val2 ;
18419 int ecode2 = 0 ;
18420 unsigned char val3 ;
18421 int ecode3 = 0 ;
18422 unsigned char val4 ;
18423 int ecode4 = 0 ;
18424 PyObject * obj0 = 0 ;
18425 PyObject * obj1 = 0 ;
18426 PyObject * obj2 = 0 ;
18427 PyObject * obj3 = 0 ;
18428 char * kwnames[] = {
18429 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18430 };
18431
18432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18434 if (!SWIG_IsOK(res1)) {
18435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18436 }
18437 arg1 = reinterpret_cast< wxImage * >(argp1);
18438 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18439 if (!SWIG_IsOK(ecode2)) {
18440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18441 }
18442 arg2 = static_cast< byte >(val2);
18443 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18444 if (!SWIG_IsOK(ecode3)) {
18445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18446 }
18447 arg3 = static_cast< byte >(val3);
18448 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18449 if (!SWIG_IsOK(ecode4)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18451 }
18452 arg4 = static_cast< byte >(val4);
18453 {
18454 PyThreadState* __tstate = wxPyBeginAllowThreads();
18455 (arg1)->SetMaskColour(arg2,arg3,arg4);
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 resultobj = SWIG_Py_Void();
18460 return resultobj;
18461 fail:
18462 return NULL;
18463 }
18464
18465
18466 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18467 PyObject *resultobj = 0;
18468 wxImage *arg1 = (wxImage *) 0 ;
18469 byte *arg2 = (byte *) 0 ;
18470 byte *arg3 = (byte *) 0 ;
18471 byte *arg4 = (byte *) 0 ;
18472 void *argp1 = 0 ;
18473 int res1 = 0 ;
18474 byte temp2 ;
18475 int res2 = SWIG_TMPOBJ ;
18476 byte temp3 ;
18477 int res3 = SWIG_TMPOBJ ;
18478 byte temp4 ;
18479 int res4 = SWIG_TMPOBJ ;
18480 PyObject *swig_obj[1] ;
18481
18482 arg2 = &temp2;
18483 arg3 = &temp3;
18484 arg4 = &temp4;
18485 if (!args) SWIG_fail;
18486 swig_obj[0] = args;
18487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18488 if (!SWIG_IsOK(res1)) {
18489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18490 }
18491 arg1 = reinterpret_cast< wxImage * >(argp1);
18492 {
18493 PyThreadState* __tstate = wxPyBeginAllowThreads();
18494 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18495 wxPyEndAllowThreads(__tstate);
18496 if (PyErr_Occurred()) SWIG_fail;
18497 }
18498 resultobj = SWIG_Py_Void();
18499 if (SWIG_IsTmpObj(res2)) {
18500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18501 } else {
18502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18504 }
18505 if (SWIG_IsTmpObj(res3)) {
18506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18507 } else {
18508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18510 }
18511 if (SWIG_IsTmpObj(res4)) {
18512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18513 } else {
18514 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18516 }
18517 return resultobj;
18518 fail:
18519 return NULL;
18520 }
18521
18522
18523 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18524 PyObject *resultobj = 0;
18525 wxImage *arg1 = (wxImage *) 0 ;
18526 byte result;
18527 void *argp1 = 0 ;
18528 int res1 = 0 ;
18529 PyObject *swig_obj[1] ;
18530
18531 if (!args) SWIG_fail;
18532 swig_obj[0] = args;
18533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18536 }
18537 arg1 = reinterpret_cast< wxImage * >(argp1);
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 result = (byte)(arg1)->GetMaskRed();
18541 wxPyEndAllowThreads(__tstate);
18542 if (PyErr_Occurred()) SWIG_fail;
18543 }
18544 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18545 return resultobj;
18546 fail:
18547 return NULL;
18548 }
18549
18550
18551 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18552 PyObject *resultobj = 0;
18553 wxImage *arg1 = (wxImage *) 0 ;
18554 byte result;
18555 void *argp1 = 0 ;
18556 int res1 = 0 ;
18557 PyObject *swig_obj[1] ;
18558
18559 if (!args) SWIG_fail;
18560 swig_obj[0] = args;
18561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18562 if (!SWIG_IsOK(res1)) {
18563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18564 }
18565 arg1 = reinterpret_cast< wxImage * >(argp1);
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (byte)(arg1)->GetMaskGreen();
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxImage *arg1 = (wxImage *) 0 ;
18582 byte result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18592 }
18593 arg1 = reinterpret_cast< wxImage * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (byte)(arg1)->GetMaskBlue();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = 0;
18609 wxImage *arg1 = (wxImage *) 0 ;
18610 bool arg2 = (bool) true ;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 bool val2 ;
18614 int ecode2 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "self",(char *) "mask", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18625 }
18626 arg1 = reinterpret_cast< wxImage * >(argp1);
18627 if (obj1) {
18628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18629 if (!SWIG_IsOK(ecode2)) {
18630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18631 }
18632 arg2 = static_cast< bool >(val2);
18633 }
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 (arg1)->SetMask(arg2);
18637 wxPyEndAllowThreads(__tstate);
18638 if (PyErr_Occurred()) SWIG_fail;
18639 }
18640 resultobj = SWIG_Py_Void();
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18648 PyObject *resultobj = 0;
18649 wxImage *arg1 = (wxImage *) 0 ;
18650 bool result;
18651 void *argp1 = 0 ;
18652 int res1 = 0 ;
18653 PyObject *swig_obj[1] ;
18654
18655 if (!args) SWIG_fail;
18656 swig_obj[0] = args;
18657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18658 if (!SWIG_IsOK(res1)) {
18659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18660 }
18661 arg1 = reinterpret_cast< wxImage * >(argp1);
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 result = (bool)(arg1)->HasMask();
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 {
18669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18670 }
18671 return resultobj;
18672 fail:
18673 return NULL;
18674 }
18675
18676
18677 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18678 PyObject *resultobj = 0;
18679 wxImage *arg1 = (wxImage *) 0 ;
18680 double arg2 ;
18681 wxPoint *arg3 = 0 ;
18682 bool arg4 = (bool) true ;
18683 wxPoint *arg5 = (wxPoint *) NULL ;
18684 SwigValueWrapper<wxImage > result;
18685 void *argp1 = 0 ;
18686 int res1 = 0 ;
18687 double val2 ;
18688 int ecode2 = 0 ;
18689 wxPoint temp3 ;
18690 bool val4 ;
18691 int ecode4 = 0 ;
18692 void *argp5 = 0 ;
18693 int res5 = 0 ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 PyObject * obj2 = 0 ;
18697 PyObject * obj3 = 0 ;
18698 PyObject * obj4 = 0 ;
18699 char * kwnames[] = {
18700 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18701 };
18702
18703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18705 if (!SWIG_IsOK(res1)) {
18706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18707 }
18708 arg1 = reinterpret_cast< wxImage * >(argp1);
18709 ecode2 = SWIG_AsVal_double(obj1, &val2);
18710 if (!SWIG_IsOK(ecode2)) {
18711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18712 }
18713 arg2 = static_cast< double >(val2);
18714 {
18715 arg3 = &temp3;
18716 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18717 }
18718 if (obj3) {
18719 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18720 if (!SWIG_IsOK(ecode4)) {
18721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18722 }
18723 arg4 = static_cast< bool >(val4);
18724 }
18725 if (obj4) {
18726 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18727 if (!SWIG_IsOK(res5)) {
18728 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18729 }
18730 arg5 = reinterpret_cast< wxPoint * >(argp5);
18731 }
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18739 return resultobj;
18740 fail:
18741 return NULL;
18742 }
18743
18744
18745 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18746 PyObject *resultobj = 0;
18747 wxImage *arg1 = (wxImage *) 0 ;
18748 bool arg2 = (bool) true ;
18749 SwigValueWrapper<wxImage > result;
18750 void *argp1 = 0 ;
18751 int res1 = 0 ;
18752 bool val2 ;
18753 int ecode2 = 0 ;
18754 PyObject * obj0 = 0 ;
18755 PyObject * obj1 = 0 ;
18756 char * kwnames[] = {
18757 (char *) "self",(char *) "clockwise", NULL
18758 };
18759
18760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18762 if (!SWIG_IsOK(res1)) {
18763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18764 }
18765 arg1 = reinterpret_cast< wxImage * >(argp1);
18766 if (obj1) {
18767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18768 if (!SWIG_IsOK(ecode2)) {
18769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18770 }
18771 arg2 = static_cast< bool >(val2);
18772 }
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (arg1)->Rotate90(arg2);
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18787 PyObject *resultobj = 0;
18788 wxImage *arg1 = (wxImage *) 0 ;
18789 bool arg2 = (bool) true ;
18790 SwigValueWrapper<wxImage > result;
18791 void *argp1 = 0 ;
18792 int res1 = 0 ;
18793 bool val2 ;
18794 int ecode2 = 0 ;
18795 PyObject * obj0 = 0 ;
18796 PyObject * obj1 = 0 ;
18797 char * kwnames[] = {
18798 (char *) "self",(char *) "horizontally", NULL
18799 };
18800
18801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18803 if (!SWIG_IsOK(res1)) {
18804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18805 }
18806 arg1 = reinterpret_cast< wxImage * >(argp1);
18807 if (obj1) {
18808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18809 if (!SWIG_IsOK(ecode2)) {
18810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18811 }
18812 arg2 = static_cast< bool >(val2);
18813 }
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = (arg1)->Mirror(arg2);
18817 wxPyEndAllowThreads(__tstate);
18818 if (PyErr_Occurred()) SWIG_fail;
18819 }
18820 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18828 PyObject *resultobj = 0;
18829 wxImage *arg1 = (wxImage *) 0 ;
18830 byte arg2 ;
18831 byte arg3 ;
18832 byte arg4 ;
18833 byte arg5 ;
18834 byte arg6 ;
18835 byte arg7 ;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 unsigned char val2 ;
18839 int ecode2 = 0 ;
18840 unsigned char val3 ;
18841 int ecode3 = 0 ;
18842 unsigned char val4 ;
18843 int ecode4 = 0 ;
18844 unsigned char val5 ;
18845 int ecode5 = 0 ;
18846 unsigned char val6 ;
18847 int ecode6 = 0 ;
18848 unsigned char val7 ;
18849 int ecode7 = 0 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 PyObject * obj2 = 0 ;
18853 PyObject * obj3 = 0 ;
18854 PyObject * obj4 = 0 ;
18855 PyObject * obj5 = 0 ;
18856 PyObject * obj6 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18865 }
18866 arg1 = reinterpret_cast< wxImage * >(argp1);
18867 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18868 if (!SWIG_IsOK(ecode2)) {
18869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18870 }
18871 arg2 = static_cast< byte >(val2);
18872 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18873 if (!SWIG_IsOK(ecode3)) {
18874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18875 }
18876 arg3 = static_cast< byte >(val3);
18877 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18878 if (!SWIG_IsOK(ecode4)) {
18879 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18880 }
18881 arg4 = static_cast< byte >(val4);
18882 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18883 if (!SWIG_IsOK(ecode5)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18885 }
18886 arg5 = static_cast< byte >(val5);
18887 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18888 if (!SWIG_IsOK(ecode6)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18890 }
18891 arg6 = static_cast< byte >(val6);
18892 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18893 if (!SWIG_IsOK(ecode7)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18895 }
18896 arg7 = static_cast< byte >(val7);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_Py_Void();
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = 0;
18912 wxImage *arg1 = (wxImage *) 0 ;
18913 double arg2 = (double) 0.299 ;
18914 double arg3 = (double) 0.587 ;
18915 double arg4 = (double) 0.114 ;
18916 SwigValueWrapper<wxImage > result;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 double val2 ;
18920 int ecode2 = 0 ;
18921 double val3 ;
18922 int ecode3 = 0 ;
18923 double val4 ;
18924 int ecode4 = 0 ;
18925 PyObject * obj0 = 0 ;
18926 PyObject * obj1 = 0 ;
18927 PyObject * obj2 = 0 ;
18928 PyObject * obj3 = 0 ;
18929 char * kwnames[] = {
18930 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18931 };
18932
18933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18935 if (!SWIG_IsOK(res1)) {
18936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18937 }
18938 arg1 = reinterpret_cast< wxImage * >(argp1);
18939 if (obj1) {
18940 ecode2 = SWIG_AsVal_double(obj1, &val2);
18941 if (!SWIG_IsOK(ecode2)) {
18942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18943 }
18944 arg2 = static_cast< double >(val2);
18945 }
18946 if (obj2) {
18947 ecode3 = SWIG_AsVal_double(obj2, &val3);
18948 if (!SWIG_IsOK(ecode3)) {
18949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18950 }
18951 arg3 = static_cast< double >(val3);
18952 }
18953 if (obj3) {
18954 ecode4 = SWIG_AsVal_double(obj3, &val4);
18955 if (!SWIG_IsOK(ecode4)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18957 }
18958 arg4 = static_cast< double >(val4);
18959 }
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj = 0;
18975 wxImage *arg1 = (wxImage *) 0 ;
18976 byte arg2 ;
18977 byte arg3 ;
18978 byte arg4 ;
18979 SwigValueWrapper<wxImage > result;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 unsigned char val2 ;
18983 int ecode2 = 0 ;
18984 unsigned char val3 ;
18985 int ecode3 = 0 ;
18986 unsigned char val4 ;
18987 int ecode4 = 0 ;
18988 PyObject * obj0 = 0 ;
18989 PyObject * obj1 = 0 ;
18990 PyObject * obj2 = 0 ;
18991 PyObject * obj3 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19000 }
19001 arg1 = reinterpret_cast< wxImage * >(argp1);
19002 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19003 if (!SWIG_IsOK(ecode2)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19005 }
19006 arg2 = static_cast< byte >(val2);
19007 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19008 if (!SWIG_IsOK(ecode3)) {
19009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19010 }
19011 arg3 = static_cast< byte >(val3);
19012 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19013 if (!SWIG_IsOK(ecode4)) {
19014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19015 }
19016 arg4 = static_cast< byte >(val4);
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj = 0;
19032 wxImage *arg1 = (wxImage *) 0 ;
19033 wxString *arg2 = 0 ;
19034 wxString *arg3 = 0 ;
19035 void *argp1 = 0 ;
19036 int res1 = 0 ;
19037 bool temp2 = false ;
19038 bool temp3 = false ;
19039 PyObject * obj0 = 0 ;
19040 PyObject * obj1 = 0 ;
19041 PyObject * obj2 = 0 ;
19042 char * kwnames[] = {
19043 (char *) "self",(char *) "name",(char *) "value", NULL
19044 };
19045
19046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19050 }
19051 arg1 = reinterpret_cast< wxImage * >(argp1);
19052 {
19053 arg2 = wxString_in_helper(obj1);
19054 if (arg2 == NULL) SWIG_fail;
19055 temp2 = true;
19056 }
19057 {
19058 arg3 = wxString_in_helper(obj2);
19059 if (arg3 == NULL) SWIG_fail;
19060 temp3 = true;
19061 }
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19065 wxPyEndAllowThreads(__tstate);
19066 if (PyErr_Occurred()) SWIG_fail;
19067 }
19068 resultobj = SWIG_Py_Void();
19069 {
19070 if (temp2)
19071 delete arg2;
19072 }
19073 {
19074 if (temp3)
19075 delete arg3;
19076 }
19077 return resultobj;
19078 fail:
19079 {
19080 if (temp2)
19081 delete arg2;
19082 }
19083 {
19084 if (temp3)
19085 delete arg3;
19086 }
19087 return NULL;
19088 }
19089
19090
19091 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj = 0;
19093 wxImage *arg1 = (wxImage *) 0 ;
19094 wxString *arg2 = 0 ;
19095 int arg3 ;
19096 void *argp1 = 0 ;
19097 int res1 = 0 ;
19098 bool temp2 = false ;
19099 int val3 ;
19100 int ecode3 = 0 ;
19101 PyObject * obj0 = 0 ;
19102 PyObject * obj1 = 0 ;
19103 PyObject * obj2 = 0 ;
19104 char * kwnames[] = {
19105 (char *) "self",(char *) "name",(char *) "value", NULL
19106 };
19107
19108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19112 }
19113 arg1 = reinterpret_cast< wxImage * >(argp1);
19114 {
19115 arg2 = wxString_in_helper(obj1);
19116 if (arg2 == NULL) SWIG_fail;
19117 temp2 = true;
19118 }
19119 ecode3 = SWIG_AsVal_int(obj2, &val3);
19120 if (!SWIG_IsOK(ecode3)) {
19121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19122 }
19123 arg3 = static_cast< int >(val3);
19124 {
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 (arg1)->SetOption((wxString const &)*arg2,arg3);
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 resultobj = SWIG_Py_Void();
19131 {
19132 if (temp2)
19133 delete arg2;
19134 }
19135 return resultobj;
19136 fail:
19137 {
19138 if (temp2)
19139 delete arg2;
19140 }
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj = 0;
19147 wxImage *arg1 = (wxImage *) 0 ;
19148 wxString *arg2 = 0 ;
19149 wxString result;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 bool temp2 = false ;
19153 PyObject * obj0 = 0 ;
19154 PyObject * obj1 = 0 ;
19155 char * kwnames[] = {
19156 (char *) "self",(char *) "name", NULL
19157 };
19158
19159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19163 }
19164 arg1 = reinterpret_cast< wxImage * >(argp1);
19165 {
19166 arg2 = wxString_in_helper(obj1);
19167 if (arg2 == NULL) SWIG_fail;
19168 temp2 = true;
19169 }
19170 {
19171 PyThreadState* __tstate = wxPyBeginAllowThreads();
19172 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19173 wxPyEndAllowThreads(__tstate);
19174 if (PyErr_Occurred()) SWIG_fail;
19175 }
19176 {
19177 #if wxUSE_UNICODE
19178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19179 #else
19180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19181 #endif
19182 }
19183 {
19184 if (temp2)
19185 delete arg2;
19186 }
19187 return resultobj;
19188 fail:
19189 {
19190 if (temp2)
19191 delete arg2;
19192 }
19193 return NULL;
19194 }
19195
19196
19197 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = 0;
19199 wxImage *arg1 = (wxImage *) 0 ;
19200 wxString *arg2 = 0 ;
19201 int result;
19202 void *argp1 = 0 ;
19203 int res1 = 0 ;
19204 bool temp2 = false ;
19205 PyObject * obj0 = 0 ;
19206 PyObject * obj1 = 0 ;
19207 char * kwnames[] = {
19208 (char *) "self",(char *) "name", NULL
19209 };
19210
19211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19215 }
19216 arg1 = reinterpret_cast< wxImage * >(argp1);
19217 {
19218 arg2 = wxString_in_helper(obj1);
19219 if (arg2 == NULL) SWIG_fail;
19220 temp2 = true;
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 resultobj = SWIG_From_int(static_cast< int >(result));
19229 {
19230 if (temp2)
19231 delete arg2;
19232 }
19233 return resultobj;
19234 fail:
19235 {
19236 if (temp2)
19237 delete arg2;
19238 }
19239 return NULL;
19240 }
19241
19242
19243 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj = 0;
19245 wxImage *arg1 = (wxImage *) 0 ;
19246 wxString *arg2 = 0 ;
19247 bool result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 bool temp2 = false ;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char * kwnames[] = {
19254 (char *) "self",(char *) "name", NULL
19255 };
19256
19257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19259 if (!SWIG_IsOK(res1)) {
19260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19261 }
19262 arg1 = reinterpret_cast< wxImage * >(argp1);
19263 {
19264 arg2 = wxString_in_helper(obj1);
19265 if (arg2 == NULL) SWIG_fail;
19266 temp2 = true;
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19271 wxPyEndAllowThreads(__tstate);
19272 if (PyErr_Occurred()) SWIG_fail;
19273 }
19274 {
19275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19276 }
19277 {
19278 if (temp2)
19279 delete arg2;
19280 }
19281 return resultobj;
19282 fail:
19283 {
19284 if (temp2)
19285 delete arg2;
19286 }
19287 return NULL;
19288 }
19289
19290
19291 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19292 PyObject *resultobj = 0;
19293 wxImage *arg1 = (wxImage *) 0 ;
19294 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19295 unsigned long result;
19296 void *argp1 = 0 ;
19297 int res1 = 0 ;
19298 unsigned long val2 ;
19299 int ecode2 = 0 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 char * kwnames[] = {
19303 (char *) "self",(char *) "stopafter", NULL
19304 };
19305
19306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19308 if (!SWIG_IsOK(res1)) {
19309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19310 }
19311 arg1 = reinterpret_cast< wxImage * >(argp1);
19312 if (obj1) {
19313 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19314 if (!SWIG_IsOK(ecode2)) {
19315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19316 }
19317 arg2 = static_cast< unsigned long >(val2);
19318 }
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 result = (unsigned long)(arg1)->CountColours(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj = 0;
19334 wxImage *arg1 = (wxImage *) 0 ;
19335 wxImageHistogram *arg2 = 0 ;
19336 unsigned long result;
19337 void *argp1 = 0 ;
19338 int res1 = 0 ;
19339 void *argp2 = 0 ;
19340 int res2 = 0 ;
19341 PyObject * obj0 = 0 ;
19342 PyObject * obj1 = 0 ;
19343 char * kwnames[] = {
19344 (char *) "self",(char *) "h", NULL
19345 };
19346
19347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19349 if (!SWIG_IsOK(res1)) {
19350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19351 }
19352 arg1 = reinterpret_cast< wxImage * >(argp1);
19353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19354 if (!SWIG_IsOK(res2)) {
19355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19356 }
19357 if (!argp2) {
19358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19359 }
19360 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj = 0;
19376 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19377 void *argp1 = 0 ;
19378 int res1 = 0 ;
19379 PyObject * obj0 = 0 ;
19380 char * kwnames[] = {
19381 (char *) "handler", NULL
19382 };
19383
19384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19386 if (!SWIG_IsOK(res1)) {
19387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19388 }
19389 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 wxImage::AddHandler(arg1);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_Py_Void();
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19406 void *argp1 = 0 ;
19407 int res1 = 0 ;
19408 PyObject * obj0 = 0 ;
19409 char * kwnames[] = {
19410 (char *) "handler", NULL
19411 };
19412
19413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19415 if (!SWIG_IsOK(res1)) {
19416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19417 }
19418 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19419 {
19420 PyThreadState* __tstate = wxPyBeginAllowThreads();
19421 wxImage::InsertHandler(arg1);
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 resultobj = SWIG_Py_Void();
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj = 0;
19434 wxString *arg1 = 0 ;
19435 bool result;
19436 bool temp1 = false ;
19437 PyObject * obj0 = 0 ;
19438 char * kwnames[] = {
19439 (char *) "name", NULL
19440 };
19441
19442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19443 {
19444 arg1 = wxString_in_helper(obj0);
19445 if (arg1 == NULL) SWIG_fail;
19446 temp1 = true;
19447 }
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 {
19455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19456 }
19457 {
19458 if (temp1)
19459 delete arg1;
19460 }
19461 return resultobj;
19462 fail:
19463 {
19464 if (temp1)
19465 delete arg1;
19466 }
19467 return NULL;
19468 }
19469
19470
19471 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19472 PyObject *resultobj = 0;
19473 PyObject *result = 0 ;
19474
19475 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 result = (PyObject *)wxImage_GetHandlers();
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = result;
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 PyObject *resultobj = 0;
19491 wxString result;
19492
19493 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = wxImage::GetImageExtWildcard();
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 {
19501 #if wxUSE_UNICODE
19502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19503 #else
19504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19505 #endif
19506 }
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19514 PyObject *resultobj = 0;
19515 wxImage *arg1 = (wxImage *) 0 ;
19516 int arg2 = (int) -1 ;
19517 wxBitmap result;
19518 void *argp1 = 0 ;
19519 int res1 = 0 ;
19520 int val2 ;
19521 int ecode2 = 0 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "self",(char *) "depth", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19530 if (!SWIG_IsOK(res1)) {
19531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19532 }
19533 arg1 = reinterpret_cast< wxImage * >(argp1);
19534 if (obj1) {
19535 ecode2 = SWIG_AsVal_int(obj1, &val2);
19536 if (!SWIG_IsOK(ecode2)) {
19537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19538 }
19539 arg2 = static_cast< int >(val2);
19540 }
19541 {
19542 if (!wxPyCheckForApp()) SWIG_fail;
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = wxImage_ConvertToBitmap(arg1,arg2);
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj = 0;
19557 wxImage *arg1 = (wxImage *) 0 ;
19558 byte arg2 ;
19559 byte arg3 ;
19560 byte arg4 ;
19561 wxBitmap result;
19562 void *argp1 = 0 ;
19563 int res1 = 0 ;
19564 unsigned char val2 ;
19565 int ecode2 = 0 ;
19566 unsigned char val3 ;
19567 int ecode3 = 0 ;
19568 unsigned char val4 ;
19569 int ecode4 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 PyObject * obj2 = 0 ;
19573 PyObject * obj3 = 0 ;
19574 char * kwnames[] = {
19575 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19576 };
19577
19578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19580 if (!SWIG_IsOK(res1)) {
19581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19582 }
19583 arg1 = reinterpret_cast< wxImage * >(argp1);
19584 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19585 if (!SWIG_IsOK(ecode2)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19587 }
19588 arg2 = static_cast< byte >(val2);
19589 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19590 if (!SWIG_IsOK(ecode3)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19592 }
19593 arg3 = static_cast< byte >(val3);
19594 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19595 if (!SWIG_IsOK(ecode4)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19597 }
19598 arg4 = static_cast< byte >(val4);
19599 {
19600 if (!wxPyCheckForApp()) SWIG_fail;
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19614 PyObject *resultobj = 0;
19615 wxImage *arg1 = (wxImage *) 0 ;
19616 double arg2 ;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 double val2 ;
19620 int ecode2 = 0 ;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 char * kwnames[] = {
19624 (char *) "self",(char *) "angle", NULL
19625 };
19626
19627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19629 if (!SWIG_IsOK(res1)) {
19630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19631 }
19632 arg1 = reinterpret_cast< wxImage * >(argp1);
19633 ecode2 = SWIG_AsVal_double(obj1, &val2);
19634 if (!SWIG_IsOK(ecode2)) {
19635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19636 }
19637 arg2 = static_cast< double >(val2);
19638 {
19639 PyThreadState* __tstate = wxPyBeginAllowThreads();
19640 (arg1)->RotateHue(arg2);
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 resultobj = SWIG_Py_Void();
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj = 0;
19653 wxImage_RGBValue arg1 ;
19654 wxImage_HSVValue result;
19655 void *argp1 ;
19656 int res1 = 0 ;
19657 PyObject * obj0 = 0 ;
19658 char * kwnames[] = {
19659 (char *) "rgb", NULL
19660 };
19661
19662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19663 {
19664 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19665 if (!SWIG_IsOK(res1)) {
19666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19667 }
19668 if (!argp1) {
19669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19670 } else {
19671 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19672 arg1 = *temp;
19673 if (SWIG_IsNewObj(res1)) delete temp;
19674 }
19675 }
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = wxImage::RGBtoHSV(arg1);
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19690 PyObject *resultobj = 0;
19691 wxImage_HSVValue arg1 ;
19692 wxImage_RGBValue result;
19693 void *argp1 ;
19694 int res1 = 0 ;
19695 PyObject * obj0 = 0 ;
19696 char * kwnames[] = {
19697 (char *) "hsv", NULL
19698 };
19699
19700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19701 {
19702 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19703 if (!SWIG_IsOK(res1)) {
19704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19705 }
19706 if (!argp1) {
19707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19708 } else {
19709 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19710 arg1 = *temp;
19711 if (SWIG_IsNewObj(res1)) delete temp;
19712 }
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = wxImage::HSVtoRGB(arg1);
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *obj;
19729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19730 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19731 return SWIG_Py_Void();
19732 }
19733
19734 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19735 return SWIG_Python_InitShadowInstance(args);
19736 }
19737
19738 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = 0;
19740 int arg1 ;
19741 int arg2 ;
19742 buffer arg3 ;
19743 int arg4 ;
19744 buffer arg5 = (buffer) NULL ;
19745 int arg6 = (int) 0 ;
19746 wxImage *result = 0 ;
19747 int val1 ;
19748 int ecode1 = 0 ;
19749 int val2 ;
19750 int ecode2 = 0 ;
19751 Py_ssize_t temp3 ;
19752 Py_ssize_t temp5 ;
19753 PyObject * obj0 = 0 ;
19754 PyObject * obj1 = 0 ;
19755 PyObject * obj2 = 0 ;
19756 PyObject * obj3 = 0 ;
19757 char * kwnames[] = {
19758 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19759 };
19760
19761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19762 ecode1 = SWIG_AsVal_int(obj0, &val1);
19763 if (!SWIG_IsOK(ecode1)) {
19764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19765 }
19766 arg1 = static_cast< int >(val1);
19767 ecode2 = SWIG_AsVal_int(obj1, &val2);
19768 if (!SWIG_IsOK(ecode2)) {
19769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19770 }
19771 arg2 = static_cast< int >(val2);
19772 {
19773 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19774 arg4 = (int)temp3;
19775 }
19776 if (obj3) {
19777 {
19778 if (obj3 != Py_None) {
19779 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19780 arg6 = (int)temp5;
19781 }
19782 }
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19792 }
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN int NullImage_set(PyObject *) {
19800 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19801 return 1;
19802 }
19803
19804
19805 SWIGINTERN PyObject *NullImage_get(void) {
19806 PyObject *pyobj = 0;
19807
19808 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19809 return pyobj;
19810 }
19811
19812
19813 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19814 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19815 return 1;
19816 }
19817
19818
19819 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19820 PyObject *pyobj = 0;
19821
19822 {
19823 #if wxUSE_UNICODE
19824 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19825 #else
19826 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19827 #endif
19828 }
19829 return pyobj;
19830 }
19831
19832
19833 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19834 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19835 return 1;
19836 }
19837
19838
19839 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19840 PyObject *pyobj = 0;
19841
19842 {
19843 #if wxUSE_UNICODE
19844 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19845 #else
19846 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19847 #endif
19848 }
19849 return pyobj;
19850 }
19851
19852
19853 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19854 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19855 return 1;
19856 }
19857
19858
19859 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19860 PyObject *pyobj = 0;
19861
19862 {
19863 #if wxUSE_UNICODE
19864 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19865 #else
19866 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19867 #endif
19868 }
19869 return pyobj;
19870 }
19871
19872
19873 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19874 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19875 return 1;
19876 }
19877
19878
19879 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19880 PyObject *pyobj = 0;
19881
19882 {
19883 #if wxUSE_UNICODE
19884 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19885 #else
19886 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19887 #endif
19888 }
19889 return pyobj;
19890 }
19891
19892
19893 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19894 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19895 return 1;
19896 }
19897
19898
19899 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19900 PyObject *pyobj = 0;
19901
19902 {
19903 #if wxUSE_UNICODE
19904 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19905 #else
19906 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19907 #endif
19908 }
19909 return pyobj;
19910 }
19911
19912
19913 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19914 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19915 return 1;
19916 }
19917
19918
19919 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19920 PyObject *pyobj = 0;
19921
19922 {
19923 #if wxUSE_UNICODE
19924 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19925 #else
19926 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19927 #endif
19928 }
19929 return pyobj;
19930 }
19931
19932
19933 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19934 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19935 return 1;
19936 }
19937
19938
19939 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19940 PyObject *pyobj = 0;
19941
19942 {
19943 #if wxUSE_UNICODE
19944 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19945 #else
19946 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19947 #endif
19948 }
19949 return pyobj;
19950 }
19951
19952
19953 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19954 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19955 return 1;
19956 }
19957
19958
19959 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19960 PyObject *pyobj = 0;
19961
19962 {
19963 #if wxUSE_UNICODE
19964 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19965 #else
19966 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19967 #endif
19968 }
19969 return pyobj;
19970 }
19971
19972
19973 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19974 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19975 return 1;
19976 }
19977
19978
19979 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19980 PyObject *pyobj = 0;
19981
19982 {
19983 #if wxUSE_UNICODE
19984 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19985 #else
19986 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19987 #endif
19988 }
19989 return pyobj;
19990 }
19991
19992
19993 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19994 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19995 return 1;
19996 }
19997
19998
19999 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20000 PyObject *pyobj = 0;
20001
20002 {
20003 #if wxUSE_UNICODE
20004 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20005 #else
20006 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20007 #endif
20008 }
20009 return pyobj;
20010 }
20011
20012
20013 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20014 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20015 return 1;
20016 }
20017
20018
20019 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20020 PyObject *pyobj = 0;
20021
20022 {
20023 #if wxUSE_UNICODE
20024 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20025 #else
20026 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20027 #endif
20028 }
20029 return pyobj;
20030 }
20031
20032
20033 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20034 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20035 return 1;
20036 }
20037
20038
20039 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20040 PyObject *pyobj = 0;
20041
20042 {
20043 #if wxUSE_UNICODE
20044 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20045 #else
20046 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20047 #endif
20048 }
20049 return pyobj;
20050 }
20051
20052
20053 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20054 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20055 return 1;
20056 }
20057
20058
20059 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20060 PyObject *pyobj = 0;
20061
20062 {
20063 #if wxUSE_UNICODE
20064 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20065 #else
20066 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20067 #endif
20068 }
20069 return pyobj;
20070 }
20071
20072
20073 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20074 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20075 return 1;
20076 }
20077
20078
20079 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20080 PyObject *pyobj = 0;
20081
20082 {
20083 #if wxUSE_UNICODE
20084 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20085 #else
20086 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20087 #endif
20088 }
20089 return pyobj;
20090 }
20091
20092
20093 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20094 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20095 return 1;
20096 }
20097
20098
20099 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20100 PyObject *pyobj = 0;
20101
20102 {
20103 #if wxUSE_UNICODE
20104 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20105 #else
20106 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20107 #endif
20108 }
20109 return pyobj;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxBMPHandler *result = 0 ;
20116
20117 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 result = (wxBMPHandler *)new wxBMPHandler();
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20132 PyObject *obj;
20133 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20134 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20135 return SWIG_Py_Void();
20136 }
20137
20138 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20139 return SWIG_Python_InitShadowInstance(args);
20140 }
20141
20142 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20143 PyObject *resultobj = 0;
20144 wxICOHandler *result = 0 ;
20145
20146 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (wxICOHandler *)new wxICOHandler();
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20161 PyObject *obj;
20162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20163 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20164 return SWIG_Py_Void();
20165 }
20166
20167 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20168 return SWIG_Python_InitShadowInstance(args);
20169 }
20170
20171 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20172 PyObject *resultobj = 0;
20173 wxCURHandler *result = 0 ;
20174
20175 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 result = (wxCURHandler *)new wxCURHandler();
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20190 PyObject *obj;
20191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20193 return SWIG_Py_Void();
20194 }
20195
20196 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20197 return SWIG_Python_InitShadowInstance(args);
20198 }
20199
20200 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201 PyObject *resultobj = 0;
20202 wxANIHandler *result = 0 ;
20203
20204 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20205 {
20206 PyThreadState* __tstate = wxPyBeginAllowThreads();
20207 result = (wxANIHandler *)new wxANIHandler();
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *obj;
20220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20221 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20222 return SWIG_Py_Void();
20223 }
20224
20225 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 return SWIG_Python_InitShadowInstance(args);
20227 }
20228
20229 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 wxPNGHandler *result = 0 ;
20232
20233 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (wxPNGHandler *)new wxPNGHandler();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *obj;
20249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20250 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20251 return SWIG_Py_Void();
20252 }
20253
20254 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 return SWIG_Python_InitShadowInstance(args);
20256 }
20257
20258 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *resultobj = 0;
20260 wxGIFHandler *result = 0 ;
20261
20262 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxGIFHandler *)new wxGIFHandler();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *obj;
20278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20279 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20280 return SWIG_Py_Void();
20281 }
20282
20283 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20284 return SWIG_Python_InitShadowInstance(args);
20285 }
20286
20287 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxPCXHandler *result = 0 ;
20290
20291 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (wxPCXHandler *)new wxPCXHandler();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20306 PyObject *obj;
20307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20308 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20309 return SWIG_Py_Void();
20310 }
20311
20312 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 return SWIG_Python_InitShadowInstance(args);
20314 }
20315
20316 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxJPEGHandler *result = 0 ;
20319
20320 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (wxJPEGHandler *)new wxJPEGHandler();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20335 PyObject *obj;
20336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20337 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20338 return SWIG_Py_Void();
20339 }
20340
20341 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 return SWIG_Python_InitShadowInstance(args);
20343 }
20344
20345 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *resultobj = 0;
20347 wxPNMHandler *result = 0 ;
20348
20349 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (wxPNMHandler *)new wxPNMHandler();
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *obj;
20365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20366 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20367 return SWIG_Py_Void();
20368 }
20369
20370 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 return SWIG_Python_InitShadowInstance(args);
20372 }
20373
20374 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxXPMHandler *result = 0 ;
20377
20378 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (wxXPMHandler *)new wxXPMHandler();
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *obj;
20394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20395 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20396 return SWIG_Py_Void();
20397 }
20398
20399 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 return SWIG_Python_InitShadowInstance(args);
20401 }
20402
20403 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *resultobj = 0;
20405 wxTIFFHandler *result = 0 ;
20406
20407 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxTIFFHandler *)new wxTIFFHandler();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *obj;
20423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20424 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20425 return SWIG_Py_Void();
20426 }
20427
20428 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 return SWIG_Python_InitShadowInstance(args);
20430 }
20431
20432 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxTGAHandler *result = 0 ;
20435
20436 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (wxTGAHandler *)new wxTGAHandler();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20451 PyObject *obj;
20452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20453 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20454 return SWIG_Py_Void();
20455 }
20456
20457 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 return SWIG_Python_InitShadowInstance(args);
20459 }
20460
20461 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20462 PyObject *resultobj = 0;
20463 wxImage *arg1 = 0 ;
20464 wxImage *arg2 = 0 ;
20465 int arg3 = (int) 236 ;
20466 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20467 bool result;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 void *argp2 = 0 ;
20471 int res2 = 0 ;
20472 int val3 ;
20473 int ecode3 = 0 ;
20474 int val4 ;
20475 int ecode4 = 0 ;
20476 PyObject * obj0 = 0 ;
20477 PyObject * obj1 = 0 ;
20478 PyObject * obj2 = 0 ;
20479 PyObject * obj3 = 0 ;
20480 char * kwnames[] = {
20481 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20482 };
20483
20484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20485 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20488 }
20489 if (!argp1) {
20490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20491 }
20492 arg1 = reinterpret_cast< wxImage * >(argp1);
20493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20494 if (!SWIG_IsOK(res2)) {
20495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20496 }
20497 if (!argp2) {
20498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20499 }
20500 arg2 = reinterpret_cast< wxImage * >(argp2);
20501 if (obj2) {
20502 ecode3 = SWIG_AsVal_int(obj2, &val3);
20503 if (!SWIG_IsOK(ecode3)) {
20504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20505 }
20506 arg3 = static_cast< int >(val3);
20507 }
20508 if (obj3) {
20509 ecode4 = SWIG_AsVal_int(obj3, &val4);
20510 if (!SWIG_IsOK(ecode4)) {
20511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20512 }
20513 arg4 = static_cast< int >(val4);
20514 }
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 {
20522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20523 }
20524 return resultobj;
20525 fail:
20526 return NULL;
20527 }
20528
20529
20530 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20531 PyObject *obj;
20532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20533 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20534 return SWIG_Py_Void();
20535 }
20536
20537 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxEvtHandler *result = 0 ;
20540
20541 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (wxEvtHandler *)new wxEvtHandler();
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20549 return resultobj;
20550 fail:
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20556 PyObject *resultobj = 0;
20557 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20558 wxEvtHandler *result = 0 ;
20559 void *argp1 = 0 ;
20560 int res1 = 0 ;
20561 PyObject *swig_obj[1] ;
20562
20563 if (!args) SWIG_fail;
20564 swig_obj[0] = args;
20565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20568 }
20569 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20573 wxPyEndAllowThreads(__tstate);
20574 if (PyErr_Occurred()) SWIG_fail;
20575 }
20576 {
20577 resultobj = wxPyMake_wxObject(result, 0);
20578 }
20579 return resultobj;
20580 fail:
20581 return NULL;
20582 }
20583
20584
20585 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20586 PyObject *resultobj = 0;
20587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20588 wxEvtHandler *result = 0 ;
20589 void *argp1 = 0 ;
20590 int res1 = 0 ;
20591 PyObject *swig_obj[1] ;
20592
20593 if (!args) SWIG_fail;
20594 swig_obj[0] = args;
20595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20596 if (!SWIG_IsOK(res1)) {
20597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20598 }
20599 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20603 wxPyEndAllowThreads(__tstate);
20604 if (PyErr_Occurred()) SWIG_fail;
20605 }
20606 {
20607 resultobj = wxPyMake_wxObject(result, 0);
20608 }
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj = 0;
20617 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20618 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20619 void *argp1 = 0 ;
20620 int res1 = 0 ;
20621 void *argp2 = 0 ;
20622 int res2 = 0 ;
20623 PyObject * obj0 = 0 ;
20624 PyObject * obj1 = 0 ;
20625 char * kwnames[] = {
20626 (char *) "self",(char *) "handler", NULL
20627 };
20628
20629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20631 if (!SWIG_IsOK(res1)) {
20632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20633 }
20634 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20636 if (!SWIG_IsOK(res2)) {
20637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20638 }
20639 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 (arg1)->SetNextHandler(arg2);
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 resultobj = SWIG_Py_Void();
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20654 PyObject *resultobj = 0;
20655 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20656 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20657 void *argp1 = 0 ;
20658 int res1 = 0 ;
20659 void *argp2 = 0 ;
20660 int res2 = 0 ;
20661 PyObject * obj0 = 0 ;
20662 PyObject * obj1 = 0 ;
20663 char * kwnames[] = {
20664 (char *) "self",(char *) "handler", NULL
20665 };
20666
20667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20669 if (!SWIG_IsOK(res1)) {
20670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20671 }
20672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20674 if (!SWIG_IsOK(res2)) {
20675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20676 }
20677 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 (arg1)->SetPreviousHandler(arg2);
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 resultobj = SWIG_Py_Void();
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20692 PyObject *resultobj = 0;
20693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20694 bool result;
20695 void *argp1 = 0 ;
20696 int res1 = 0 ;
20697 PyObject *swig_obj[1] ;
20698
20699 if (!args) SWIG_fail;
20700 swig_obj[0] = args;
20701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20704 }
20705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = (bool)(arg1)->GetEvtHandlerEnabled();
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 {
20713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20714 }
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20722 PyObject *resultobj = 0;
20723 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20724 bool arg2 ;
20725 void *argp1 = 0 ;
20726 int res1 = 0 ;
20727 bool val2 ;
20728 int ecode2 = 0 ;
20729 PyObject * obj0 = 0 ;
20730 PyObject * obj1 = 0 ;
20731 char * kwnames[] = {
20732 (char *) "self",(char *) "enabled", NULL
20733 };
20734
20735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20739 }
20740 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20742 if (!SWIG_IsOK(ecode2)) {
20743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20744 }
20745 arg2 = static_cast< bool >(val2);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 (arg1)->SetEvtHandlerEnabled(arg2);
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 resultobj = SWIG_Py_Void();
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj = 0;
20761 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20762 wxEvent *arg2 = 0 ;
20763 bool result;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 void *argp2 = 0 ;
20767 int res2 = 0 ;
20768 PyObject * obj0 = 0 ;
20769 PyObject * obj1 = 0 ;
20770 char * kwnames[] = {
20771 (char *) "self",(char *) "event", NULL
20772 };
20773
20774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20776 if (!SWIG_IsOK(res1)) {
20777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20778 }
20779 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20780 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20781 if (!SWIG_IsOK(res2)) {
20782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20783 }
20784 if (!argp2) {
20785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20786 }
20787 arg2 = reinterpret_cast< wxEvent * >(argp2);
20788 {
20789 PyThreadState* __tstate = wxPyBeginAllowThreads();
20790 result = (bool)(arg1)->ProcessEvent(*arg2);
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 {
20795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20796 }
20797 return resultobj;
20798 fail:
20799 return NULL;
20800 }
20801
20802
20803 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20804 PyObject *resultobj = 0;
20805 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20806 wxEvent *arg2 = 0 ;
20807 void *argp1 = 0 ;
20808 int res1 = 0 ;
20809 void *argp2 = 0 ;
20810 int res2 = 0 ;
20811 PyObject * obj0 = 0 ;
20812 PyObject * obj1 = 0 ;
20813 char * kwnames[] = {
20814 (char *) "self",(char *) "event", NULL
20815 };
20816
20817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20821 }
20822 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20824 if (!SWIG_IsOK(res2)) {
20825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20826 }
20827 if (!argp2) {
20828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20829 }
20830 arg2 = reinterpret_cast< wxEvent * >(argp2);
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 (arg1)->AddPendingEvent(*arg2);
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 resultobj = SWIG_Py_Void();
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20845 PyObject *resultobj = 0;
20846 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20847 void *argp1 = 0 ;
20848 int res1 = 0 ;
20849 PyObject *swig_obj[1] ;
20850
20851 if (!args) SWIG_fail;
20852 swig_obj[0] = args;
20853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20854 if (!SWIG_IsOK(res1)) {
20855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20856 }
20857 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 (arg1)->ProcessPendingEvents();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_Py_Void();
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj = 0;
20873 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20874 int arg2 ;
20875 int arg3 ;
20876 int arg4 ;
20877 PyObject *arg5 = (PyObject *) 0 ;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 int val2 ;
20881 int ecode2 = 0 ;
20882 int val3 ;
20883 int ecode3 = 0 ;
20884 int val4 ;
20885 int ecode4 = 0 ;
20886 PyObject * obj0 = 0 ;
20887 PyObject * obj1 = 0 ;
20888 PyObject * obj2 = 0 ;
20889 PyObject * obj3 = 0 ;
20890 PyObject * obj4 = 0 ;
20891 char * kwnames[] = {
20892 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20893 };
20894
20895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20899 }
20900 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20901 ecode2 = SWIG_AsVal_int(obj1, &val2);
20902 if (!SWIG_IsOK(ecode2)) {
20903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20904 }
20905 arg2 = static_cast< int >(val2);
20906 ecode3 = SWIG_AsVal_int(obj2, &val3);
20907 if (!SWIG_IsOK(ecode3)) {
20908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20909 }
20910 arg3 = static_cast< int >(val3);
20911 ecode4 = SWIG_AsVal_int(obj3, &val4);
20912 if (!SWIG_IsOK(ecode4)) {
20913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20914 }
20915 arg4 = static_cast< int >(val4);
20916 arg5 = obj4;
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_Py_Void();
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20931 PyObject *resultobj = 0;
20932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20933 int arg2 ;
20934 int arg3 = (int) -1 ;
20935 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20936 bool result;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 int val2 ;
20940 int ecode2 = 0 ;
20941 int val3 ;
20942 int ecode3 = 0 ;
20943 int val4 ;
20944 int ecode4 = 0 ;
20945 PyObject * obj0 = 0 ;
20946 PyObject * obj1 = 0 ;
20947 PyObject * obj2 = 0 ;
20948 PyObject * obj3 = 0 ;
20949 char * kwnames[] = {
20950 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20951 };
20952
20953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20955 if (!SWIG_IsOK(res1)) {
20956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20957 }
20958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20959 ecode2 = SWIG_AsVal_int(obj1, &val2);
20960 if (!SWIG_IsOK(ecode2)) {
20961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20962 }
20963 arg2 = static_cast< int >(val2);
20964 if (obj2) {
20965 ecode3 = SWIG_AsVal_int(obj2, &val3);
20966 if (!SWIG_IsOK(ecode3)) {
20967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20968 }
20969 arg3 = static_cast< int >(val3);
20970 }
20971 if (obj3) {
20972 ecode4 = SWIG_AsVal_int(obj3, &val4);
20973 if (!SWIG_IsOK(ecode4)) {
20974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20975 }
20976 arg4 = static_cast< wxEventType >(val4);
20977 }
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 {
20985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20986 }
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj = 0;
20995 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20996 PyObject *arg2 = (PyObject *) 0 ;
20997 bool arg3 = (bool) true ;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 bool val3 ;
21001 int ecode3 = 0 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 PyObject * obj2 = 0 ;
21005 char * kwnames[] = {
21006 (char *) "self",(char *) "_self",(char *) "incref", NULL
21007 };
21008
21009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21013 }
21014 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21015 arg2 = obj1;
21016 if (obj2) {
21017 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21018 if (!SWIG_IsOK(ecode3)) {
21019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21020 }
21021 arg3 = static_cast< bool >(val3);
21022 }
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21026 wxPyEndAllowThreads(__tstate);
21027 if (PyErr_Occurred()) SWIG_fail;
21028 }
21029 resultobj = SWIG_Py_Void();
21030 return resultobj;
21031 fail:
21032 return NULL;
21033 }
21034
21035
21036 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21037 PyObject *obj;
21038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21039 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21040 return SWIG_Py_Void();
21041 }
21042
21043 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 return SWIG_Python_InitShadowInstance(args);
21045 }
21046
21047 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxEventType result;
21050
21051 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (wxEventType)wxNewEventType();
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = SWIG_From_int(static_cast< int >(result));
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21066 PyObject *resultobj = 0;
21067 wxEvent *arg1 = (wxEvent *) 0 ;
21068 void *argp1 = 0 ;
21069 int res1 = 0 ;
21070 PyObject *swig_obj[1] ;
21071
21072 if (!args) SWIG_fail;
21073 swig_obj[0] = args;
21074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21075 if (!SWIG_IsOK(res1)) {
21076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21077 }
21078 arg1 = reinterpret_cast< wxEvent * >(argp1);
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 delete arg1;
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 resultobj = SWIG_Py_Void();
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj = 0;
21095 wxEvent *arg1 = (wxEvent *) 0 ;
21096 wxEventType arg2 ;
21097 void *argp1 = 0 ;
21098 int res1 = 0 ;
21099 int val2 ;
21100 int ecode2 = 0 ;
21101 PyObject * obj0 = 0 ;
21102 PyObject * obj1 = 0 ;
21103 char * kwnames[] = {
21104 (char *) "self",(char *) "typ", NULL
21105 };
21106
21107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21111 }
21112 arg1 = reinterpret_cast< wxEvent * >(argp1);
21113 ecode2 = SWIG_AsVal_int(obj1, &val2);
21114 if (!SWIG_IsOK(ecode2)) {
21115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21116 }
21117 arg2 = static_cast< wxEventType >(val2);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 (arg1)->SetEventType(arg2);
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_Py_Void();
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxEvent *arg1 = (wxEvent *) 0 ;
21134 wxEventType result;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxEvent * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 resultobj = SWIG_From_int(static_cast< int >(result));
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 PyObject *resultobj = 0;
21161 wxEvent *arg1 = (wxEvent *) 0 ;
21162 wxObject *result = 0 ;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 PyObject *swig_obj[1] ;
21166
21167 if (!args) SWIG_fail;
21168 swig_obj[0] = args;
21169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21172 }
21173 arg1 = reinterpret_cast< wxEvent * >(argp1);
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 {
21181 resultobj = wxPyMake_wxObject(result, (bool)0);
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj = 0;
21191 wxEvent *arg1 = (wxEvent *) 0 ;
21192 wxObject *arg2 = (wxObject *) 0 ;
21193 void *argp1 = 0 ;
21194 int res1 = 0 ;
21195 void *argp2 = 0 ;
21196 int res2 = 0 ;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 char * kwnames[] = {
21200 (char *) "self",(char *) "obj", NULL
21201 };
21202
21203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21205 if (!SWIG_IsOK(res1)) {
21206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21207 }
21208 arg1 = reinterpret_cast< wxEvent * >(argp1);
21209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21210 if (!SWIG_IsOK(res2)) {
21211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21212 }
21213 arg2 = reinterpret_cast< wxObject * >(argp2);
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 (arg1)->SetEventObject(arg2);
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxEvent *arg1 = (wxEvent *) 0 ;
21230 long result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21240 }
21241 arg1 = reinterpret_cast< wxEvent * >(argp1);
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 resultobj = SWIG_From_long(static_cast< long >(result));
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21256 PyObject *resultobj = 0;
21257 wxEvent *arg1 = (wxEvent *) 0 ;
21258 long arg2 = (long) 0 ;
21259 void *argp1 = 0 ;
21260 int res1 = 0 ;
21261 long val2 ;
21262 int ecode2 = 0 ;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char * kwnames[] = {
21266 (char *) "self",(char *) "ts", NULL
21267 };
21268
21269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21273 }
21274 arg1 = reinterpret_cast< wxEvent * >(argp1);
21275 if (obj1) {
21276 ecode2 = SWIG_AsVal_long(obj1, &val2);
21277 if (!SWIG_IsOK(ecode2)) {
21278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21279 }
21280 arg2 = static_cast< long >(val2);
21281 }
21282 {
21283 PyThreadState* __tstate = wxPyBeginAllowThreads();
21284 (arg1)->SetTimestamp(arg2);
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 resultobj = SWIG_Py_Void();
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxEvent *arg1 = (wxEvent *) 0 ;
21298 int result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 PyObject *swig_obj[1] ;
21302
21303 if (!args) SWIG_fail;
21304 swig_obj[0] = args;
21305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21306 if (!SWIG_IsOK(res1)) {
21307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21308 }
21309 arg1 = reinterpret_cast< wxEvent * >(argp1);
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (int)((wxEvent const *)arg1)->GetId();
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 resultobj = SWIG_From_int(static_cast< int >(result));
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj = 0;
21325 wxEvent *arg1 = (wxEvent *) 0 ;
21326 int arg2 ;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 int val2 ;
21330 int ecode2 = 0 ;
21331 PyObject * obj0 = 0 ;
21332 PyObject * obj1 = 0 ;
21333 char * kwnames[] = {
21334 (char *) "self",(char *) "Id", NULL
21335 };
21336
21337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21339 if (!SWIG_IsOK(res1)) {
21340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21341 }
21342 arg1 = reinterpret_cast< wxEvent * >(argp1);
21343 ecode2 = SWIG_AsVal_int(obj1, &val2);
21344 if (!SWIG_IsOK(ecode2)) {
21345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21346 }
21347 arg2 = static_cast< int >(val2);
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 (arg1)->SetId(arg2);
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_Py_Void();
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxEvent *arg1 = (wxEvent *) 0 ;
21364 bool result;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 PyObject *swig_obj[1] ;
21368
21369 if (!args) SWIG_fail;
21370 swig_obj[0] = args;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21374 }
21375 arg1 = reinterpret_cast< wxEvent * >(argp1);
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 {
21383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21384 }
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj = 0;
21393 wxEvent *arg1 = (wxEvent *) 0 ;
21394 bool arg2 = (bool) true ;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 bool val2 ;
21398 int ecode2 = 0 ;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char * kwnames[] = {
21402 (char *) "self",(char *) "skip", NULL
21403 };
21404
21405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21407 if (!SWIG_IsOK(res1)) {
21408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21409 }
21410 arg1 = reinterpret_cast< wxEvent * >(argp1);
21411 if (obj1) {
21412 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21413 if (!SWIG_IsOK(ecode2)) {
21414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21415 }
21416 arg2 = static_cast< bool >(val2);
21417 }
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 (arg1)->Skip(arg2);
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 resultobj = SWIG_Py_Void();
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21432 PyObject *resultobj = 0;
21433 wxEvent *arg1 = (wxEvent *) 0 ;
21434 bool result;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 PyObject *swig_obj[1] ;
21438
21439 if (!args) SWIG_fail;
21440 swig_obj[0] = args;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21444 }
21445 arg1 = reinterpret_cast< wxEvent * >(argp1);
21446 {
21447 PyThreadState* __tstate = wxPyBeginAllowThreads();
21448 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21449 wxPyEndAllowThreads(__tstate);
21450 if (PyErr_Occurred()) SWIG_fail;
21451 }
21452 {
21453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21454 }
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21462 PyObject *resultobj = 0;
21463 wxEvent *arg1 = (wxEvent *) 0 ;
21464 bool result;
21465 void *argp1 = 0 ;
21466 int res1 = 0 ;
21467 PyObject *swig_obj[1] ;
21468
21469 if (!args) SWIG_fail;
21470 swig_obj[0] = args;
21471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21472 if (!SWIG_IsOK(res1)) {
21473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21474 }
21475 arg1 = reinterpret_cast< wxEvent * >(argp1);
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21479 wxPyEndAllowThreads(__tstate);
21480 if (PyErr_Occurred()) SWIG_fail;
21481 }
21482 {
21483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21484 }
21485 return resultobj;
21486 fail:
21487 return NULL;
21488 }
21489
21490
21491 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21492 PyObject *resultobj = 0;
21493 wxEvent *arg1 = (wxEvent *) 0 ;
21494 int result;
21495 void *argp1 = 0 ;
21496 int res1 = 0 ;
21497 PyObject *swig_obj[1] ;
21498
21499 if (!args) SWIG_fail;
21500 swig_obj[0] = args;
21501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21502 if (!SWIG_IsOK(res1)) {
21503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21504 }
21505 arg1 = reinterpret_cast< wxEvent * >(argp1);
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (int)(arg1)->StopPropagation();
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 resultobj = SWIG_From_int(static_cast< int >(result));
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj = 0;
21521 wxEvent *arg1 = (wxEvent *) 0 ;
21522 int arg2 ;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 int val2 ;
21526 int ecode2 = 0 ;
21527 PyObject * obj0 = 0 ;
21528 PyObject * obj1 = 0 ;
21529 char * kwnames[] = {
21530 (char *) "self",(char *) "propagationLevel", NULL
21531 };
21532
21533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxEvent * >(argp1);
21539 ecode2 = SWIG_AsVal_int(obj1, &val2);
21540 if (!SWIG_IsOK(ecode2)) {
21541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21542 }
21543 arg2 = static_cast< int >(val2);
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 (arg1)->ResumePropagation(arg2);
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxEvent *arg1 = (wxEvent *) 0 ;
21560 wxEvent *result = 0 ;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxEvent * >(argp1);
21572 {
21573 PyThreadState* __tstate = wxPyBeginAllowThreads();
21574 result = (wxEvent *)(arg1)->Clone();
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21586 PyObject *obj;
21587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21588 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21589 return SWIG_Py_Void();
21590 }
21591
21592 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj = 0;
21594 wxEvent *arg1 = 0 ;
21595 wxPropagationDisabler *result = 0 ;
21596 void *argp1 = 0 ;
21597 int res1 = 0 ;
21598 PyObject * obj0 = 0 ;
21599 char * kwnames[] = {
21600 (char *) "event", NULL
21601 };
21602
21603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21604 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21605 if (!SWIG_IsOK(res1)) {
21606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21607 }
21608 if (!argp1) {
21609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21610 }
21611 arg1 = reinterpret_cast< wxEvent * >(argp1);
21612 {
21613 PyThreadState* __tstate = wxPyBeginAllowThreads();
21614 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21615 wxPyEndAllowThreads(__tstate);
21616 if (PyErr_Occurred()) SWIG_fail;
21617 }
21618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21619 return resultobj;
21620 fail:
21621 return NULL;
21622 }
21623
21624
21625 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21626 PyObject *resultobj = 0;
21627 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21628 void *argp1 = 0 ;
21629 int res1 = 0 ;
21630 PyObject *swig_obj[1] ;
21631
21632 if (!args) SWIG_fail;
21633 swig_obj[0] = args;
21634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21637 }
21638 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 delete arg1;
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_Py_Void();
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21654 PyObject *obj;
21655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21656 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21657 return SWIG_Py_Void();
21658 }
21659
21660 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661 return SWIG_Python_InitShadowInstance(args);
21662 }
21663
21664 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21665 PyObject *resultobj = 0;
21666 wxEvent *arg1 = 0 ;
21667 wxPropagateOnce *result = 0 ;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 PyObject * obj0 = 0 ;
21671 char * kwnames[] = {
21672 (char *) "event", NULL
21673 };
21674
21675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21676 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21679 }
21680 if (!argp1) {
21681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21682 }
21683 arg1 = reinterpret_cast< wxEvent * >(argp1);
21684 {
21685 PyThreadState* __tstate = wxPyBeginAllowThreads();
21686 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21687 wxPyEndAllowThreads(__tstate);
21688 if (PyErr_Occurred()) SWIG_fail;
21689 }
21690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21691 return resultobj;
21692 fail:
21693 return NULL;
21694 }
21695
21696
21697 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21698 PyObject *resultobj = 0;
21699 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21709 }
21710 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 delete arg1;
21714
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 resultobj = SWIG_Py_Void();
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *obj;
21727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21728 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21729 return SWIG_Py_Void();
21730 }
21731
21732 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 return SWIG_Python_InitShadowInstance(args);
21734 }
21735
21736 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21739 int arg2 = (int) 0 ;
21740 wxCommandEvent *result = 0 ;
21741 int val1 ;
21742 int ecode1 = 0 ;
21743 int val2 ;
21744 int ecode2 = 0 ;
21745 PyObject * obj0 = 0 ;
21746 PyObject * obj1 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "commandType",(char *) "winid", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21752 if (obj0) {
21753 ecode1 = SWIG_AsVal_int(obj0, &val1);
21754 if (!SWIG_IsOK(ecode1)) {
21755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21756 }
21757 arg1 = static_cast< wxEventType >(val1);
21758 }
21759 if (obj1) {
21760 ecode2 = SWIG_AsVal_int(obj1, &val2);
21761 if (!SWIG_IsOK(ecode2)) {
21762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21763 }
21764 arg2 = static_cast< int >(val2);
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21782 int result;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21792 }
21793 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 resultobj = SWIG_From_int(static_cast< int >(result));
21801 return resultobj;
21802 fail:
21803 return NULL;
21804 }
21805
21806
21807 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21808 PyObject *resultobj = 0;
21809 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21810 wxString *arg2 = 0 ;
21811 void *argp1 = 0 ;
21812 int res1 = 0 ;
21813 bool temp2 = false ;
21814 PyObject * obj0 = 0 ;
21815 PyObject * obj1 = 0 ;
21816 char * kwnames[] = {
21817 (char *) "self",(char *) "s", NULL
21818 };
21819
21820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21824 }
21825 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21826 {
21827 arg2 = wxString_in_helper(obj1);
21828 if (arg2 == NULL) SWIG_fail;
21829 temp2 = true;
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->SetString((wxString const &)*arg2);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_Py_Void();
21838 {
21839 if (temp2)
21840 delete arg2;
21841 }
21842 return resultobj;
21843 fail:
21844 {
21845 if (temp2)
21846 delete arg2;
21847 }
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 PyObject *resultobj = 0;
21854 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21855 wxString result;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 PyObject *swig_obj[1] ;
21859
21860 if (!args) SWIG_fail;
21861 swig_obj[0] = args;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21865 }
21866 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = ((wxCommandEvent const *)arg1)->GetString();
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 {
21874 #if wxUSE_UNICODE
21875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21876 #else
21877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21878 #endif
21879 }
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21889 bool result;
21890 void *argp1 = 0 ;
21891 int res1 = 0 ;
21892 PyObject *swig_obj[1] ;
21893
21894 if (!args) SWIG_fail;
21895 swig_obj[0] = args;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21899 }
21900 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21919 bool result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21929 }
21930 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21947 PyObject *resultobj = 0;
21948 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21949 long arg2 ;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 long val2 ;
21953 int ecode2 = 0 ;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char * kwnames[] = {
21957 (char *) "self",(char *) "extraLong", NULL
21958 };
21959
21960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21964 }
21965 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21966 ecode2 = SWIG_AsVal_long(obj1, &val2);
21967 if (!SWIG_IsOK(ecode2)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21969 }
21970 arg2 = static_cast< long >(val2);
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 (arg1)->SetExtraLong(arg2);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_Py_Void();
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21987 long result;
21988 void *argp1 = 0 ;
21989 int res1 = 0 ;
21990 PyObject *swig_obj[1] ;
21991
21992 if (!args) SWIG_fail;
21993 swig_obj[0] = args;
21994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21995 if (!SWIG_IsOK(res1)) {
21996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21997 }
21998 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 resultobj = SWIG_From_long(static_cast< long >(result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj = 0;
22014 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22015 int arg2 ;
22016 void *argp1 = 0 ;
22017 int res1 = 0 ;
22018 int val2 ;
22019 int ecode2 = 0 ;
22020 PyObject * obj0 = 0 ;
22021 PyObject * obj1 = 0 ;
22022 char * kwnames[] = {
22023 (char *) "self",(char *) "i", NULL
22024 };
22025
22026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22030 }
22031 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22032 ecode2 = SWIG_AsVal_int(obj1, &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22035 }
22036 arg2 = static_cast< int >(val2);
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 (arg1)->SetInt(arg2);
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22053 int result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22063 }
22064 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 resultobj = SWIG_From_int(static_cast< int >(result));
22072 return resultobj;
22073 fail:
22074 return NULL;
22075 }
22076
22077
22078 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22079 PyObject *resultobj = 0;
22080 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22081 PyObject *result = 0 ;
22082 void *argp1 = 0 ;
22083 int res1 = 0 ;
22084 PyObject *swig_obj[1] ;
22085
22086 if (!args) SWIG_fail;
22087 swig_obj[0] = args;
22088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22089 if (!SWIG_IsOK(res1)) {
22090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22091 }
22092 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 resultobj = result;
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj = 0;
22108 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22109 PyObject *arg2 = (PyObject *) 0 ;
22110 void *argp1 = 0 ;
22111 int res1 = 0 ;
22112 PyObject * obj0 = 0 ;
22113 PyObject * obj1 = 0 ;
22114 char * kwnames[] = {
22115 (char *) "self",(char *) "clientData", NULL
22116 };
22117
22118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22120 if (!SWIG_IsOK(res1)) {
22121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22122 }
22123 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22124 arg2 = obj1;
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 wxCommandEvent_SetClientData(arg1,arg2);
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 resultobj = SWIG_Py_Void();
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *resultobj = 0;
22140 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22141 wxEvent *result = 0 ;
22142 void *argp1 = 0 ;
22143 int res1 = 0 ;
22144 PyObject *swig_obj[1] ;
22145
22146 if (!args) SWIG_fail;
22147 swig_obj[0] = args;
22148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22149 if (!SWIG_IsOK(res1)) {
22150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22151 }
22152 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167 PyObject *obj;
22168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22169 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22170 return SWIG_Py_Void();
22171 }
22172
22173 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22174 return SWIG_Python_InitShadowInstance(args);
22175 }
22176
22177 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj = 0;
22179 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22180 int arg2 = (int) 0 ;
22181 wxNotifyEvent *result = 0 ;
22182 int val1 ;
22183 int ecode1 = 0 ;
22184 int val2 ;
22185 int ecode2 = 0 ;
22186 PyObject * obj0 = 0 ;
22187 PyObject * obj1 = 0 ;
22188 char * kwnames[] = {
22189 (char *) "commandType",(char *) "winid", NULL
22190 };
22191
22192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22193 if (obj0) {
22194 ecode1 = SWIG_AsVal_int(obj0, &val1);
22195 if (!SWIG_IsOK(ecode1)) {
22196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22197 }
22198 arg1 = static_cast< wxEventType >(val1);
22199 }
22200 if (obj1) {
22201 ecode2 = SWIG_AsVal_int(obj1, &val2);
22202 if (!SWIG_IsOK(ecode2)) {
22203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22204 }
22205 arg2 = static_cast< int >(val2);
22206 }
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22223 void *argp1 = 0 ;
22224 int res1 = 0 ;
22225 PyObject *swig_obj[1] ;
22226
22227 if (!args) SWIG_fail;
22228 swig_obj[0] = args;
22229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22230 if (!SWIG_IsOK(res1)) {
22231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22232 }
22233 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 (arg1)->Veto();
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 resultobj = SWIG_Py_Void();
22241 return resultobj;
22242 fail:
22243 return NULL;
22244 }
22245
22246
22247 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22248 PyObject *resultobj = 0;
22249 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22250 void *argp1 = 0 ;
22251 int res1 = 0 ;
22252 PyObject *swig_obj[1] ;
22253
22254 if (!args) SWIG_fail;
22255 swig_obj[0] = args;
22256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22257 if (!SWIG_IsOK(res1)) {
22258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22259 }
22260 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 (arg1)->Allow();
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 resultobj = SWIG_Py_Void();
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22275 PyObject *resultobj = 0;
22276 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22277 bool result;
22278 void *argp1 = 0 ;
22279 int res1 = 0 ;
22280 PyObject *swig_obj[1] ;
22281
22282 if (!args) SWIG_fail;
22283 swig_obj[0] = args;
22284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22285 if (!SWIG_IsOK(res1)) {
22286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22287 }
22288 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = (bool)(arg1)->IsAllowed();
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 {
22296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22297 }
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22305 PyObject *obj;
22306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22307 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22308 return SWIG_Py_Void();
22309 }
22310
22311 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 return SWIG_Python_InitShadowInstance(args);
22313 }
22314
22315 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22316 PyObject *resultobj = 0;
22317 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22318 int arg2 = (int) 0 ;
22319 int arg3 = (int) 0 ;
22320 int arg4 = (int) 0 ;
22321 wxScrollEvent *result = 0 ;
22322 int val1 ;
22323 int ecode1 = 0 ;
22324 int val2 ;
22325 int ecode2 = 0 ;
22326 int val3 ;
22327 int ecode3 = 0 ;
22328 int val4 ;
22329 int ecode4 = 0 ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 PyObject * obj2 = 0 ;
22333 PyObject * obj3 = 0 ;
22334 char * kwnames[] = {
22335 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22336 };
22337
22338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22339 if (obj0) {
22340 ecode1 = SWIG_AsVal_int(obj0, &val1);
22341 if (!SWIG_IsOK(ecode1)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22343 }
22344 arg1 = static_cast< wxEventType >(val1);
22345 }
22346 if (obj1) {
22347 ecode2 = SWIG_AsVal_int(obj1, &val2);
22348 if (!SWIG_IsOK(ecode2)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22350 }
22351 arg2 = static_cast< int >(val2);
22352 }
22353 if (obj2) {
22354 ecode3 = SWIG_AsVal_int(obj2, &val3);
22355 if (!SWIG_IsOK(ecode3)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22357 }
22358 arg3 = static_cast< int >(val3);
22359 }
22360 if (obj3) {
22361 ecode4 = SWIG_AsVal_int(obj3, &val4);
22362 if (!SWIG_IsOK(ecode4)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22364 }
22365 arg4 = static_cast< int >(val4);
22366 }
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22383 int result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22393 }
22394 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 resultobj = SWIG_From_int(static_cast< int >(result));
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22409 PyObject *resultobj = 0;
22410 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22411 int result;
22412 void *argp1 = 0 ;
22413 int res1 = 0 ;
22414 PyObject *swig_obj[1] ;
22415
22416 if (!args) SWIG_fail;
22417 swig_obj[0] = args;
22418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22419 if (!SWIG_IsOK(res1)) {
22420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22421 }
22422 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_From_int(static_cast< int >(result));
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22437 PyObject *resultobj = 0;
22438 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22439 int arg2 ;
22440 void *argp1 = 0 ;
22441 int res1 = 0 ;
22442 int val2 ;
22443 int ecode2 = 0 ;
22444 PyObject * obj0 = 0 ;
22445 PyObject * obj1 = 0 ;
22446 char * kwnames[] = {
22447 (char *) "self",(char *) "orient", NULL
22448 };
22449
22450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22454 }
22455 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22456 ecode2 = SWIG_AsVal_int(obj1, &val2);
22457 if (!SWIG_IsOK(ecode2)) {
22458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22459 }
22460 arg2 = static_cast< int >(val2);
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 (arg1)->SetOrientation(arg2);
22464 wxPyEndAllowThreads(__tstate);
22465 if (PyErr_Occurred()) SWIG_fail;
22466 }
22467 resultobj = SWIG_Py_Void();
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj = 0;
22476 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22477 int arg2 ;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 int val2 ;
22481 int ecode2 = 0 ;
22482 PyObject * obj0 = 0 ;
22483 PyObject * obj1 = 0 ;
22484 char * kwnames[] = {
22485 (char *) "self",(char *) "pos", NULL
22486 };
22487
22488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22492 }
22493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22494 ecode2 = SWIG_AsVal_int(obj1, &val2);
22495 if (!SWIG_IsOK(ecode2)) {
22496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22497 }
22498 arg2 = static_cast< int >(val2);
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 (arg1)->SetPosition(arg2);
22502 wxPyEndAllowThreads(__tstate);
22503 if (PyErr_Occurred()) SWIG_fail;
22504 }
22505 resultobj = SWIG_Py_Void();
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 PyObject *obj;
22514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22515 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22516 return SWIG_Py_Void();
22517 }
22518
22519 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520 return SWIG_Python_InitShadowInstance(args);
22521 }
22522
22523 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22526 int arg2 = (int) 0 ;
22527 int arg3 = (int) 0 ;
22528 wxScrollWinEvent *result = 0 ;
22529 int val1 ;
22530 int ecode1 = 0 ;
22531 int val2 ;
22532 int ecode2 = 0 ;
22533 int val3 ;
22534 int ecode3 = 0 ;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 PyObject * obj2 = 0 ;
22538 char * kwnames[] = {
22539 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22540 };
22541
22542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22543 if (obj0) {
22544 ecode1 = SWIG_AsVal_int(obj0, &val1);
22545 if (!SWIG_IsOK(ecode1)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22547 }
22548 arg1 = static_cast< wxEventType >(val1);
22549 }
22550 if (obj1) {
22551 ecode2 = SWIG_AsVal_int(obj1, &val2);
22552 if (!SWIG_IsOK(ecode2)) {
22553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22554 }
22555 arg2 = static_cast< int >(val2);
22556 }
22557 if (obj2) {
22558 ecode3 = SWIG_AsVal_int(obj2, &val3);
22559 if (!SWIG_IsOK(ecode3)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22561 }
22562 arg3 = static_cast< int >(val3);
22563 }
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22578 PyObject *resultobj = 0;
22579 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22580 int result;
22581 void *argp1 = 0 ;
22582 int res1 = 0 ;
22583 PyObject *swig_obj[1] ;
22584
22585 if (!args) SWIG_fail;
22586 swig_obj[0] = args;
22587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22590 }
22591 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22592 {
22593 PyThreadState* __tstate = wxPyBeginAllowThreads();
22594 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22595 wxPyEndAllowThreads(__tstate);
22596 if (PyErr_Occurred()) SWIG_fail;
22597 }
22598 resultobj = SWIG_From_int(static_cast< int >(result));
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22606 PyObject *resultobj = 0;
22607 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22608 int result;
22609 void *argp1 = 0 ;
22610 int res1 = 0 ;
22611 PyObject *swig_obj[1] ;
22612
22613 if (!args) SWIG_fail;
22614 swig_obj[0] = args;
22615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22616 if (!SWIG_IsOK(res1)) {
22617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22618 }
22619 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_From_int(static_cast< int >(result));
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj = 0;
22635 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22636 int arg2 ;
22637 void *argp1 = 0 ;
22638 int res1 = 0 ;
22639 int val2 ;
22640 int ecode2 = 0 ;
22641 PyObject * obj0 = 0 ;
22642 PyObject * obj1 = 0 ;
22643 char * kwnames[] = {
22644 (char *) "self",(char *) "orient", NULL
22645 };
22646
22647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22649 if (!SWIG_IsOK(res1)) {
22650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22651 }
22652 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22653 ecode2 = SWIG_AsVal_int(obj1, &val2);
22654 if (!SWIG_IsOK(ecode2)) {
22655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22656 }
22657 arg2 = static_cast< int >(val2);
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 (arg1)->SetOrientation(arg2);
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 resultobj = SWIG_Py_Void();
22665 return resultobj;
22666 fail:
22667 return NULL;
22668 }
22669
22670
22671 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22672 PyObject *resultobj = 0;
22673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22674 int arg2 ;
22675 void *argp1 = 0 ;
22676 int res1 = 0 ;
22677 int val2 ;
22678 int ecode2 = 0 ;
22679 PyObject * obj0 = 0 ;
22680 PyObject * obj1 = 0 ;
22681 char * kwnames[] = {
22682 (char *) "self",(char *) "pos", NULL
22683 };
22684
22685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22689 }
22690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22691 ecode2 = SWIG_AsVal_int(obj1, &val2);
22692 if (!SWIG_IsOK(ecode2)) {
22693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22694 }
22695 arg2 = static_cast< int >(val2);
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 (arg1)->SetPosition(arg2);
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 resultobj = SWIG_Py_Void();
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *obj;
22711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22712 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22713 return SWIG_Py_Void();
22714 }
22715
22716 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 return SWIG_Python_InitShadowInstance(args);
22718 }
22719
22720 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj = 0;
22722 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22723 wxMouseEvent *result = 0 ;
22724 int val1 ;
22725 int ecode1 = 0 ;
22726 PyObject * obj0 = 0 ;
22727 char * kwnames[] = {
22728 (char *) "mouseType", NULL
22729 };
22730
22731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22732 if (obj0) {
22733 ecode1 = SWIG_AsVal_int(obj0, &val1);
22734 if (!SWIG_IsOK(ecode1)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22736 }
22737 arg1 = static_cast< wxEventType >(val1);
22738 }
22739 {
22740 PyThreadState* __tstate = wxPyBeginAllowThreads();
22741 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22753 PyObject *resultobj = 0;
22754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22755 bool result;
22756 void *argp1 = 0 ;
22757 int res1 = 0 ;
22758 PyObject *swig_obj[1] ;
22759
22760 if (!args) SWIG_fail;
22761 swig_obj[0] = args;
22762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22763 if (!SWIG_IsOK(res1)) {
22764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22765 }
22766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22770 wxPyEndAllowThreads(__tstate);
22771 if (PyErr_Occurred()) SWIG_fail;
22772 }
22773 {
22774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22775 }
22776 return resultobj;
22777 fail:
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22783 PyObject *resultobj = 0;
22784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22785 int arg2 = (int) wxMOUSE_BTN_ANY ;
22786 bool result;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 int val2 ;
22790 int ecode2 = 0 ;
22791 PyObject * obj0 = 0 ;
22792 PyObject * obj1 = 0 ;
22793 char * kwnames[] = {
22794 (char *) "self",(char *) "but", NULL
22795 };
22796
22797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22801 }
22802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22803 if (obj1) {
22804 ecode2 = SWIG_AsVal_int(obj1, &val2);
22805 if (!SWIG_IsOK(ecode2)) {
22806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22807 }
22808 arg2 = static_cast< int >(val2);
22809 }
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22826 PyObject *resultobj = 0;
22827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22828 int arg2 = (int) wxMOUSE_BTN_ANY ;
22829 bool result;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 int val2 ;
22833 int ecode2 = 0 ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char * kwnames[] = {
22837 (char *) "self",(char *) "but", NULL
22838 };
22839
22840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22842 if (!SWIG_IsOK(res1)) {
22843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22844 }
22845 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22846 if (obj1) {
22847 ecode2 = SWIG_AsVal_int(obj1, &val2);
22848 if (!SWIG_IsOK(ecode2)) {
22849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22850 }
22851 arg2 = static_cast< int >(val2);
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22869 PyObject *resultobj = 0;
22870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22871 int arg2 = (int) wxMOUSE_BTN_ANY ;
22872 bool result;
22873 void *argp1 = 0 ;
22874 int res1 = 0 ;
22875 int val2 ;
22876 int ecode2 = 0 ;
22877 PyObject * obj0 = 0 ;
22878 PyObject * obj1 = 0 ;
22879 char * kwnames[] = {
22880 (char *) "self",(char *) "but", NULL
22881 };
22882
22883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22887 }
22888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22889 if (obj1) {
22890 ecode2 = SWIG_AsVal_int(obj1, &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22893 }
22894 arg2 = static_cast< int >(val2);
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 {
22903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj = 0;
22913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22914 int arg2 ;
22915 bool result;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char * kwnames[] = {
22923 (char *) "self",(char *) "button", NULL
22924 };
22925
22926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22928 if (!SWIG_IsOK(res1)) {
22929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22930 }
22931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22932 ecode2 = SWIG_AsVal_int(obj1, &val2);
22933 if (!SWIG_IsOK(ecode2)) {
22934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22935 }
22936 arg2 = static_cast< int >(val2);
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 {
22944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22945 }
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22953 PyObject *resultobj = 0;
22954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22955 int arg2 ;
22956 bool result;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 int val2 ;
22960 int ecode2 = 0 ;
22961 PyObject * obj0 = 0 ;
22962 PyObject * obj1 = 0 ;
22963 char * kwnames[] = {
22964 (char *) "self",(char *) "but", NULL
22965 };
22966
22967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22971 }
22972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22973 ecode2 = SWIG_AsVal_int(obj1, &val2);
22974 if (!SWIG_IsOK(ecode2)) {
22975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22976 }
22977 arg2 = static_cast< int >(val2);
22978 {
22979 PyThreadState* __tstate = wxPyBeginAllowThreads();
22980 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22994 PyObject *resultobj = 0;
22995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22996 int result;
22997 void *argp1 = 0 ;
22998 int res1 = 0 ;
22999 PyObject *swig_obj[1] ;
23000
23001 if (!args) SWIG_fail;
23002 swig_obj[0] = args;
23003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23006 }
23007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 resultobj = SWIG_From_int(static_cast< int >(result));
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23022 PyObject *resultobj = 0;
23023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23024 bool result;
23025 void *argp1 = 0 ;
23026 int res1 = 0 ;
23027 PyObject *swig_obj[1] ;
23028
23029 if (!args) SWIG_fail;
23030 swig_obj[0] = args;
23031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23034 }
23035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23036 {
23037 PyThreadState* __tstate = wxPyBeginAllowThreads();
23038 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23039 wxPyEndAllowThreads(__tstate);
23040 if (PyErr_Occurred()) SWIG_fail;
23041 }
23042 {
23043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23044 }
23045 return resultobj;
23046 fail:
23047 return NULL;
23048 }
23049
23050
23051 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23052 PyObject *resultobj = 0;
23053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23054 bool result;
23055 void *argp1 = 0 ;
23056 int res1 = 0 ;
23057 PyObject *swig_obj[1] ;
23058
23059 if (!args) SWIG_fail;
23060 swig_obj[0] = args;
23061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23062 if (!SWIG_IsOK(res1)) {
23063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23064 }
23065 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23069 wxPyEndAllowThreads(__tstate);
23070 if (PyErr_Occurred()) SWIG_fail;
23071 }
23072 {
23073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23084 bool result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23104 }
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23112 PyObject *resultobj = 0;
23113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23114 bool result;
23115 void *argp1 = 0 ;
23116 int res1 = 0 ;
23117 PyObject *swig_obj[1] ;
23118
23119 if (!args) SWIG_fail;
23120 swig_obj[0] = args;
23121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23122 if (!SWIG_IsOK(res1)) {
23123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23124 }
23125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23129 wxPyEndAllowThreads(__tstate);
23130 if (PyErr_Occurred()) SWIG_fail;
23131 }
23132 {
23133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23134 }
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 PyObject *resultobj = 0;
23143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23144 bool result;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 PyObject *swig_obj[1] ;
23148
23149 if (!args) SWIG_fail;
23150 swig_obj[0] = args;
23151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23154 }
23155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 {
23163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23164 }
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23174 bool result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23184 }
23185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 {
23193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23194 }
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23202 PyObject *resultobj = 0;
23203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23204 bool result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 PyObject *swig_obj[1] ;
23208
23209 if (!args) SWIG_fail;
23210 swig_obj[0] = args;
23211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23214 }
23215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 {
23223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23224 }
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 PyObject *resultobj = 0;
23233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23234 bool result;
23235 void *argp1 = 0 ;
23236 int res1 = 0 ;
23237 PyObject *swig_obj[1] ;
23238
23239 if (!args) SWIG_fail;
23240 swig_obj[0] = args;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23244 }
23245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 {
23253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23254 }
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23262 PyObject *resultobj = 0;
23263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23264 bool result;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 PyObject *swig_obj[1] ;
23268
23269 if (!args) SWIG_fail;
23270 swig_obj[0] = args;
23271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23274 }
23275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23276 {
23277 PyThreadState* __tstate = wxPyBeginAllowThreads();
23278 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23279 wxPyEndAllowThreads(__tstate);
23280 if (PyErr_Occurred()) SWIG_fail;
23281 }
23282 {
23283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23284 }
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23292 PyObject *resultobj = 0;
23293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23294 bool result;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 PyObject *swig_obj[1] ;
23298
23299 if (!args) SWIG_fail;
23300 swig_obj[0] = args;
23301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23302 if (!SWIG_IsOK(res1)) {
23303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23304 }
23305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 {
23313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23314 }
23315 return resultobj;
23316 fail:
23317 return NULL;
23318 }
23319
23320
23321 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 PyObject *resultobj = 0;
23323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23324 bool result;
23325 void *argp1 = 0 ;
23326 int res1 = 0 ;
23327 PyObject *swig_obj[1] ;
23328
23329 if (!args) SWIG_fail;
23330 swig_obj[0] = args;
23331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23332 if (!SWIG_IsOK(res1)) {
23333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23334 }
23335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 {
23343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23344 }
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23352 PyObject *resultobj = 0;
23353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23354 bool result;
23355 void *argp1 = 0 ;
23356 int res1 = 0 ;
23357 PyObject *swig_obj[1] ;
23358
23359 if (!args) SWIG_fail;
23360 swig_obj[0] = args;
23361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23362 if (!SWIG_IsOK(res1)) {
23363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23364 }
23365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23369 wxPyEndAllowThreads(__tstate);
23370 if (PyErr_Occurred()) SWIG_fail;
23371 }
23372 {
23373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23374 }
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23382 PyObject *resultobj = 0;
23383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23384 bool result;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 PyObject *swig_obj[1] ;
23388
23389 if (!args) SWIG_fail;
23390 swig_obj[0] = args;
23391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23392 if (!SWIG_IsOK(res1)) {
23393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23394 }
23395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23414 bool result;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 PyObject *swig_obj[1] ;
23418
23419 if (!args) SWIG_fail;
23420 swig_obj[0] = args;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23424 }
23425 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23444 bool result;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 result = (bool)(arg1)->LeftIsDown();
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 {
23463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23464 }
23465 return resultobj;
23466 fail:
23467 return NULL;
23468 }
23469
23470
23471 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23472 PyObject *resultobj = 0;
23473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23474 bool result;
23475 void *argp1 = 0 ;
23476 int res1 = 0 ;
23477 PyObject *swig_obj[1] ;
23478
23479 if (!args) SWIG_fail;
23480 swig_obj[0] = args;
23481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23484 }
23485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (bool)(arg1)->MiddleIsDown();
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 {
23493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 PyObject *resultobj = 0;
23503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23504 bool result;
23505 void *argp1 = 0 ;
23506 int res1 = 0 ;
23507 PyObject *swig_obj[1] ;
23508
23509 if (!args) SWIG_fail;
23510 swig_obj[0] = args;
23511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23512 if (!SWIG_IsOK(res1)) {
23513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23514 }
23515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (bool)(arg1)->RightIsDown();
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 {
23523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23524 }
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23532 PyObject *resultobj = 0;
23533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23534 bool result;
23535 void *argp1 = 0 ;
23536 int res1 = 0 ;
23537 PyObject *swig_obj[1] ;
23538
23539 if (!args) SWIG_fail;
23540 swig_obj[0] = args;
23541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23542 if (!SWIG_IsOK(res1)) {
23543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23544 }
23545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23554 }
23555 return resultobj;
23556 fail:
23557 return NULL;
23558 }
23559
23560
23561 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23562 PyObject *resultobj = 0;
23563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23564 bool result;
23565 void *argp1 = 0 ;
23566 int res1 = 0 ;
23567 PyObject *swig_obj[1] ;
23568
23569 if (!args) SWIG_fail;
23570 swig_obj[0] = args;
23571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23572 if (!SWIG_IsOK(res1)) {
23573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23574 }
23575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 {
23583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23594 bool result;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 PyObject *swig_obj[1] ;
23598
23599 if (!args) SWIG_fail;
23600 swig_obj[0] = args;
23601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *resultobj = 0;
23623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23624 bool result;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 PyObject *swig_obj[1] ;
23628
23629 if (!args) SWIG_fail;
23630 swig_obj[0] = args;
23631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23632 if (!SWIG_IsOK(res1)) {
23633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23634 }
23635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23636 {
23637 PyThreadState* __tstate = wxPyBeginAllowThreads();
23638 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23652 PyObject *resultobj = 0;
23653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23654 wxPoint result;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 PyObject *swig_obj[1] ;
23658
23659 if (!args) SWIG_fail;
23660 swig_obj[0] = args;
23661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23662 if (!SWIG_IsOK(res1)) {
23663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23664 }
23665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23666 {
23667 PyThreadState* __tstate = wxPyBeginAllowThreads();
23668 result = (arg1)->GetPosition();
23669 wxPyEndAllowThreads(__tstate);
23670 if (PyErr_Occurred()) SWIG_fail;
23671 }
23672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23680 PyObject *resultobj = 0;
23681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23682 long *arg2 = (long *) 0 ;
23683 long *arg3 = (long *) 0 ;
23684 void *argp1 = 0 ;
23685 int res1 = 0 ;
23686 long temp2 ;
23687 int res2 = SWIG_TMPOBJ ;
23688 long temp3 ;
23689 int res3 = SWIG_TMPOBJ ;
23690 PyObject *swig_obj[1] ;
23691
23692 arg2 = &temp2;
23693 arg3 = &temp3;
23694 if (!args) SWIG_fail;
23695 swig_obj[0] = args;
23696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23699 }
23700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 (arg1)->GetPosition(arg2,arg3);
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 resultobj = SWIG_Py_Void();
23708 if (SWIG_IsTmpObj(res2)) {
23709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23710 } else {
23711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23713 }
23714 if (SWIG_IsTmpObj(res3)) {
23715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23716 } else {
23717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23719 }
23720 return resultobj;
23721 fail:
23722 return NULL;
23723 }
23724
23725
23726 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj = 0;
23728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23729 wxDC *arg2 = 0 ;
23730 wxPoint result;
23731 void *argp1 = 0 ;
23732 int res1 = 0 ;
23733 void *argp2 = 0 ;
23734 int res2 = 0 ;
23735 PyObject * obj0 = 0 ;
23736 PyObject * obj1 = 0 ;
23737 char * kwnames[] = {
23738 (char *) "self",(char *) "dc", NULL
23739 };
23740
23741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23745 }
23746 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23748 if (!SWIG_IsOK(res2)) {
23749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23750 }
23751 if (!argp2) {
23752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23753 }
23754 arg2 = reinterpret_cast< wxDC * >(argp2);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23769 PyObject *resultobj = 0;
23770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23771 int result;
23772 void *argp1 = 0 ;
23773 int res1 = 0 ;
23774 PyObject *swig_obj[1] ;
23775
23776 if (!args) SWIG_fail;
23777 swig_obj[0] = args;
23778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23779 if (!SWIG_IsOK(res1)) {
23780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23781 }
23782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (int)((wxMouseEvent const *)arg1)->GetX();
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_From_int(static_cast< int >(result));
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *resultobj = 0;
23798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23799 int result;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 PyObject *swig_obj[1] ;
23803
23804 if (!args) SWIG_fail;
23805 swig_obj[0] = args;
23806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23809 }
23810 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (int)((wxMouseEvent const *)arg1)->GetY();
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 resultobj = SWIG_From_int(static_cast< int >(result));
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 PyObject *resultobj = 0;
23826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23827 int result;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 PyObject *swig_obj[1] ;
23831
23832 if (!args) SWIG_fail;
23833 swig_obj[0] = args;
23834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23837 }
23838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_From_int(static_cast< int >(result));
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23855 int result;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 resultobj = SWIG_From_int(static_cast< int >(result));
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23881 PyObject *resultobj = 0;
23882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23883 int result;
23884 void *argp1 = 0 ;
23885 int res1 = 0 ;
23886 PyObject *swig_obj[1] ;
23887
23888 if (!args) SWIG_fail;
23889 swig_obj[0] = args;
23890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23891 if (!SWIG_IsOK(res1)) {
23892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23893 }
23894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23898 wxPyEndAllowThreads(__tstate);
23899 if (PyErr_Occurred()) SWIG_fail;
23900 }
23901 resultobj = SWIG_From_int(static_cast< int >(result));
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23909 PyObject *resultobj = 0;
23910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23911 bool result;
23912 void *argp1 = 0 ;
23913 int res1 = 0 ;
23914 PyObject *swig_obj[1] ;
23915
23916 if (!args) SWIG_fail;
23917 swig_obj[0] = args;
23918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23919 if (!SWIG_IsOK(res1)) {
23920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23921 }
23922 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23931 }
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *resultobj = 0;
23940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23941 int arg2 ;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 int val2 ;
23945 int ecode2 = 0 ;
23946 PyObject *swig_obj[2] ;
23947
23948 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23950 if (!SWIG_IsOK(res1)) {
23951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23952 }
23953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23954 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23955 if (!SWIG_IsOK(ecode2)) {
23956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23957 }
23958 arg2 = static_cast< int >(val2);
23959 if (arg1) (arg1)->m_x = arg2;
23960
23961 resultobj = SWIG_Py_Void();
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 PyObject *resultobj = 0;
23970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23971 int result;
23972 void *argp1 = 0 ;
23973 int res1 = 0 ;
23974 PyObject *swig_obj[1] ;
23975
23976 if (!args) SWIG_fail;
23977 swig_obj[0] = args;
23978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23979 if (!SWIG_IsOK(res1)) {
23980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23981 }
23982 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23983 result = (int) ((arg1)->m_x);
23984 resultobj = SWIG_From_int(static_cast< int >(result));
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23994 int arg2 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 int val2 ;
23998 int ecode2 = 0 ;
23999 PyObject *swig_obj[2] ;
24000
24001 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24005 }
24006 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24007 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24008 if (!SWIG_IsOK(ecode2)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24010 }
24011 arg2 = static_cast< int >(val2);
24012 if (arg1) (arg1)->m_y = arg2;
24013
24014 resultobj = SWIG_Py_Void();
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24024 int result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24036 result = (int) ((arg1)->m_y);
24037 resultobj = SWIG_From_int(static_cast< int >(result));
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24045 PyObject *resultobj = 0;
24046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24047 bool arg2 ;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 bool val2 ;
24051 int ecode2 = 0 ;
24052 PyObject *swig_obj[2] ;
24053
24054 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24056 if (!SWIG_IsOK(res1)) {
24057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24058 }
24059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24060 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24061 if (!SWIG_IsOK(ecode2)) {
24062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24063 }
24064 arg2 = static_cast< bool >(val2);
24065 if (arg1) (arg1)->m_leftDown = arg2;
24066
24067 resultobj = SWIG_Py_Void();
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24075 PyObject *resultobj = 0;
24076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24077 bool result;
24078 void *argp1 = 0 ;
24079 int res1 = 0 ;
24080 PyObject *swig_obj[1] ;
24081
24082 if (!args) SWIG_fail;
24083 swig_obj[0] = args;
24084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24087 }
24088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24089 result = (bool) ((arg1)->m_leftDown);
24090 {
24091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24092 }
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 PyObject *resultobj = 0;
24101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24102 bool arg2 ;
24103 void *argp1 = 0 ;
24104 int res1 = 0 ;
24105 bool val2 ;
24106 int ecode2 = 0 ;
24107 PyObject *swig_obj[2] ;
24108
24109 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24113 }
24114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24115 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24116 if (!SWIG_IsOK(ecode2)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24118 }
24119 arg2 = static_cast< bool >(val2);
24120 if (arg1) (arg1)->m_middleDown = arg2;
24121
24122 resultobj = SWIG_Py_Void();
24123 return resultobj;
24124 fail:
24125 return NULL;
24126 }
24127
24128
24129 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24130 PyObject *resultobj = 0;
24131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24132 bool result;
24133 void *argp1 = 0 ;
24134 int res1 = 0 ;
24135 PyObject *swig_obj[1] ;
24136
24137 if (!args) SWIG_fail;
24138 swig_obj[0] = args;
24139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24140 if (!SWIG_IsOK(res1)) {
24141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24142 }
24143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24144 result = (bool) ((arg1)->m_middleDown);
24145 {
24146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24155 PyObject *resultobj = 0;
24156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24157 bool arg2 ;
24158 void *argp1 = 0 ;
24159 int res1 = 0 ;
24160 bool val2 ;
24161 int ecode2 = 0 ;
24162 PyObject *swig_obj[2] ;
24163
24164 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24168 }
24169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24170 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24171 if (!SWIG_IsOK(ecode2)) {
24172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24173 }
24174 arg2 = static_cast< bool >(val2);
24175 if (arg1) (arg1)->m_rightDown = arg2;
24176
24177 resultobj = SWIG_Py_Void();
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24187 bool result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24197 }
24198 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24199 result = (bool) ((arg1)->m_rightDown);
24200 {
24201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24202 }
24203 return resultobj;
24204 fail:
24205 return NULL;
24206 }
24207
24208
24209 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24210 PyObject *resultobj = 0;
24211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24212 bool arg2 ;
24213 void *argp1 = 0 ;
24214 int res1 = 0 ;
24215 bool val2 ;
24216 int ecode2 = 0 ;
24217 PyObject *swig_obj[2] ;
24218
24219 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24221 if (!SWIG_IsOK(res1)) {
24222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24223 }
24224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24225 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24226 if (!SWIG_IsOK(ecode2)) {
24227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24228 }
24229 arg2 = static_cast< bool >(val2);
24230 if (arg1) (arg1)->m_controlDown = arg2;
24231
24232 resultobj = SWIG_Py_Void();
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24240 PyObject *resultobj = 0;
24241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24242 bool result;
24243 void *argp1 = 0 ;
24244 int res1 = 0 ;
24245 PyObject *swig_obj[1] ;
24246
24247 if (!args) SWIG_fail;
24248 swig_obj[0] = args;
24249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24250 if (!SWIG_IsOK(res1)) {
24251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24252 }
24253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24254 result = (bool) ((arg1)->m_controlDown);
24255 {
24256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24257 }
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24267 bool arg2 ;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 bool val2 ;
24271 int ecode2 = 0 ;
24272 PyObject *swig_obj[2] ;
24273
24274 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24278 }
24279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24280 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24281 if (!SWIG_IsOK(ecode2)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24283 }
24284 arg2 = static_cast< bool >(val2);
24285 if (arg1) (arg1)->m_shiftDown = arg2;
24286
24287 resultobj = SWIG_Py_Void();
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24297 bool result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
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_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24309 result = (bool) ((arg1)->m_shiftDown);
24310 {
24311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24312 }
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24322 bool arg2 ;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 bool val2 ;
24326 int ecode2 = 0 ;
24327 PyObject *swig_obj[2] ;
24328
24329 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24331 if (!SWIG_IsOK(res1)) {
24332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24333 }
24334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24335 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24336 if (!SWIG_IsOK(ecode2)) {
24337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24338 }
24339 arg2 = static_cast< bool >(val2);
24340 if (arg1) (arg1)->m_altDown = arg2;
24341
24342 resultobj = SWIG_Py_Void();
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24350 PyObject *resultobj = 0;
24351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24352 bool result;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 PyObject *swig_obj[1] ;
24356
24357 if (!args) SWIG_fail;
24358 swig_obj[0] = args;
24359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24360 if (!SWIG_IsOK(res1)) {
24361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24362 }
24363 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24364 result = (bool) ((arg1)->m_altDown);
24365 {
24366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24367 }
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24375 PyObject *resultobj = 0;
24376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24377 bool arg2 ;
24378 void *argp1 = 0 ;
24379 int res1 = 0 ;
24380 bool val2 ;
24381 int ecode2 = 0 ;
24382 PyObject *swig_obj[2] ;
24383
24384 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24388 }
24389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24390 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24391 if (!SWIG_IsOK(ecode2)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24393 }
24394 arg2 = static_cast< bool >(val2);
24395 if (arg1) (arg1)->m_metaDown = arg2;
24396
24397 resultobj = SWIG_Py_Void();
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24407 bool 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_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24417 }
24418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24419 result = (bool) ((arg1)->m_metaDown);
24420 {
24421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24430 PyObject *resultobj = 0;
24431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24432 int arg2 ;
24433 void *argp1 = 0 ;
24434 int res1 = 0 ;
24435 int val2 ;
24436 int ecode2 = 0 ;
24437 PyObject *swig_obj[2] ;
24438
24439 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24443 }
24444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24445 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24446 if (!SWIG_IsOK(ecode2)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24448 }
24449 arg2 = static_cast< int >(val2);
24450 if (arg1) (arg1)->m_wheelRotation = arg2;
24451
24452 resultobj = SWIG_Py_Void();
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24460 PyObject *resultobj = 0;
24461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24462 int result;
24463 void *argp1 = 0 ;
24464 int res1 = 0 ;
24465 PyObject *swig_obj[1] ;
24466
24467 if (!args) SWIG_fail;
24468 swig_obj[0] = args;
24469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24470 if (!SWIG_IsOK(res1)) {
24471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24472 }
24473 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24474 result = (int) ((arg1)->m_wheelRotation);
24475 resultobj = SWIG_From_int(static_cast< int >(result));
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24483 PyObject *resultobj = 0;
24484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24485 int arg2 ;
24486 void *argp1 = 0 ;
24487 int res1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 PyObject *swig_obj[2] ;
24491
24492 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24494 if (!SWIG_IsOK(res1)) {
24495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24496 }
24497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24498 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24499 if (!SWIG_IsOK(ecode2)) {
24500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24501 }
24502 arg2 = static_cast< int >(val2);
24503 if (arg1) (arg1)->m_wheelDelta = arg2;
24504
24505 resultobj = SWIG_Py_Void();
24506 return resultobj;
24507 fail:
24508 return NULL;
24509 }
24510
24511
24512 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24513 PyObject *resultobj = 0;
24514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24515 int result;
24516 void *argp1 = 0 ;
24517 int res1 = 0 ;
24518 PyObject *swig_obj[1] ;
24519
24520 if (!args) SWIG_fail;
24521 swig_obj[0] = args;
24522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24523 if (!SWIG_IsOK(res1)) {
24524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24525 }
24526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24527 result = (int) ((arg1)->m_wheelDelta);
24528 resultobj = SWIG_From_int(static_cast< int >(result));
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 PyObject *resultobj = 0;
24537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24538 int arg2 ;
24539 void *argp1 = 0 ;
24540 int res1 = 0 ;
24541 int val2 ;
24542 int ecode2 = 0 ;
24543 PyObject *swig_obj[2] ;
24544
24545 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24547 if (!SWIG_IsOK(res1)) {
24548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24549 }
24550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24552 if (!SWIG_IsOK(ecode2)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24554 }
24555 arg2 = static_cast< int >(val2);
24556 if (arg1) (arg1)->m_linesPerAction = arg2;
24557
24558 resultobj = SWIG_Py_Void();
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24566 PyObject *resultobj = 0;
24567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24568 int result;
24569 void *argp1 = 0 ;
24570 int res1 = 0 ;
24571 PyObject *swig_obj[1] ;
24572
24573 if (!args) SWIG_fail;
24574 swig_obj[0] = args;
24575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24576 if (!SWIG_IsOK(res1)) {
24577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24578 }
24579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24580 result = (int) ((arg1)->m_linesPerAction);
24581 resultobj = SWIG_From_int(static_cast< int >(result));
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24589 PyObject *obj;
24590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24591 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24592 return SWIG_Py_Void();
24593 }
24594
24595 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 return SWIG_Python_InitShadowInstance(args);
24597 }
24598
24599 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj = 0;
24601 int arg1 = (int) 0 ;
24602 int arg2 = (int) 0 ;
24603 wxSetCursorEvent *result = 0 ;
24604 int val1 ;
24605 int ecode1 = 0 ;
24606 int val2 ;
24607 int ecode2 = 0 ;
24608 PyObject * obj0 = 0 ;
24609 PyObject * obj1 = 0 ;
24610 char * kwnames[] = {
24611 (char *) "x",(char *) "y", NULL
24612 };
24613
24614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24615 if (obj0) {
24616 ecode1 = SWIG_AsVal_int(obj0, &val1);
24617 if (!SWIG_IsOK(ecode1)) {
24618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24619 }
24620 arg1 = static_cast< int >(val1);
24621 }
24622 if (obj1) {
24623 ecode2 = SWIG_AsVal_int(obj1, &val2);
24624 if (!SWIG_IsOK(ecode2)) {
24625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24626 }
24627 arg2 = static_cast< int >(val2);
24628 }
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24636 return resultobj;
24637 fail:
24638 return NULL;
24639 }
24640
24641
24642 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24643 PyObject *resultobj = 0;
24644 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24645 int result;
24646 void *argp1 = 0 ;
24647 int res1 = 0 ;
24648 PyObject *swig_obj[1] ;
24649
24650 if (!args) SWIG_fail;
24651 swig_obj[0] = args;
24652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24653 if (!SWIG_IsOK(res1)) {
24654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24655 }
24656 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24657 {
24658 PyThreadState* __tstate = wxPyBeginAllowThreads();
24659 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24660 wxPyEndAllowThreads(__tstate);
24661 if (PyErr_Occurred()) SWIG_fail;
24662 }
24663 resultobj = SWIG_From_int(static_cast< int >(result));
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24671 PyObject *resultobj = 0;
24672 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24673 int result;
24674 void *argp1 = 0 ;
24675 int res1 = 0 ;
24676 PyObject *swig_obj[1] ;
24677
24678 if (!args) SWIG_fail;
24679 swig_obj[0] = args;
24680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24681 if (!SWIG_IsOK(res1)) {
24682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24683 }
24684 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24685 {
24686 PyThreadState* __tstate = wxPyBeginAllowThreads();
24687 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24688 wxPyEndAllowThreads(__tstate);
24689 if (PyErr_Occurred()) SWIG_fail;
24690 }
24691 resultobj = SWIG_From_int(static_cast< int >(result));
24692 return resultobj;
24693 fail:
24694 return NULL;
24695 }
24696
24697
24698 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = 0;
24700 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24701 wxCursor *arg2 = 0 ;
24702 void *argp1 = 0 ;
24703 int res1 = 0 ;
24704 void *argp2 = 0 ;
24705 int res2 = 0 ;
24706 PyObject * obj0 = 0 ;
24707 PyObject * obj1 = 0 ;
24708 char * kwnames[] = {
24709 (char *) "self",(char *) "cursor", NULL
24710 };
24711
24712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24714 if (!SWIG_IsOK(res1)) {
24715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24716 }
24717 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24719 if (!SWIG_IsOK(res2)) {
24720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24721 }
24722 if (!argp2) {
24723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24724 }
24725 arg2 = reinterpret_cast< wxCursor * >(argp2);
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 (arg1)->SetCursor((wxCursor const &)*arg2);
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_Py_Void();
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24742 wxCursor *result = 0 ;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 PyObject *swig_obj[1] ;
24746
24747 if (!args) SWIG_fail;
24748 swig_obj[0] = args;
24749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24752 }
24753 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 {
24757 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24758 result = (wxCursor *) &_result_ref;
24759 }
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 {
24764 wxCursor* resultptr = new wxCursor(*result);
24765 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24766 }
24767 return resultobj;
24768 fail:
24769 return NULL;
24770 }
24771
24772
24773 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24774 PyObject *resultobj = 0;
24775 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24776 bool result;
24777 void *argp1 = 0 ;
24778 int res1 = 0 ;
24779 PyObject *swig_obj[1] ;
24780
24781 if (!args) SWIG_fail;
24782 swig_obj[0] = args;
24783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24784 if (!SWIG_IsOK(res1)) {
24785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24786 }
24787 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24788 {
24789 PyThreadState* __tstate = wxPyBeginAllowThreads();
24790 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *obj;
24805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24806 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24807 return SWIG_Py_Void();
24808 }
24809
24810 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 return SWIG_Python_InitShadowInstance(args);
24812 }
24813
24814 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24817 wxKeyEvent *result = 0 ;
24818 int val1 ;
24819 int ecode1 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "eventType", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24826 if (obj0) {
24827 ecode1 = SWIG_AsVal_int(obj0, &val1);
24828 if (!SWIG_IsOK(ecode1)) {
24829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24830 }
24831 arg1 = static_cast< wxEventType >(val1);
24832 }
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24849 int result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 resultobj = SWIG_From_int(static_cast< int >(result));
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24875 PyObject *resultobj = 0;
24876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24877 bool result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 PyObject *swig_obj[1] ;
24881
24882 if (!args) SWIG_fail;
24883 swig_obj[0] = args;
24884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24887 }
24888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24897 }
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24905 PyObject *resultobj = 0;
24906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24907 bool result;
24908 void *argp1 = 0 ;
24909 int res1 = 0 ;
24910 PyObject *swig_obj[1] ;
24911
24912 if (!args) SWIG_fail;
24913 swig_obj[0] = args;
24914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24915 if (!SWIG_IsOK(res1)) {
24916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24917 }
24918 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 {
24926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24927 }
24928 return resultobj;
24929 fail:
24930 return NULL;
24931 }
24932
24933
24934 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24935 PyObject *resultobj = 0;
24936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24937 bool result;
24938 void *argp1 = 0 ;
24939 int res1 = 0 ;
24940 PyObject *swig_obj[1] ;
24941
24942 if (!args) SWIG_fail;
24943 swig_obj[0] = args;
24944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24947 }
24948 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 {
24956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24957 }
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24965 PyObject *resultobj = 0;
24966 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24967 bool result;
24968 void *argp1 = 0 ;
24969 int res1 = 0 ;
24970 PyObject *swig_obj[1] ;
24971
24972 if (!args) SWIG_fail;
24973 swig_obj[0] = args;
24974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24975 if (!SWIG_IsOK(res1)) {
24976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24977 }
24978 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24979 {
24980 PyThreadState* __tstate = wxPyBeginAllowThreads();
24981 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24982 wxPyEndAllowThreads(__tstate);
24983 if (PyErr_Occurred()) SWIG_fail;
24984 }
24985 {
24986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24987 }
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24995 PyObject *resultobj = 0;
24996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24997 bool result;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 PyObject *swig_obj[1] ;
25001
25002 if (!args) SWIG_fail;
25003 swig_obj[0] = args;
25004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25005 if (!SWIG_IsOK(res1)) {
25006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25007 }
25008 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 {
25016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25017 }
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25025 PyObject *resultobj = 0;
25026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25027 bool result;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 PyObject *swig_obj[1] ;
25031
25032 if (!args) SWIG_fail;
25033 swig_obj[0] = args;
25034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25037 }
25038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 {
25046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25055 PyObject *resultobj = 0;
25056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25057 int result;
25058 void *argp1 = 0 ;
25059 int res1 = 0 ;
25060 PyObject *swig_obj[1] ;
25061
25062 if (!args) SWIG_fail;
25063 swig_obj[0] = args;
25064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25065 if (!SWIG_IsOK(res1)) {
25066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25067 }
25068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_From_int(static_cast< int >(result));
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25083 PyObject *resultobj = 0;
25084 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25085 int result;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 PyObject *swig_obj[1] ;
25089
25090 if (!args) SWIG_fail;
25091 swig_obj[0] = args;
25092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25095 }
25096 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 resultobj = SWIG_From_int(static_cast< int >(result));
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj = 0;
25112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25113 int arg2 ;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 int val2 ;
25117 int ecode2 = 0 ;
25118 PyObject * obj0 = 0 ;
25119 PyObject * obj1 = 0 ;
25120 char * kwnames[] = {
25121 (char *) "self",(char *) "uniChar", NULL
25122 };
25123
25124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25126 if (!SWIG_IsOK(res1)) {
25127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25128 }
25129 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25130 ecode2 = SWIG_AsVal_int(obj1, &val2);
25131 if (!SWIG_IsOK(ecode2)) {
25132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25133 }
25134 arg2 = static_cast< int >(val2);
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 resultobj = SWIG_Py_Void();
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25151 unsigned 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_wxKeyEvent, 0 | 0 );
25159 if (!SWIG_IsOK(res1)) {
25160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25161 }
25162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25177 PyObject *resultobj = 0;
25178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25179 unsigned int result;
25180 void *argp1 = 0 ;
25181 int res1 = 0 ;
25182 PyObject *swig_obj[1] ;
25183
25184 if (!args) SWIG_fail;
25185 swig_obj[0] = args;
25186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25187 if (!SWIG_IsOK(res1)) {
25188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25189 }
25190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25191 {
25192 PyThreadState* __tstate = wxPyBeginAllowThreads();
25193 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25194 wxPyEndAllowThreads(__tstate);
25195 if (PyErr_Occurred()) SWIG_fail;
25196 }
25197 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25198 return resultobj;
25199 fail:
25200 return NULL;
25201 }
25202
25203
25204 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25205 PyObject *resultobj = 0;
25206 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25207 wxPoint result;
25208 void *argp1 = 0 ;
25209 int res1 = 0 ;
25210 PyObject *swig_obj[1] ;
25211
25212 if (!args) SWIG_fail;
25213 swig_obj[0] = args;
25214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25217 }
25218 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (arg1)->GetPosition();
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25233 PyObject *resultobj = 0;
25234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25235 long *arg2 = (long *) 0 ;
25236 long *arg3 = (long *) 0 ;
25237 void *argp1 = 0 ;
25238 int res1 = 0 ;
25239 long temp2 ;
25240 int res2 = SWIG_TMPOBJ ;
25241 long temp3 ;
25242 int res3 = SWIG_TMPOBJ ;
25243 PyObject *swig_obj[1] ;
25244
25245 arg2 = &temp2;
25246 arg3 = &temp3;
25247 if (!args) SWIG_fail;
25248 swig_obj[0] = args;
25249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25250 if (!SWIG_IsOK(res1)) {
25251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25252 }
25253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 (arg1)->GetPosition(arg2,arg3);
25257 wxPyEndAllowThreads(__tstate);
25258 if (PyErr_Occurred()) SWIG_fail;
25259 }
25260 resultobj = SWIG_Py_Void();
25261 if (SWIG_IsTmpObj(res2)) {
25262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25263 } else {
25264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25266 }
25267 if (SWIG_IsTmpObj(res3)) {
25268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25269 } else {
25270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25272 }
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25280 PyObject *resultobj = 0;
25281 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25282 int result;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 PyObject *swig_obj[1] ;
25286
25287 if (!args) SWIG_fail;
25288 swig_obj[0] = args;
25289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25290 if (!SWIG_IsOK(res1)) {
25291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25292 }
25293 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = (int)((wxKeyEvent const *)arg1)->GetX();
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 resultobj = SWIG_From_int(static_cast< int >(result));
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25308 PyObject *resultobj = 0;
25309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25310 int result;
25311 void *argp1 = 0 ;
25312 int res1 = 0 ;
25313 PyObject *swig_obj[1] ;
25314
25315 if (!args) SWIG_fail;
25316 swig_obj[0] = args;
25317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25318 if (!SWIG_IsOK(res1)) {
25319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25320 }
25321 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (int)((wxKeyEvent const *)arg1)->GetY();
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 resultobj = SWIG_From_int(static_cast< int >(result));
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *resultobj = 0;
25337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25338 int arg2 ;
25339 void *argp1 = 0 ;
25340 int res1 = 0 ;
25341 int val2 ;
25342 int ecode2 = 0 ;
25343 PyObject *swig_obj[2] ;
25344
25345 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25349 }
25350 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25351 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25352 if (!SWIG_IsOK(ecode2)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25354 }
25355 arg2 = static_cast< int >(val2);
25356 if (arg1) (arg1)->m_x = arg2;
25357
25358 resultobj = SWIG_Py_Void();
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25366 PyObject *resultobj = 0;
25367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25368 int result;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 PyObject *swig_obj[1] ;
25372
25373 if (!args) SWIG_fail;
25374 swig_obj[0] = args;
25375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25376 if (!SWIG_IsOK(res1)) {
25377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25378 }
25379 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25380 result = (int) ((arg1)->m_x);
25381 resultobj = SWIG_From_int(static_cast< int >(result));
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25389 PyObject *resultobj = 0;
25390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25391 int arg2 ;
25392 void *argp1 = 0 ;
25393 int res1 = 0 ;
25394 int val2 ;
25395 int ecode2 = 0 ;
25396 PyObject *swig_obj[2] ;
25397
25398 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25400 if (!SWIG_IsOK(res1)) {
25401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25402 }
25403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25404 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25405 if (!SWIG_IsOK(ecode2)) {
25406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25407 }
25408 arg2 = static_cast< int >(val2);
25409 if (arg1) (arg1)->m_y = arg2;
25410
25411 resultobj = SWIG_Py_Void();
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25421 int result;
25422 void *argp1 = 0 ;
25423 int res1 = 0 ;
25424 PyObject *swig_obj[1] ;
25425
25426 if (!args) SWIG_fail;
25427 swig_obj[0] = args;
25428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25429 if (!SWIG_IsOK(res1)) {
25430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25431 }
25432 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25433 result = (int) ((arg1)->m_y);
25434 resultobj = SWIG_From_int(static_cast< int >(result));
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25442 PyObject *resultobj = 0;
25443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25444 long arg2 ;
25445 void *argp1 = 0 ;
25446 int res1 = 0 ;
25447 long val2 ;
25448 int ecode2 = 0 ;
25449 PyObject *swig_obj[2] ;
25450
25451 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25453 if (!SWIG_IsOK(res1)) {
25454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25455 }
25456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25457 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25458 if (!SWIG_IsOK(ecode2)) {
25459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25460 }
25461 arg2 = static_cast< long >(val2);
25462 if (arg1) (arg1)->m_keyCode = arg2;
25463
25464 resultobj = SWIG_Py_Void();
25465 return resultobj;
25466 fail:
25467 return NULL;
25468 }
25469
25470
25471 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 PyObject *resultobj = 0;
25473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25474 long result;
25475 void *argp1 = 0 ;
25476 int res1 = 0 ;
25477 PyObject *swig_obj[1] ;
25478
25479 if (!args) SWIG_fail;
25480 swig_obj[0] = args;
25481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25482 if (!SWIG_IsOK(res1)) {
25483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25484 }
25485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25486 result = (long) ((arg1)->m_keyCode);
25487 resultobj = SWIG_From_long(static_cast< long >(result));
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25497 bool arg2 ;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 bool val2 ;
25501 int ecode2 = 0 ;
25502 PyObject *swig_obj[2] ;
25503
25504 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25506 if (!SWIG_IsOK(res1)) {
25507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25508 }
25509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25510 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25511 if (!SWIG_IsOK(ecode2)) {
25512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25513 }
25514 arg2 = static_cast< bool >(val2);
25515 if (arg1) (arg1)->m_controlDown = arg2;
25516
25517 resultobj = SWIG_Py_Void();
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 PyObject *resultobj = 0;
25526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25527 bool result;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 PyObject *swig_obj[1] ;
25531
25532 if (!args) SWIG_fail;
25533 swig_obj[0] = args;
25534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25535 if (!SWIG_IsOK(res1)) {
25536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25537 }
25538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25539 result = (bool) ((arg1)->m_controlDown);
25540 {
25541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25542 }
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25550 PyObject *resultobj = 0;
25551 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25552 bool arg2 ;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 bool val2 ;
25556 int ecode2 = 0 ;
25557 PyObject *swig_obj[2] ;
25558
25559 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25563 }
25564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25565 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25566 if (!SWIG_IsOK(ecode2)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25568 }
25569 arg2 = static_cast< bool >(val2);
25570 if (arg1) (arg1)->m_shiftDown = arg2;
25571
25572 resultobj = SWIG_Py_Void();
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 PyObject *resultobj = 0;
25581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25582 bool result;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 PyObject *swig_obj[1] ;
25586
25587 if (!args) SWIG_fail;
25588 swig_obj[0] = args;
25589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25592 }
25593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25594 result = (bool) ((arg1)->m_shiftDown);
25595 {
25596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25605 PyObject *resultobj = 0;
25606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25607 bool arg2 ;
25608 void *argp1 = 0 ;
25609 int res1 = 0 ;
25610 bool val2 ;
25611 int ecode2 = 0 ;
25612 PyObject *swig_obj[2] ;
25613
25614 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25618 }
25619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25620 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25621 if (!SWIG_IsOK(ecode2)) {
25622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25623 }
25624 arg2 = static_cast< bool >(val2);
25625 if (arg1) (arg1)->m_altDown = arg2;
25626
25627 resultobj = SWIG_Py_Void();
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25635 PyObject *resultobj = 0;
25636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25637 bool result;
25638 void *argp1 = 0 ;
25639 int res1 = 0 ;
25640 PyObject *swig_obj[1] ;
25641
25642 if (!args) SWIG_fail;
25643 swig_obj[0] = args;
25644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25645 if (!SWIG_IsOK(res1)) {
25646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25647 }
25648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25649 result = (bool) ((arg1)->m_altDown);
25650 {
25651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25652 }
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25662 bool arg2 ;
25663 void *argp1 = 0 ;
25664 int res1 = 0 ;
25665 bool val2 ;
25666 int ecode2 = 0 ;
25667 PyObject *swig_obj[2] ;
25668
25669 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
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_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25673 }
25674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25675 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25676 if (!SWIG_IsOK(ecode2)) {
25677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25678 }
25679 arg2 = static_cast< bool >(val2);
25680 if (arg1) (arg1)->m_metaDown = arg2;
25681
25682 resultobj = SWIG_Py_Void();
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25690 PyObject *resultobj = 0;
25691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25692 bool result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 PyObject *swig_obj[1] ;
25696
25697 if (!args) SWIG_fail;
25698 swig_obj[0] = args;
25699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25702 }
25703 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25704 result = (bool) ((arg1)->m_metaDown);
25705 {
25706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25707 }
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *resultobj = 0;
25716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25717 bool arg2 ;
25718 void *argp1 = 0 ;
25719 int res1 = 0 ;
25720 bool val2 ;
25721 int ecode2 = 0 ;
25722 PyObject *swig_obj[2] ;
25723
25724 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25728 }
25729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25730 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25731 if (!SWIG_IsOK(ecode2)) {
25732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25733 }
25734 arg2 = static_cast< bool >(val2);
25735 if (arg1) (arg1)->m_scanCode = arg2;
25736
25737 resultobj = SWIG_Py_Void();
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25745 PyObject *resultobj = 0;
25746 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25747 bool result;
25748 void *argp1 = 0 ;
25749 int res1 = 0 ;
25750 PyObject *swig_obj[1] ;
25751
25752 if (!args) SWIG_fail;
25753 swig_obj[0] = args;
25754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25755 if (!SWIG_IsOK(res1)) {
25756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25757 }
25758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25759 result = (bool) ((arg1)->m_scanCode);
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *resultobj = 0;
25771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25772 unsigned int arg2 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 unsigned int val2 ;
25776 int ecode2 = 0 ;
25777 PyObject *swig_obj[2] ;
25778
25779 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25781 if (!SWIG_IsOK(res1)) {
25782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25783 }
25784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25785 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25786 if (!SWIG_IsOK(ecode2)) {
25787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25788 }
25789 arg2 = static_cast< unsigned int >(val2);
25790 if (arg1) (arg1)->m_rawCode = arg2;
25791
25792 resultobj = SWIG_Py_Void();
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25800 PyObject *resultobj = 0;
25801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25802 unsigned int result;
25803 void *argp1 = 0 ;
25804 int res1 = 0 ;
25805 PyObject *swig_obj[1] ;
25806
25807 if (!args) SWIG_fail;
25808 swig_obj[0] = args;
25809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25810 if (!SWIG_IsOK(res1)) {
25811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25812 }
25813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25814 result = (unsigned int) ((arg1)->m_rawCode);
25815 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25823 PyObject *resultobj = 0;
25824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25825 unsigned int arg2 ;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 unsigned int val2 ;
25829 int ecode2 = 0 ;
25830 PyObject *swig_obj[2] ;
25831
25832 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25834 if (!SWIG_IsOK(res1)) {
25835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25836 }
25837 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25838 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25839 if (!SWIG_IsOK(ecode2)) {
25840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25841 }
25842 arg2 = static_cast< unsigned int >(val2);
25843 if (arg1) (arg1)->m_rawFlags = arg2;
25844
25845 resultobj = SWIG_Py_Void();
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853 PyObject *resultobj = 0;
25854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25855 unsigned int result;
25856 void *argp1 = 0 ;
25857 int res1 = 0 ;
25858 PyObject *swig_obj[1] ;
25859
25860 if (!args) SWIG_fail;
25861 swig_obj[0] = args;
25862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25863 if (!SWIG_IsOK(res1)) {
25864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25865 }
25866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25867 result = (unsigned int) ((arg1)->m_rawFlags);
25868 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25876 PyObject *obj;
25877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25878 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25879 return SWIG_Py_Void();
25880 }
25881
25882 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25883 return SWIG_Python_InitShadowInstance(args);
25884 }
25885
25886 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25887 PyObject *resultobj = 0;
25888 wxSize const &arg1_defvalue = wxDefaultSize ;
25889 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25890 int arg2 = (int) 0 ;
25891 wxSizeEvent *result = 0 ;
25892 wxSize temp1 ;
25893 int val2 ;
25894 int ecode2 = 0 ;
25895 PyObject * obj0 = 0 ;
25896 PyObject * obj1 = 0 ;
25897 char * kwnames[] = {
25898 (char *) "sz",(char *) "winid", NULL
25899 };
25900
25901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25902 if (obj0) {
25903 {
25904 arg1 = &temp1;
25905 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25906 }
25907 }
25908 if (obj1) {
25909 ecode2 = SWIG_AsVal_int(obj1, &val2);
25910 if (!SWIG_IsOK(ecode2)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25912 }
25913 arg2 = static_cast< int >(val2);
25914 }
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25922 return resultobj;
25923 fail:
25924 return NULL;
25925 }
25926
25927
25928 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25929 PyObject *resultobj = 0;
25930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25931 wxSize result;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 PyObject *swig_obj[1] ;
25935
25936 if (!args) SWIG_fail;
25937 swig_obj[0] = args;
25938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25939 if (!SWIG_IsOK(res1)) {
25940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25941 }
25942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = ((wxSizeEvent const *)arg1)->GetSize();
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 PyObject *resultobj = 0;
25958 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25959 wxRect result;
25960 void *argp1 = 0 ;
25961 int res1 = 0 ;
25962 PyObject *swig_obj[1] ;
25963
25964 if (!args) SWIG_fail;
25965 swig_obj[0] = args;
25966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25969 }
25970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 result = ((wxSizeEvent const *)arg1)->GetRect();
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25985 PyObject *resultobj = 0;
25986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25987 wxRect arg2 ;
25988 void *argp1 = 0 ;
25989 int res1 = 0 ;
25990 void *argp2 ;
25991 int res2 = 0 ;
25992 PyObject * obj0 = 0 ;
25993 PyObject * obj1 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "rect", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26002 }
26003 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26004 {
26005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26006 if (!SWIG_IsOK(res2)) {
26007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26008 }
26009 if (!argp2) {
26010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26011 } else {
26012 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26013 arg2 = *temp;
26014 if (SWIG_IsNewObj(res2)) delete temp;
26015 }
26016 }
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 (arg1)->SetRect(arg2);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 resultobj = SWIG_Py_Void();
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26031 PyObject *resultobj = 0;
26032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26033 wxSize arg2 ;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 void *argp2 ;
26037 int res2 = 0 ;
26038 PyObject * obj0 = 0 ;
26039 PyObject * obj1 = 0 ;
26040 char * kwnames[] = {
26041 (char *) "self",(char *) "size", NULL
26042 };
26043
26044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26046 if (!SWIG_IsOK(res1)) {
26047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26048 }
26049 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26050 {
26051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26052 if (!SWIG_IsOK(res2)) {
26053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26054 }
26055 if (!argp2) {
26056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26057 } else {
26058 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26059 arg2 = *temp;
26060 if (SWIG_IsNewObj(res2)) delete temp;
26061 }
26062 }
26063 {
26064 PyThreadState* __tstate = wxPyBeginAllowThreads();
26065 wxSizeEvent_SetSize(arg1,arg2);
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 resultobj = SWIG_Py_Void();
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26077 PyObject *resultobj = 0;
26078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26079 wxSize *arg2 = (wxSize *) 0 ;
26080 void *argp1 = 0 ;
26081 int res1 = 0 ;
26082 void *argp2 = 0 ;
26083 int res2 = 0 ;
26084 PyObject *swig_obj[2] ;
26085
26086 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26090 }
26091 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26093 if (!SWIG_IsOK(res2)) {
26094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26095 }
26096 arg2 = reinterpret_cast< wxSize * >(argp2);
26097 if (arg1) (arg1)->m_size = *arg2;
26098
26099 resultobj = SWIG_Py_Void();
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26109 wxSize *result = 0 ;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26119 }
26120 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26121 result = (wxSize *)& ((arg1)->m_size);
26122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *resultobj = 0;
26131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26132 wxRect *arg2 = (wxRect *) 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 void *argp2 = 0 ;
26136 int res2 = 0 ;
26137 PyObject *swig_obj[2] ;
26138
26139 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26143 }
26144 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26146 if (!SWIG_IsOK(res2)) {
26147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26148 }
26149 arg2 = reinterpret_cast< wxRect * >(argp2);
26150 if (arg1) (arg1)->m_rect = *arg2;
26151
26152 resultobj = SWIG_Py_Void();
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26160 PyObject *resultobj = 0;
26161 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26162 wxRect *result = 0 ;
26163 void *argp1 = 0 ;
26164 int res1 = 0 ;
26165 PyObject *swig_obj[1] ;
26166
26167 if (!args) SWIG_fail;
26168 swig_obj[0] = args;
26169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26172 }
26173 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26174 result = (wxRect *)& ((arg1)->m_rect);
26175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26183 PyObject *obj;
26184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26185 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26186 return SWIG_Py_Void();
26187 }
26188
26189 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26190 return SWIG_Python_InitShadowInstance(args);
26191 }
26192
26193 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26194 PyObject *resultobj = 0;
26195 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26196 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26197 int arg2 = (int) 0 ;
26198 wxMoveEvent *result = 0 ;
26199 wxPoint temp1 ;
26200 int val2 ;
26201 int ecode2 = 0 ;
26202 PyObject * obj0 = 0 ;
26203 PyObject * obj1 = 0 ;
26204 char * kwnames[] = {
26205 (char *) "pos",(char *) "winid", NULL
26206 };
26207
26208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26209 if (obj0) {
26210 {
26211 arg1 = &temp1;
26212 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26213 }
26214 }
26215 if (obj1) {
26216 ecode2 = SWIG_AsVal_int(obj1, &val2);
26217 if (!SWIG_IsOK(ecode2)) {
26218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26219 }
26220 arg2 = static_cast< int >(val2);
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26236 PyObject *resultobj = 0;
26237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26238 wxPoint result;
26239 void *argp1 = 0 ;
26240 int res1 = 0 ;
26241 PyObject *swig_obj[1] ;
26242
26243 if (!args) SWIG_fail;
26244 swig_obj[0] = args;
26245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26246 if (!SWIG_IsOK(res1)) {
26247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26248 }
26249 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26250 {
26251 PyThreadState* __tstate = wxPyBeginAllowThreads();
26252 result = ((wxMoveEvent const *)arg1)->GetPosition();
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26264 PyObject *resultobj = 0;
26265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26266 wxRect result;
26267 void *argp1 = 0 ;
26268 int res1 = 0 ;
26269 PyObject *swig_obj[1] ;
26270
26271 if (!args) SWIG_fail;
26272 swig_obj[0] = args;
26273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26274 if (!SWIG_IsOK(res1)) {
26275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26276 }
26277 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26278 {
26279 PyThreadState* __tstate = wxPyBeginAllowThreads();
26280 result = ((wxMoveEvent const *)arg1)->GetRect();
26281 wxPyEndAllowThreads(__tstate);
26282 if (PyErr_Occurred()) SWIG_fail;
26283 }
26284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj = 0;
26293 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26294 wxRect *arg2 = 0 ;
26295 void *argp1 = 0 ;
26296 int res1 = 0 ;
26297 wxRect temp2 ;
26298 PyObject * obj0 = 0 ;
26299 PyObject * obj1 = 0 ;
26300 char * kwnames[] = {
26301 (char *) "self",(char *) "rect", NULL
26302 };
26303
26304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26306 if (!SWIG_IsOK(res1)) {
26307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26308 }
26309 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26310 {
26311 arg2 = &temp2;
26312 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26313 }
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 (arg1)->SetRect((wxRect const &)*arg2);
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 resultobj = SWIG_Py_Void();
26321 return resultobj;
26322 fail:
26323 return NULL;
26324 }
26325
26326
26327 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26328 PyObject *resultobj = 0;
26329 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26330 wxPoint *arg2 = 0 ;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 wxPoint temp2 ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char * kwnames[] = {
26337 (char *) "self",(char *) "pos", NULL
26338 };
26339
26340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26344 }
26345 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26346 {
26347 arg2 = &temp2;
26348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 (arg1)->SetPosition((wxPoint const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_Py_Void();
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *obj;
26365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26367 return SWIG_Py_Void();
26368 }
26369
26370 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26371 return SWIG_Python_InitShadowInstance(args);
26372 }
26373
26374 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26375 PyObject *resultobj = 0;
26376 int arg1 = (int) 0 ;
26377 wxPaintEvent *result = 0 ;
26378 int val1 ;
26379 int ecode1 = 0 ;
26380 PyObject * obj0 = 0 ;
26381 char * kwnames[] = {
26382 (char *) "Id", NULL
26383 };
26384
26385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26386 if (obj0) {
26387 ecode1 = SWIG_AsVal_int(obj0, &val1);
26388 if (!SWIG_IsOK(ecode1)) {
26389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26390 }
26391 arg1 = static_cast< int >(val1);
26392 }
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *obj;
26408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26410 return SWIG_Py_Void();
26411 }
26412
26413 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26414 return SWIG_Python_InitShadowInstance(args);
26415 }
26416
26417 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj = 0;
26419 int arg1 = (int) 0 ;
26420 wxNcPaintEvent *result = 0 ;
26421 int val1 ;
26422 int ecode1 = 0 ;
26423 PyObject * obj0 = 0 ;
26424 char * kwnames[] = {
26425 (char *) "winid", NULL
26426 };
26427
26428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26429 if (obj0) {
26430 ecode1 = SWIG_AsVal_int(obj0, &val1);
26431 if (!SWIG_IsOK(ecode1)) {
26432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26433 }
26434 arg1 = static_cast< int >(val1);
26435 }
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26450 PyObject *obj;
26451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26452 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26453 return SWIG_Py_Void();
26454 }
26455
26456 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 return SWIG_Python_InitShadowInstance(args);
26458 }
26459
26460 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26461 PyObject *resultobj = 0;
26462 int arg1 = (int) 0 ;
26463 wxDC *arg2 = (wxDC *) NULL ;
26464 wxEraseEvent *result = 0 ;
26465 int val1 ;
26466 int ecode1 = 0 ;
26467 void *argp2 = 0 ;
26468 int res2 = 0 ;
26469 PyObject * obj0 = 0 ;
26470 PyObject * obj1 = 0 ;
26471 char * kwnames[] = {
26472 (char *) "Id",(char *) "dc", NULL
26473 };
26474
26475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26476 if (obj0) {
26477 ecode1 = SWIG_AsVal_int(obj0, &val1);
26478 if (!SWIG_IsOK(ecode1)) {
26479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26480 }
26481 arg1 = static_cast< int >(val1);
26482 }
26483 if (obj1) {
26484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26485 if (!SWIG_IsOK(res2)) {
26486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26487 }
26488 arg2 = reinterpret_cast< wxDC * >(argp2);
26489 }
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26504 PyObject *resultobj = 0;
26505 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26506 wxDC *result = 0 ;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 PyObject *swig_obj[1] ;
26510
26511 if (!args) SWIG_fail;
26512 swig_obj[0] = args;
26513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26516 }
26517 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 {
26525 resultobj = wxPyMake_wxObject(result, (bool)0);
26526 }
26527 return resultobj;
26528 fail:
26529 return NULL;
26530 }
26531
26532
26533 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26534 PyObject *obj;
26535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26536 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26537 return SWIG_Py_Void();
26538 }
26539
26540 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26541 return SWIG_Python_InitShadowInstance(args);
26542 }
26543
26544 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj = 0;
26546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26547 int arg2 = (int) 0 ;
26548 wxFocusEvent *result = 0 ;
26549 int val1 ;
26550 int ecode1 = 0 ;
26551 int val2 ;
26552 int ecode2 = 0 ;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555 char * kwnames[] = {
26556 (char *) "type",(char *) "winid", NULL
26557 };
26558
26559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26560 if (obj0) {
26561 ecode1 = SWIG_AsVal_int(obj0, &val1);
26562 if (!SWIG_IsOK(ecode1)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26564 }
26565 arg1 = static_cast< wxEventType >(val1);
26566 }
26567 if (obj1) {
26568 ecode2 = SWIG_AsVal_int(obj1, &val2);
26569 if (!SWIG_IsOK(ecode2)) {
26570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26571 }
26572 arg2 = static_cast< int >(val2);
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26581 return resultobj;
26582 fail:
26583 return NULL;
26584 }
26585
26586
26587 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26588 PyObject *resultobj = 0;
26589 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26590 wxWindow *result = 0 ;
26591 void *argp1 = 0 ;
26592 int res1 = 0 ;
26593 PyObject *swig_obj[1] ;
26594
26595 if (!args) SWIG_fail;
26596 swig_obj[0] = args;
26597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26598 if (!SWIG_IsOK(res1)) {
26599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26600 }
26601 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 {
26609 resultobj = wxPyMake_wxObject(result, (bool)0);
26610 }
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26620 wxWindow *arg2 = (wxWindow *) 0 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 void *argp2 = 0 ;
26624 int res2 = 0 ;
26625 PyObject * obj0 = 0 ;
26626 PyObject * obj1 = 0 ;
26627 char * kwnames[] = {
26628 (char *) "self",(char *) "win", NULL
26629 };
26630
26631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26635 }
26636 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26638 if (!SWIG_IsOK(res2)) {
26639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26640 }
26641 arg2 = reinterpret_cast< wxWindow * >(argp2);
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 (arg1)->SetWindow(arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_Py_Void();
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 PyObject *obj;
26657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26658 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26659 return SWIG_Py_Void();
26660 }
26661
26662 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26663 return SWIG_Python_InitShadowInstance(args);
26664 }
26665
26666 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj = 0;
26668 wxWindow *arg1 = (wxWindow *) NULL ;
26669 wxChildFocusEvent *result = 0 ;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 PyObject * obj0 = 0 ;
26673 char * kwnames[] = {
26674 (char *) "win", NULL
26675 };
26676
26677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26678 if (obj0) {
26679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26680 if (!SWIG_IsOK(res1)) {
26681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26682 }
26683 arg1 = reinterpret_cast< wxWindow * >(argp1);
26684 }
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26699 PyObject *resultobj = 0;
26700 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26701 wxWindow *result = 0 ;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject *swig_obj[1] ;
26705
26706 if (!args) SWIG_fail;
26707 swig_obj[0] = args;
26708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26709 if (!SWIG_IsOK(res1)) {
26710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26711 }
26712 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 {
26720 resultobj = wxPyMake_wxObject(result, (bool)0);
26721 }
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26729 PyObject *obj;
26730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26731 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26732 return SWIG_Py_Void();
26733 }
26734
26735 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26736 return SWIG_Python_InitShadowInstance(args);
26737 }
26738
26739 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26740 PyObject *resultobj = 0;
26741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26742 bool arg2 = (bool) true ;
26743 int arg3 = (int) 0 ;
26744 wxActivateEvent *result = 0 ;
26745 int val1 ;
26746 int ecode1 = 0 ;
26747 bool val2 ;
26748 int ecode2 = 0 ;
26749 int val3 ;
26750 int ecode3 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 PyObject * obj2 = 0 ;
26754 char * kwnames[] = {
26755 (char *) "type",(char *) "active",(char *) "Id", NULL
26756 };
26757
26758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26759 if (obj0) {
26760 ecode1 = SWIG_AsVal_int(obj0, &val1);
26761 if (!SWIG_IsOK(ecode1)) {
26762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26763 }
26764 arg1 = static_cast< wxEventType >(val1);
26765 }
26766 if (obj1) {
26767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26770 }
26771 arg2 = static_cast< bool >(val2);
26772 }
26773 if (obj2) {
26774 ecode3 = SWIG_AsVal_int(obj2, &val3);
26775 if (!SWIG_IsOK(ecode3)) {
26776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26777 }
26778 arg3 = static_cast< int >(val3);
26779 }
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 PyObject *resultobj = 0;
26795 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26796 bool result;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 PyObject *swig_obj[1] ;
26800
26801 if (!args) SWIG_fail;
26802 swig_obj[0] = args;
26803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26806 }
26807 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 {
26815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26816 }
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26824 PyObject *obj;
26825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26826 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26827 return SWIG_Py_Void();
26828 }
26829
26830 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26831 return SWIG_Python_InitShadowInstance(args);
26832 }
26833
26834 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj = 0;
26836 int arg1 = (int) 0 ;
26837 wxInitDialogEvent *result = 0 ;
26838 int val1 ;
26839 int ecode1 = 0 ;
26840 PyObject * obj0 = 0 ;
26841 char * kwnames[] = {
26842 (char *) "Id", NULL
26843 };
26844
26845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26846 if (obj0) {
26847 ecode1 = SWIG_AsVal_int(obj0, &val1);
26848 if (!SWIG_IsOK(ecode1)) {
26849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26850 }
26851 arg1 = static_cast< int >(val1);
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26860 return resultobj;
26861 fail:
26862 return NULL;
26863 }
26864
26865
26866 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26867 PyObject *obj;
26868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26869 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26870 return SWIG_Py_Void();
26871 }
26872
26873 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26874 return SWIG_Python_InitShadowInstance(args);
26875 }
26876
26877 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj = 0;
26879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26880 int arg2 = (int) 0 ;
26881 wxMenu *arg3 = (wxMenu *) NULL ;
26882 wxMenuEvent *result = 0 ;
26883 int val1 ;
26884 int ecode1 = 0 ;
26885 int val2 ;
26886 int ecode2 = 0 ;
26887 void *argp3 = 0 ;
26888 int res3 = 0 ;
26889 PyObject * obj0 = 0 ;
26890 PyObject * obj1 = 0 ;
26891 PyObject * obj2 = 0 ;
26892 char * kwnames[] = {
26893 (char *) "type",(char *) "winid",(char *) "menu", NULL
26894 };
26895
26896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26897 if (obj0) {
26898 ecode1 = SWIG_AsVal_int(obj0, &val1);
26899 if (!SWIG_IsOK(ecode1)) {
26900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26901 }
26902 arg1 = static_cast< wxEventType >(val1);
26903 }
26904 if (obj1) {
26905 ecode2 = SWIG_AsVal_int(obj1, &val2);
26906 if (!SWIG_IsOK(ecode2)) {
26907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26908 }
26909 arg2 = static_cast< int >(val2);
26910 }
26911 if (obj2) {
26912 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26913 if (!SWIG_IsOK(res3)) {
26914 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26915 }
26916 arg3 = reinterpret_cast< wxMenu * >(argp3);
26917 }
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26932 PyObject *resultobj = 0;
26933 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26934 int result;
26935 void *argp1 = 0 ;
26936 int res1 = 0 ;
26937 PyObject *swig_obj[1] ;
26938
26939 if (!args) SWIG_fail;
26940 swig_obj[0] = args;
26941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26942 if (!SWIG_IsOK(res1)) {
26943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26944 }
26945 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26946 {
26947 PyThreadState* __tstate = wxPyBeginAllowThreads();
26948 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 resultobj = SWIG_From_int(static_cast< int >(result));
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26960 PyObject *resultobj = 0;
26961 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26962 bool result;
26963 void *argp1 = 0 ;
26964 int res1 = 0 ;
26965 PyObject *swig_obj[1] ;
26966
26967 if (!args) SWIG_fail;
26968 swig_obj[0] = args;
26969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26970 if (!SWIG_IsOK(res1)) {
26971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26972 }
26973 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 {
26981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26990 PyObject *resultobj = 0;
26991 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26992 wxMenu *result = 0 ;
26993 void *argp1 = 0 ;
26994 int res1 = 0 ;
26995 PyObject *swig_obj[1] ;
26996
26997 if (!args) SWIG_fail;
26998 swig_obj[0] = args;
26999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27000 if (!SWIG_IsOK(res1)) {
27001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27002 }
27003 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27007 wxPyEndAllowThreads(__tstate);
27008 if (PyErr_Occurred()) SWIG_fail;
27009 }
27010 {
27011 resultobj = wxPyMake_wxObject(result, (bool)0);
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27020 PyObject *obj;
27021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27022 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27023 return SWIG_Py_Void();
27024 }
27025
27026 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27027 return SWIG_Python_InitShadowInstance(args);
27028 }
27029
27030 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj = 0;
27032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27033 int arg2 = (int) 0 ;
27034 wxCloseEvent *result = 0 ;
27035 int val1 ;
27036 int ecode1 = 0 ;
27037 int val2 ;
27038 int ecode2 = 0 ;
27039 PyObject * obj0 = 0 ;
27040 PyObject * obj1 = 0 ;
27041 char * kwnames[] = {
27042 (char *) "type",(char *) "winid", NULL
27043 };
27044
27045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27046 if (obj0) {
27047 ecode1 = SWIG_AsVal_int(obj0, &val1);
27048 if (!SWIG_IsOK(ecode1)) {
27049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27050 }
27051 arg1 = static_cast< wxEventType >(val1);
27052 }
27053 if (obj1) {
27054 ecode2 = SWIG_AsVal_int(obj1, &val2);
27055 if (!SWIG_IsOK(ecode2)) {
27056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27057 }
27058 arg2 = static_cast< int >(val2);
27059 }
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj = 0;
27075 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27076 bool arg2 ;
27077 void *argp1 = 0 ;
27078 int res1 = 0 ;
27079 bool val2 ;
27080 int ecode2 = 0 ;
27081 PyObject * obj0 = 0 ;
27082 PyObject * obj1 = 0 ;
27083 char * kwnames[] = {
27084 (char *) "self",(char *) "logOff", NULL
27085 };
27086
27087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27089 if (!SWIG_IsOK(res1)) {
27090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27091 }
27092 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27093 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27094 if (!SWIG_IsOK(ecode2)) {
27095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27096 }
27097 arg2 = static_cast< bool >(val2);
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 (arg1)->SetLoggingOff(arg2);
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 resultobj = SWIG_Py_Void();
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27112 PyObject *resultobj = 0;
27113 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27114 bool result;
27115 void *argp1 = 0 ;
27116 int res1 = 0 ;
27117 PyObject *swig_obj[1] ;
27118
27119 if (!args) SWIG_fail;
27120 swig_obj[0] = args;
27121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27122 if (!SWIG_IsOK(res1)) {
27123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27124 }
27125 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 {
27133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27134 }
27135 return resultobj;
27136 fail:
27137 return NULL;
27138 }
27139
27140
27141 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27142 PyObject *resultobj = 0;
27143 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27144 bool arg2 = (bool) true ;
27145 void *argp1 = 0 ;
27146 int res1 = 0 ;
27147 bool val2 ;
27148 int ecode2 = 0 ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "veto", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27159 }
27160 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27161 if (obj1) {
27162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27163 if (!SWIG_IsOK(ecode2)) {
27164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27165 }
27166 arg2 = static_cast< bool >(val2);
27167 }
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 (arg1)->Veto(arg2);
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 resultobj = SWIG_Py_Void();
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27182 PyObject *resultobj = 0;
27183 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27184 bool result;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 PyObject *swig_obj[1] ;
27188
27189 if (!args) SWIG_fail;
27190 swig_obj[0] = args;
27191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27194 }
27195 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 {
27203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27204 }
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj = 0;
27213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27214 bool arg2 ;
27215 void *argp1 = 0 ;
27216 int res1 = 0 ;
27217 bool val2 ;
27218 int ecode2 = 0 ;
27219 PyObject * obj0 = 0 ;
27220 PyObject * obj1 = 0 ;
27221 char * kwnames[] = {
27222 (char *) "self",(char *) "canVeto", NULL
27223 };
27224
27225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27227 if (!SWIG_IsOK(res1)) {
27228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27229 }
27230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27232 if (!SWIG_IsOK(ecode2)) {
27233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27234 }
27235 arg2 = static_cast< bool >(val2);
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 (arg1)->SetCanVeto(arg2);
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 resultobj = SWIG_Py_Void();
27243 return resultobj;
27244 fail:
27245 return NULL;
27246 }
27247
27248
27249 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27250 PyObject *resultobj = 0;
27251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27252 bool result;
27253 void *argp1 = 0 ;
27254 int res1 = 0 ;
27255 PyObject *swig_obj[1] ;
27256
27257 if (!args) SWIG_fail;
27258 swig_obj[0] = args;
27259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27260 if (!SWIG_IsOK(res1)) {
27261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27262 }
27263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 {
27271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27272 }
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27280 PyObject *obj;
27281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27282 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27283 return SWIG_Py_Void();
27284 }
27285
27286 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27287 return SWIG_Python_InitShadowInstance(args);
27288 }
27289
27290 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj = 0;
27292 int arg1 = (int) 0 ;
27293 bool arg2 = (bool) false ;
27294 wxShowEvent *result = 0 ;
27295 int val1 ;
27296 int ecode1 = 0 ;
27297 bool val2 ;
27298 int ecode2 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "winid",(char *) "show", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27306 if (obj0) {
27307 ecode1 = SWIG_AsVal_int(obj0, &val1);
27308 if (!SWIG_IsOK(ecode1)) {
27309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27310 }
27311 arg1 = static_cast< int >(val1);
27312 }
27313 if (obj1) {
27314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27315 if (!SWIG_IsOK(ecode2)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27317 }
27318 arg2 = static_cast< bool >(val2);
27319 }
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27334 PyObject *resultobj = 0;
27335 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27336 bool arg2 ;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 bool val2 ;
27340 int ecode2 = 0 ;
27341 PyObject * obj0 = 0 ;
27342 PyObject * obj1 = 0 ;
27343 char * kwnames[] = {
27344 (char *) "self",(char *) "show", NULL
27345 };
27346
27347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27351 }
27352 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27354 if (!SWIG_IsOK(ecode2)) {
27355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27356 }
27357 arg2 = static_cast< bool >(val2);
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 (arg1)->SetShow(arg2);
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_Py_Void();
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27372 PyObject *resultobj = 0;
27373 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27374 bool result;
27375 void *argp1 = 0 ;
27376 int res1 = 0 ;
27377 PyObject *swig_obj[1] ;
27378
27379 if (!args) SWIG_fail;
27380 swig_obj[0] = args;
27381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27384 }
27385 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27389 wxPyEndAllowThreads(__tstate);
27390 if (PyErr_Occurred()) SWIG_fail;
27391 }
27392 {
27393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27394 }
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 PyObject *obj;
27403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27404 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27405 return SWIG_Py_Void();
27406 }
27407
27408 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27409 return SWIG_Python_InitShadowInstance(args);
27410 }
27411
27412 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj = 0;
27414 int arg1 = (int) 0 ;
27415 bool arg2 = (bool) true ;
27416 wxIconizeEvent *result = 0 ;
27417 int val1 ;
27418 int ecode1 = 0 ;
27419 bool val2 ;
27420 int ecode2 = 0 ;
27421 PyObject * obj0 = 0 ;
27422 PyObject * obj1 = 0 ;
27423 char * kwnames[] = {
27424 (char *) "id",(char *) "iconized", NULL
27425 };
27426
27427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27428 if (obj0) {
27429 ecode1 = SWIG_AsVal_int(obj0, &val1);
27430 if (!SWIG_IsOK(ecode1)) {
27431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27432 }
27433 arg1 = static_cast< int >(val1);
27434 }
27435 if (obj1) {
27436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27437 if (!SWIG_IsOK(ecode2)) {
27438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27439 }
27440 arg2 = static_cast< bool >(val2);
27441 }
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27456 PyObject *resultobj = 0;
27457 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27458 bool result;
27459 void *argp1 = 0 ;
27460 int res1 = 0 ;
27461 PyObject *swig_obj[1] ;
27462
27463 if (!args) SWIG_fail;
27464 swig_obj[0] = args;
27465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27466 if (!SWIG_IsOK(res1)) {
27467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27468 }
27469 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = (bool)(arg1)->Iconized();
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 {
27477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27478 }
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *obj;
27487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27488 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27489 return SWIG_Py_Void();
27490 }
27491
27492 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27493 return SWIG_Python_InitShadowInstance(args);
27494 }
27495
27496 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27497 PyObject *resultobj = 0;
27498 int arg1 = (int) 0 ;
27499 wxMaximizeEvent *result = 0 ;
27500 int val1 ;
27501 int ecode1 = 0 ;
27502 PyObject * obj0 = 0 ;
27503 char * kwnames[] = {
27504 (char *) "id", NULL
27505 };
27506
27507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27508 if (obj0) {
27509 ecode1 = SWIG_AsVal_int(obj0, &val1);
27510 if (!SWIG_IsOK(ecode1)) {
27511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27512 }
27513 arg1 = static_cast< int >(val1);
27514 }
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27529 PyObject *obj;
27530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27531 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27532 return SWIG_Py_Void();
27533 }
27534
27535 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27536 return SWIG_Python_InitShadowInstance(args);
27537 }
27538
27539 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27540 PyObject *resultobj = 0;
27541 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27542 wxPoint result;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 PyObject *swig_obj[1] ;
27546
27547 if (!args) SWIG_fail;
27548 swig_obj[0] = args;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27552 }
27553 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (arg1)->GetPosition();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 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_wxDropFilesEvent, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27580 }
27581 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (int)(arg1)->GetNumberOfFiles();
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_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27598 PyObject *result = 0 ;
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_wxDropFilesEvent, 0 | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27608 }
27609 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 resultobj = result;
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27624 PyObject *obj;
27625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27626 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27627 return SWIG_Py_Void();
27628 }
27629
27630 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj = 0;
27632 int arg1 = (int) 0 ;
27633 wxUpdateUIEvent *result = 0 ;
27634 int val1 ;
27635 int ecode1 = 0 ;
27636 PyObject * obj0 = 0 ;
27637 char * kwnames[] = {
27638 (char *) "commandId", NULL
27639 };
27640
27641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27642 if (obj0) {
27643 ecode1 = SWIG_AsVal_int(obj0, &val1);
27644 if (!SWIG_IsOK(ecode1)) {
27645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27646 }
27647 arg1 = static_cast< int >(val1);
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27665 bool result;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27675 }
27676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27693 PyObject *resultobj = 0;
27694 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27695 bool result;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 PyObject *swig_obj[1] ;
27699
27700 if (!args) SWIG_fail;
27701 swig_obj[0] = args;
27702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27703 if (!SWIG_IsOK(res1)) {
27704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27705 }
27706 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 {
27714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27715 }
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *resultobj = 0;
27724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27725 bool result;
27726 void *argp1 = 0 ;
27727 int res1 = 0 ;
27728 PyObject *swig_obj[1] ;
27729
27730 if (!args) SWIG_fail;
27731 swig_obj[0] = args;
27732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27735 }
27736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27753 PyObject *resultobj = 0;
27754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27755 wxString result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 PyObject *swig_obj[1] ;
27759
27760 if (!args) SWIG_fail;
27761 swig_obj[0] = args;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27765 }
27766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 {
27774 #if wxUSE_UNICODE
27775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27776 #else
27777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27778 #endif
27779 }
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27787 PyObject *resultobj = 0;
27788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27789 bool result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 PyObject *swig_obj[1] ;
27793
27794 if (!args) SWIG_fail;
27795 swig_obj[0] = args;
27796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27799 }
27800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27817 PyObject *resultobj = 0;
27818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27819 bool result;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 PyObject *swig_obj[1] ;
27823
27824 if (!args) SWIG_fail;
27825 swig_obj[0] = args;
27826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27827 if (!SWIG_IsOK(res1)) {
27828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27829 }
27830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 {
27838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27839 }
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27847 PyObject *resultobj = 0;
27848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27849 bool result;
27850 void *argp1 = 0 ;
27851 int res1 = 0 ;
27852 PyObject *swig_obj[1] ;
27853
27854 if (!args) SWIG_fail;
27855 swig_obj[0] = args;
27856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27857 if (!SWIG_IsOK(res1)) {
27858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27859 }
27860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27869 }
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27877 PyObject *resultobj = 0;
27878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27879 bool result;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 PyObject *swig_obj[1] ;
27883
27884 if (!args) SWIG_fail;
27885 swig_obj[0] = args;
27886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27887 if (!SWIG_IsOK(res1)) {
27888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27889 }
27890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27891 {
27892 PyThreadState* __tstate = wxPyBeginAllowThreads();
27893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27894 wxPyEndAllowThreads(__tstate);
27895 if (PyErr_Occurred()) SWIG_fail;
27896 }
27897 {
27898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27899 }
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27907 PyObject *resultobj = 0;
27908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27909 bool arg2 ;
27910 void *argp1 = 0 ;
27911 int res1 = 0 ;
27912 bool val2 ;
27913 int ecode2 = 0 ;
27914 PyObject * obj0 = 0 ;
27915 PyObject * obj1 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "self",(char *) "check", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27924 }
27925 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27927 if (!SWIG_IsOK(ecode2)) {
27928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27929 }
27930 arg2 = static_cast< bool >(val2);
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 (arg1)->Check(arg2);
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 resultobj = SWIG_Py_Void();
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = 0;
27946 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27947 bool arg2 ;
27948 void *argp1 = 0 ;
27949 int res1 = 0 ;
27950 bool val2 ;
27951 int ecode2 = 0 ;
27952 PyObject * obj0 = 0 ;
27953 PyObject * obj1 = 0 ;
27954 char * kwnames[] = {
27955 (char *) "self",(char *) "enable", NULL
27956 };
27957
27958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27962 }
27963 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27965 if (!SWIG_IsOK(ecode2)) {
27966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27967 }
27968 arg2 = static_cast< bool >(val2);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 (arg1)->Enable(arg2);
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 resultobj = SWIG_Py_Void();
27976 return resultobj;
27977 fail:
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27985 bool arg2 ;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 bool val2 ;
27989 int ecode2 = 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "show", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28000 }
28001 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28003 if (!SWIG_IsOK(ecode2)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28005 }
28006 arg2 = static_cast< bool >(val2);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 (arg1)->Show(arg2);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_Py_Void();
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj = 0;
28022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28023 wxString *arg2 = 0 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 bool temp2 = false ;
28027 PyObject * obj0 = 0 ;
28028 PyObject * obj1 = 0 ;
28029 char * kwnames[] = {
28030 (char *) "self",(char *) "text", NULL
28031 };
28032
28033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28035 if (!SWIG_IsOK(res1)) {
28036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28037 }
28038 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28039 {
28040 arg2 = wxString_in_helper(obj1);
28041 if (arg2 == NULL) SWIG_fail;
28042 temp2 = true;
28043 }
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 (arg1)->SetText((wxString const &)*arg2);
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 resultobj = SWIG_Py_Void();
28051 {
28052 if (temp2)
28053 delete arg2;
28054 }
28055 return resultobj;
28056 fail:
28057 {
28058 if (temp2)
28059 delete arg2;
28060 }
28061 return NULL;
28062 }
28063
28064
28065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj = 0;
28067 long arg1 ;
28068 long val1 ;
28069 int ecode1 = 0 ;
28070 PyObject * obj0 = 0 ;
28071 char * kwnames[] = {
28072 (char *) "updateInterval", NULL
28073 };
28074
28075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28076 ecode1 = SWIG_AsVal_long(obj0, &val1);
28077 if (!SWIG_IsOK(ecode1)) {
28078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28079 }
28080 arg1 = static_cast< long >(val1);
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 wxUpdateUIEvent::SetUpdateInterval(arg1);
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_Py_Void();
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 long result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_From_long(static_cast< long >(result));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = 0;
28114 wxWindow *arg1 = (wxWindow *) 0 ;
28115 bool result;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 PyObject * obj0 = 0 ;
28119 char * kwnames[] = {
28120 (char *) "win", NULL
28121 };
28122
28123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28125 if (!SWIG_IsOK(res1)) {
28126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28127 }
28128 arg1 = reinterpret_cast< wxWindow * >(argp1);
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 {
28136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28137 }
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28145 PyObject *resultobj = 0;
28146
28147 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxUpdateUIEvent::ResetUpdateTime();
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxUpdateUIMode arg1 ;
28164 int val1 ;
28165 int ecode1 = 0 ;
28166 PyObject * obj0 = 0 ;
28167 char * kwnames[] = {
28168 (char *) "mode", NULL
28169 };
28170
28171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28172 ecode1 = SWIG_AsVal_int(obj0, &val1);
28173 if (!SWIG_IsOK(ecode1)) {
28174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28175 }
28176 arg1 = static_cast< wxUpdateUIMode >(val1);
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 wxUpdateUIEvent::SetMode(arg1);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_Py_Void();
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28191 PyObject *resultobj = 0;
28192 wxUpdateUIMode result;
28193
28194 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_From_int(static_cast< int >(result));
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 PyObject *obj;
28210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28211 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28212 return SWIG_Py_Void();
28213 }
28214
28215 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28216 return SWIG_Python_InitShadowInstance(args);
28217 }
28218
28219 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28220 PyObject *resultobj = 0;
28221 wxSysColourChangedEvent *result = 0 ;
28222
28223 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *obj;
28239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28240 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28241 return SWIG_Py_Void();
28242 }
28243
28244 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28245 return SWIG_Python_InitShadowInstance(args);
28246 }
28247
28248 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28249 PyObject *resultobj = 0;
28250 int arg1 = (int) 0 ;
28251 wxWindow *arg2 = (wxWindow *) NULL ;
28252 wxMouseCaptureChangedEvent *result = 0 ;
28253 int val1 ;
28254 int ecode1 = 0 ;
28255 void *argp2 = 0 ;
28256 int res2 = 0 ;
28257 PyObject * obj0 = 0 ;
28258 PyObject * obj1 = 0 ;
28259 char * kwnames[] = {
28260 (char *) "winid",(char *) "gainedCapture", NULL
28261 };
28262
28263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28264 if (obj0) {
28265 ecode1 = SWIG_AsVal_int(obj0, &val1);
28266 if (!SWIG_IsOK(ecode1)) {
28267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28268 }
28269 arg1 = static_cast< int >(val1);
28270 }
28271 if (obj1) {
28272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28273 if (!SWIG_IsOK(res2)) {
28274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28275 }
28276 arg2 = reinterpret_cast< wxWindow * >(argp2);
28277 }
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28292 PyObject *resultobj = 0;
28293 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28294 wxWindow *result = 0 ;
28295 void *argp1 = 0 ;
28296 int res1 = 0 ;
28297 PyObject *swig_obj[1] ;
28298
28299 if (!args) SWIG_fail;
28300 swig_obj[0] = args;
28301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28304 }
28305 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 {
28313 resultobj = wxPyMake_wxObject(result, (bool)0);
28314 }
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28322 PyObject *obj;
28323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28324 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28325 return SWIG_Py_Void();
28326 }
28327
28328 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 return SWIG_Python_InitShadowInstance(args);
28330 }
28331
28332 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj = 0;
28334 int arg1 = (int) 0 ;
28335 wxMouseCaptureLostEvent *result = 0 ;
28336 int val1 ;
28337 int ecode1 = 0 ;
28338 PyObject * obj0 = 0 ;
28339 char * kwnames[] = {
28340 (char *) "winid", NULL
28341 };
28342
28343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28344 if (obj0) {
28345 ecode1 = SWIG_AsVal_int(obj0, &val1);
28346 if (!SWIG_IsOK(ecode1)) {
28347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28348 }
28349 arg1 = static_cast< int >(val1);
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28365 PyObject *obj;
28366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28367 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28368 return SWIG_Py_Void();
28369 }
28370
28371 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28372 return SWIG_Python_InitShadowInstance(args);
28373 }
28374
28375 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28376 PyObject *resultobj = 0;
28377 wxDisplayChangedEvent *result = 0 ;
28378
28379 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28387 return resultobj;
28388 fail:
28389 return NULL;
28390 }
28391
28392
28393 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28394 PyObject *obj;
28395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28396 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28397 return SWIG_Py_Void();
28398 }
28399
28400 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401 return SWIG_Python_InitShadowInstance(args);
28402 }
28403
28404 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj = 0;
28406 int arg1 = (int) 0 ;
28407 wxPaletteChangedEvent *result = 0 ;
28408 int val1 ;
28409 int ecode1 = 0 ;
28410 PyObject * obj0 = 0 ;
28411 char * kwnames[] = {
28412 (char *) "id", NULL
28413 };
28414
28415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28416 if (obj0) {
28417 ecode1 = SWIG_AsVal_int(obj0, &val1);
28418 if (!SWIG_IsOK(ecode1)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28420 }
28421 arg1 = static_cast< int >(val1);
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj = 0;
28438 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28439 wxWindow *arg2 = (wxWindow *) 0 ;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 void *argp2 = 0 ;
28443 int res2 = 0 ;
28444 PyObject * obj0 = 0 ;
28445 PyObject * obj1 = 0 ;
28446 char * kwnames[] = {
28447 (char *) "self",(char *) "win", NULL
28448 };
28449
28450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28452 if (!SWIG_IsOK(res1)) {
28453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28454 }
28455 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28457 if (!SWIG_IsOK(res2)) {
28458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28459 }
28460 arg2 = reinterpret_cast< wxWindow * >(argp2);
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 (arg1)->SetChangedWindow(arg2);
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_Py_Void();
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28477 wxWindow *result = 0 ;
28478 void *argp1 = 0 ;
28479 int res1 = 0 ;
28480 PyObject *swig_obj[1] ;
28481
28482 if (!args) SWIG_fail;
28483 swig_obj[0] = args;
28484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28485 if (!SWIG_IsOK(res1)) {
28486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28487 }
28488 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (wxWindow *)(arg1)->GetChangedWindow();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = wxPyMake_wxObject(result, (bool)0);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *obj;
28506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28507 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28508 return SWIG_Py_Void();
28509 }
28510
28511 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28512 return SWIG_Python_InitShadowInstance(args);
28513 }
28514
28515 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28516 PyObject *resultobj = 0;
28517 int arg1 = (int) 0 ;
28518 wxQueryNewPaletteEvent *result = 0 ;
28519 int val1 ;
28520 int ecode1 = 0 ;
28521 PyObject * obj0 = 0 ;
28522 char * kwnames[] = {
28523 (char *) "winid", NULL
28524 };
28525
28526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28527 if (obj0) {
28528 ecode1 = SWIG_AsVal_int(obj0, &val1);
28529 if (!SWIG_IsOK(ecode1)) {
28530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28531 }
28532 arg1 = static_cast< int >(val1);
28533 }
28534 {
28535 PyThreadState* __tstate = wxPyBeginAllowThreads();
28536 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28537 wxPyEndAllowThreads(__tstate);
28538 if (PyErr_Occurred()) SWIG_fail;
28539 }
28540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28548 PyObject *resultobj = 0;
28549 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28550 bool arg2 ;
28551 void *argp1 = 0 ;
28552 int res1 = 0 ;
28553 bool val2 ;
28554 int ecode2 = 0 ;
28555 PyObject * obj0 = 0 ;
28556 PyObject * obj1 = 0 ;
28557 char * kwnames[] = {
28558 (char *) "self",(char *) "realized", NULL
28559 };
28560
28561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28563 if (!SWIG_IsOK(res1)) {
28564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28565 }
28566 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28568 if (!SWIG_IsOK(ecode2)) {
28569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28570 }
28571 arg2 = static_cast< bool >(val2);
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->SetPaletteRealized(arg2);
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_Py_Void();
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28588 bool result;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28598 }
28599 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *obj;
28617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28618 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28619 return SWIG_Py_Void();
28620 }
28621
28622 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28623 return SWIG_Python_InitShadowInstance(args);
28624 }
28625
28626 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 PyObject *resultobj = 0;
28628 wxNavigationKeyEvent *result = 0 ;
28629
28630 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28647 bool result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28657 }
28658 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28667 }
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj = 0;
28676 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28677 bool arg2 ;
28678 void *argp1 = 0 ;
28679 int res1 = 0 ;
28680 bool val2 ;
28681 int ecode2 = 0 ;
28682 PyObject * obj0 = 0 ;
28683 PyObject * obj1 = 0 ;
28684 char * kwnames[] = {
28685 (char *) "self",(char *) "forward", NULL
28686 };
28687
28688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28690 if (!SWIG_IsOK(res1)) {
28691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28692 }
28693 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28694 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28695 if (!SWIG_IsOK(ecode2)) {
28696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28697 }
28698 arg2 = static_cast< bool >(val2);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 (arg1)->SetDirection(arg2);
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_Py_Void();
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28713 PyObject *resultobj = 0;
28714 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28715 bool result;
28716 void *argp1 = 0 ;
28717 int res1 = 0 ;
28718 PyObject *swig_obj[1] ;
28719
28720 if (!args) SWIG_fail;
28721 swig_obj[0] = args;
28722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28725 }
28726 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 {
28734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28735 }
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = 0;
28744 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28745 bool arg2 ;
28746 void *argp1 = 0 ;
28747 int res1 = 0 ;
28748 bool val2 ;
28749 int ecode2 = 0 ;
28750 PyObject * obj0 = 0 ;
28751 PyObject * obj1 = 0 ;
28752 char * kwnames[] = {
28753 (char *) "self",(char *) "ischange", NULL
28754 };
28755
28756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28760 }
28761 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28763 if (!SWIG_IsOK(ecode2)) {
28764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28765 }
28766 arg2 = static_cast< bool >(val2);
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 (arg1)->SetWindowChange(arg2);
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_Py_Void();
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28783 bool result;
28784 void *argp1 = 0 ;
28785 int res1 = 0 ;
28786 PyObject *swig_obj[1] ;
28787
28788 if (!args) SWIG_fail;
28789 swig_obj[0] = args;
28790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28793 }
28794 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 {
28802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28803 }
28804 return resultobj;
28805 fail:
28806 return NULL;
28807 }
28808
28809
28810 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28811 PyObject *resultobj = 0;
28812 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28813 bool arg2 ;
28814 void *argp1 = 0 ;
28815 int res1 = 0 ;
28816 bool val2 ;
28817 int ecode2 = 0 ;
28818 PyObject * obj0 = 0 ;
28819 PyObject * obj1 = 0 ;
28820 char * kwnames[] = {
28821 (char *) "self",(char *) "bIs", NULL
28822 };
28823
28824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28826 if (!SWIG_IsOK(res1)) {
28827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28828 }
28829 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28830 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28831 if (!SWIG_IsOK(ecode2)) {
28832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28833 }
28834 arg2 = static_cast< bool >(val2);
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 (arg1)->SetFromTab(arg2);
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 resultobj = SWIG_Py_Void();
28842 return resultobj;
28843 fail:
28844 return NULL;
28845 }
28846
28847
28848 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28849 PyObject *resultobj = 0;
28850 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28851 long arg2 ;
28852 void *argp1 = 0 ;
28853 int res1 = 0 ;
28854 long val2 ;
28855 int ecode2 = 0 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 char * kwnames[] = {
28859 (char *) "self",(char *) "flags", NULL
28860 };
28861
28862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28864 if (!SWIG_IsOK(res1)) {
28865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28866 }
28867 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28868 ecode2 = SWIG_AsVal_long(obj1, &val2);
28869 if (!SWIG_IsOK(ecode2)) {
28870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28871 }
28872 arg2 = static_cast< long >(val2);
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->SetFlags(arg2);
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_Py_Void();
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28887 PyObject *resultobj = 0;
28888 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28889 wxWindow *result = 0 ;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 PyObject *swig_obj[1] ;
28893
28894 if (!args) SWIG_fail;
28895 swig_obj[0] = args;
28896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28897 if (!SWIG_IsOK(res1)) {
28898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28899 }
28900 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 {
28908 resultobj = wxPyMake_wxObject(result, (bool)0);
28909 }
28910 return resultobj;
28911 fail:
28912 return NULL;
28913 }
28914
28915
28916 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28917 PyObject *resultobj = 0;
28918 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28919 wxWindow *arg2 = (wxWindow *) 0 ;
28920 void *argp1 = 0 ;
28921 int res1 = 0 ;
28922 void *argp2 = 0 ;
28923 int res2 = 0 ;
28924 PyObject * obj0 = 0 ;
28925 PyObject * obj1 = 0 ;
28926 char * kwnames[] = {
28927 (char *) "self",(char *) "win", NULL
28928 };
28929
28930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28932 if (!SWIG_IsOK(res1)) {
28933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28934 }
28935 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28937 if (!SWIG_IsOK(res2)) {
28938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28939 }
28940 arg2 = reinterpret_cast< wxWindow * >(argp2);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 (arg1)->SetCurrentFocus(arg2);
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_Py_Void();
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *obj;
28956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28957 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28958 return SWIG_Py_Void();
28959 }
28960
28961 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28962 return SWIG_Python_InitShadowInstance(args);
28963 }
28964
28965 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj = 0;
28967 wxWindow *arg1 = (wxWindow *) NULL ;
28968 wxWindowCreateEvent *result = 0 ;
28969 void *argp1 = 0 ;
28970 int res1 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 char * kwnames[] = {
28973 (char *) "win", NULL
28974 };
28975
28976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28977 if (obj0) {
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28981 }
28982 arg1 = reinterpret_cast< wxWindow * >(argp1);
28983 }
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29000 wxWindow *result = 0 ;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29010 }
29011 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 {
29019 resultobj = wxPyMake_wxObject(result, (bool)0);
29020 }
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *obj;
29029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29030 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29031 return SWIG_Py_Void();
29032 }
29033
29034 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29035 return SWIG_Python_InitShadowInstance(args);
29036 }
29037
29038 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj = 0;
29040 wxWindow *arg1 = (wxWindow *) NULL ;
29041 wxWindowDestroyEvent *result = 0 ;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject * obj0 = 0 ;
29045 char * kwnames[] = {
29046 (char *) "win", NULL
29047 };
29048
29049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29050 if (obj0) {
29051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29052 if (!SWIG_IsOK(res1)) {
29053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29054 }
29055 arg1 = reinterpret_cast< wxWindow * >(argp1);
29056 }
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29073 wxWindow *result = 0 ;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject *swig_obj[1] ;
29077
29078 if (!args) SWIG_fail;
29079 swig_obj[0] = args;
29080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29083 }
29084 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 {
29092 resultobj = wxPyMake_wxObject(result, (bool)0);
29093 }
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29101 PyObject *obj;
29102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29103 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29104 return SWIG_Py_Void();
29105 }
29106
29107 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 return SWIG_Python_InitShadowInstance(args);
29109 }
29110
29111 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj = 0;
29113 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29114 int arg2 = (int) 0 ;
29115 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29116 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29117 wxContextMenuEvent *result = 0 ;
29118 int val1 ;
29119 int ecode1 = 0 ;
29120 int val2 ;
29121 int ecode2 = 0 ;
29122 wxPoint temp3 ;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 PyObject * obj2 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "type",(char *) "winid",(char *) "pt", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29131 if (obj0) {
29132 ecode1 = SWIG_AsVal_int(obj0, &val1);
29133 if (!SWIG_IsOK(ecode1)) {
29134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29135 }
29136 arg1 = static_cast< wxEventType >(val1);
29137 }
29138 if (obj1) {
29139 ecode2 = SWIG_AsVal_int(obj1, &val2);
29140 if (!SWIG_IsOK(ecode2)) {
29141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29142 }
29143 arg2 = static_cast< int >(val2);
29144 }
29145 if (obj2) {
29146 {
29147 arg3 = &temp3;
29148 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29149 }
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29165 PyObject *resultobj = 0;
29166 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29167 wxPoint *result = 0 ;
29168 void *argp1 = 0 ;
29169 int res1 = 0 ;
29170 PyObject *swig_obj[1] ;
29171
29172 if (!args) SWIG_fail;
29173 swig_obj[0] = args;
29174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29177 }
29178 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 {
29182 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29183 result = (wxPoint *) &_result_ref;
29184 }
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj = 0;
29197 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29198 wxPoint *arg2 = 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 wxPoint temp2 ;
29202 PyObject * obj0 = 0 ;
29203 PyObject * obj1 = 0 ;
29204 char * kwnames[] = {
29205 (char *) "self",(char *) "pos", NULL
29206 };
29207
29208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29210 if (!SWIG_IsOK(res1)) {
29211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29212 }
29213 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29214 {
29215 arg2 = &temp2;
29216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29217 }
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->SetPosition((wxPoint const &)*arg2);
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_Py_Void();
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *obj;
29233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29234 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29235 return SWIG_Py_Void();
29236 }
29237
29238 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29239 return SWIG_Python_InitShadowInstance(args);
29240 }
29241
29242 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxIdleEvent *result = 0 ;
29245
29246 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 result = (wxIdleEvent *)new wxIdleEvent();
29250 wxPyEndAllowThreads(__tstate);
29251 if (PyErr_Occurred()) SWIG_fail;
29252 }
29253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj = 0;
29262 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29263 bool arg2 = (bool) true ;
29264 void *argp1 = 0 ;
29265 int res1 = 0 ;
29266 bool val2 ;
29267 int ecode2 = 0 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 char * kwnames[] = {
29271 (char *) "self",(char *) "needMore", NULL
29272 };
29273
29274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29276 if (!SWIG_IsOK(res1)) {
29277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29278 }
29279 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29280 if (obj1) {
29281 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29282 if (!SWIG_IsOK(ecode2)) {
29283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29284 }
29285 arg2 = static_cast< bool >(val2);
29286 }
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 (arg1)->RequestMore(arg2);
29290 wxPyEndAllowThreads(__tstate);
29291 if (PyErr_Occurred()) SWIG_fail;
29292 }
29293 resultobj = SWIG_Py_Void();
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29301 PyObject *resultobj = 0;
29302 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29303 bool result;
29304 void *argp1 = 0 ;
29305 int res1 = 0 ;
29306 PyObject *swig_obj[1] ;
29307
29308 if (!args) SWIG_fail;
29309 swig_obj[0] = args;
29310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29313 }
29314 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 {
29322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29323 }
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj = 0;
29332 wxIdleMode arg1 ;
29333 int val1 ;
29334 int ecode1 = 0 ;
29335 PyObject * obj0 = 0 ;
29336 char * kwnames[] = {
29337 (char *) "mode", NULL
29338 };
29339
29340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29341 ecode1 = SWIG_AsVal_int(obj0, &val1);
29342 if (!SWIG_IsOK(ecode1)) {
29343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29344 }
29345 arg1 = static_cast< wxIdleMode >(val1);
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 wxIdleEvent::SetMode(arg1);
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_Py_Void();
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29360 PyObject *resultobj = 0;
29361 wxIdleMode result;
29362
29363 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 result = (wxIdleMode)wxIdleEvent::GetMode();
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_From_int(static_cast< int >(result));
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxWindow *arg1 = (wxWindow *) 0 ;
29380 bool result;
29381 void *argp1 = 0 ;
29382 int res1 = 0 ;
29383 PyObject * obj0 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "win", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29392 }
29393 arg1 = reinterpret_cast< wxWindow * >(argp1);
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 result = (bool)wxIdleEvent::CanSend(arg1);
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 {
29401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29402 }
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *obj;
29411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29412 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29413 return SWIG_Py_Void();
29414 }
29415
29416 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 return SWIG_Python_InitShadowInstance(args);
29418 }
29419
29420 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = 0;
29422 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29423 int arg2 = (int) 0 ;
29424 wxClipboardTextEvent *result = 0 ;
29425 int val1 ;
29426 int ecode1 = 0 ;
29427 int val2 ;
29428 int ecode2 = 0 ;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "type",(char *) "winid", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29436 if (obj0) {
29437 ecode1 = SWIG_AsVal_int(obj0, &val1);
29438 if (!SWIG_IsOK(ecode1)) {
29439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29440 }
29441 arg1 = static_cast< wxEventType >(val1);
29442 }
29443 if (obj1) {
29444 ecode2 = SWIG_AsVal_int(obj1, &val2);
29445 if (!SWIG_IsOK(ecode2)) {
29446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29447 }
29448 arg2 = static_cast< int >(val2);
29449 }
29450 {
29451 PyThreadState* __tstate = wxPyBeginAllowThreads();
29452 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29453 wxPyEndAllowThreads(__tstate);
29454 if (PyErr_Occurred()) SWIG_fail;
29455 }
29456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29464 PyObject *obj;
29465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29466 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29467 return SWIG_Py_Void();
29468 }
29469
29470 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29471 return SWIG_Python_InitShadowInstance(args);
29472 }
29473
29474 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 int arg1 = (int) 0 ;
29477 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29478 wxPyEvent *result = 0 ;
29479 int val1 ;
29480 int ecode1 = 0 ;
29481 int val2 ;
29482 int ecode2 = 0 ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char * kwnames[] = {
29486 (char *) "winid",(char *) "eventType", NULL
29487 };
29488
29489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29490 if (obj0) {
29491 ecode1 = SWIG_AsVal_int(obj0, &val1);
29492 if (!SWIG_IsOK(ecode1)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29494 }
29495 arg1 = static_cast< int >(val1);
29496 }
29497 if (obj1) {
29498 ecode2 = SWIG_AsVal_int(obj1, &val2);
29499 if (!SWIG_IsOK(ecode2)) {
29500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29501 }
29502 arg2 = static_cast< wxEventType >(val2);
29503 }
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29518 PyObject *resultobj = 0;
29519 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29520 void *argp1 = 0 ;
29521 int res1 = 0 ;
29522 PyObject *swig_obj[1] ;
29523
29524 if (!args) SWIG_fail;
29525 swig_obj[0] = args;
29526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29527 if (!SWIG_IsOK(res1)) {
29528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29529 }
29530 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 delete arg1;
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_Py_Void();
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj = 0;
29547 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29548 PyObject *arg2 = (PyObject *) 0 ;
29549 void *argp1 = 0 ;
29550 int res1 = 0 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 char * kwnames[] = {
29554 (char *) "self",(char *) "self", NULL
29555 };
29556
29557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29559 if (!SWIG_IsOK(res1)) {
29560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29561 }
29562 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29563 arg2 = obj1;
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 (arg1)->SetSelf(arg2);
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 resultobj = SWIG_Py_Void();
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29578 PyObject *resultobj = 0;
29579 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29580 PyObject *result = 0 ;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 PyObject *swig_obj[1] ;
29584
29585 if (!args) SWIG_fail;
29586 swig_obj[0] = args;
29587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29588 if (!SWIG_IsOK(res1)) {
29589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29590 }
29591 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (PyObject *)(arg1)->GetSelf();
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = result;
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *obj;
29607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29608 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29609 return SWIG_Py_Void();
29610 }
29611
29612 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29613 return SWIG_Python_InitShadowInstance(args);
29614 }
29615
29616 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29617 PyObject *resultobj = 0;
29618 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29619 int arg2 = (int) 0 ;
29620 wxPyCommandEvent *result = 0 ;
29621 int val1 ;
29622 int ecode1 = 0 ;
29623 int val2 ;
29624 int ecode2 = 0 ;
29625 PyObject * obj0 = 0 ;
29626 PyObject * obj1 = 0 ;
29627 char * kwnames[] = {
29628 (char *) "eventType",(char *) "id", NULL
29629 };
29630
29631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29632 if (obj0) {
29633 ecode1 = SWIG_AsVal_int(obj0, &val1);
29634 if (!SWIG_IsOK(ecode1)) {
29635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29636 }
29637 arg1 = static_cast< wxEventType >(val1);
29638 }
29639 if (obj1) {
29640 ecode2 = SWIG_AsVal_int(obj1, &val2);
29641 if (!SWIG_IsOK(ecode2)) {
29642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29643 }
29644 arg2 = static_cast< int >(val2);
29645 }
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29660 PyObject *resultobj = 0;
29661 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29662 void *argp1 = 0 ;
29663 int res1 = 0 ;
29664 PyObject *swig_obj[1] ;
29665
29666 if (!args) SWIG_fail;
29667 swig_obj[0] = args;
29668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29669 if (!SWIG_IsOK(res1)) {
29670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29671 }
29672 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 delete arg1;
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 resultobj = SWIG_Py_Void();
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj = 0;
29689 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29690 PyObject *arg2 = (PyObject *) 0 ;
29691 void *argp1 = 0 ;
29692 int res1 = 0 ;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 char * kwnames[] = {
29696 (char *) "self",(char *) "self", NULL
29697 };
29698
29699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29701 if (!SWIG_IsOK(res1)) {
29702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29703 }
29704 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29705 arg2 = obj1;
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 (arg1)->SetSelf(arg2);
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = SWIG_Py_Void();
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29720 PyObject *resultobj = 0;
29721 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29722 PyObject *result = 0 ;
29723 void *argp1 = 0 ;
29724 int res1 = 0 ;
29725 PyObject *swig_obj[1] ;
29726
29727 if (!args) SWIG_fail;
29728 swig_obj[0] = args;
29729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29732 }
29733 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (PyObject *)(arg1)->GetSelf();
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 resultobj = result;
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29748 PyObject *obj;
29749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29750 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29751 return SWIG_Py_Void();
29752 }
29753
29754 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 return SWIG_Python_InitShadowInstance(args);
29756 }
29757
29758 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj = 0;
29760 wxWindow *arg1 = (wxWindow *) 0 ;
29761 wxDateTime *arg2 = 0 ;
29762 wxEventType arg3 ;
29763 wxDateEvent *result = 0 ;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 void *argp2 = 0 ;
29767 int res2 = 0 ;
29768 int val3 ;
29769 int ecode3 = 0 ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 char * kwnames[] = {
29774 (char *) "win",(char *) "dt",(char *) "type", NULL
29775 };
29776
29777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29779 if (!SWIG_IsOK(res1)) {
29780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29781 }
29782 arg1 = reinterpret_cast< wxWindow * >(argp1);
29783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29784 if (!SWIG_IsOK(res2)) {
29785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29786 }
29787 if (!argp2) {
29788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29789 }
29790 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29791 ecode3 = SWIG_AsVal_int(obj2, &val3);
29792 if (!SWIG_IsOK(ecode3)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29794 }
29795 arg3 = static_cast< wxEventType >(val3);
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29812 wxDateTime *result = 0 ;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 PyObject *swig_obj[1] ;
29816
29817 if (!args) SWIG_fail;
29818 swig_obj[0] = args;
29819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29822 }
29823 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 {
29827 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29828 result = (wxDateTime *) &_result_ref;
29829 }
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj = 0;
29842 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29843 wxDateTime *arg2 = 0 ;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 void *argp2 = 0 ;
29847 int res2 = 0 ;
29848 PyObject * obj0 = 0 ;
29849 PyObject * obj1 = 0 ;
29850 char * kwnames[] = {
29851 (char *) "self",(char *) "date", NULL
29852 };
29853
29854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29856 if (!SWIG_IsOK(res1)) {
29857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29858 }
29859 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29861 if (!SWIG_IsOK(res2)) {
29862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29863 }
29864 if (!argp2) {
29865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29866 }
29867 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->SetDate((wxDateTime const &)*arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_Py_Void();
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *obj;
29883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29884 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29885 return SWIG_Py_Void();
29886 }
29887
29888 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29889 return SWIG_Python_InitShadowInstance(args);
29890 }
29891
29892 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 wxPyApp *result = 0 ;
29895
29896 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (wxPyApp *)new_wxPyApp();
29900 wxPyEndAllowThreads(__tstate);
29901 if (PyErr_Occurred()) SWIG_fail;
29902 }
29903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29911 PyObject *resultobj = 0;
29912 wxPyApp *arg1 = (wxPyApp *) 0 ;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 PyObject *swig_obj[1] ;
29916
29917 if (!args) SWIG_fail;
29918 swig_obj[0] = args;
29919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29920 if (!SWIG_IsOK(res1)) {
29921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29922 }
29923 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 delete arg1;
29927
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 resultobj = SWIG_Py_Void();
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj = 0;
29940 wxPyApp *arg1 = (wxPyApp *) 0 ;
29941 PyObject *arg2 = (PyObject *) 0 ;
29942 PyObject *arg3 = (PyObject *) 0 ;
29943 bool arg4 = (bool) false ;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 bool val4 ;
29947 int ecode4 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 PyObject * obj2 = 0 ;
29951 PyObject * obj3 = 0 ;
29952 char * kwnames[] = {
29953 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29954 };
29955
29956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29960 }
29961 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29962 arg2 = obj1;
29963 arg3 = obj2;
29964 if (obj3) {
29965 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29966 if (!SWIG_IsOK(ecode4)) {
29967 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29968 }
29969 arg4 = static_cast< bool >(val4);
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 resultobj = SWIG_Py_Void();
29978 return resultobj;
29979 fail:
29980 return NULL;
29981 }
29982
29983
29984 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29985 PyObject *resultobj = 0;
29986 wxPyApp *arg1 = (wxPyApp *) 0 ;
29987 wxString result;
29988 void *argp1 = 0 ;
29989 int res1 = 0 ;
29990 PyObject *swig_obj[1] ;
29991
29992 if (!args) SWIG_fail;
29993 swig_obj[0] = args;
29994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29995 if (!SWIG_IsOK(res1)) {
29996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
29997 }
29998 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 result = ((wxPyApp const *)arg1)->GetAppName();
30002 wxPyEndAllowThreads(__tstate);
30003 if (PyErr_Occurred()) SWIG_fail;
30004 }
30005 {
30006 #if wxUSE_UNICODE
30007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30008 #else
30009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30010 #endif
30011 }
30012 return resultobj;
30013 fail:
30014 return NULL;
30015 }
30016
30017
30018 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30019 PyObject *resultobj = 0;
30020 wxPyApp *arg1 = (wxPyApp *) 0 ;
30021 wxString *arg2 = 0 ;
30022 void *argp1 = 0 ;
30023 int res1 = 0 ;
30024 bool temp2 = false ;
30025 PyObject * obj0 = 0 ;
30026 PyObject * obj1 = 0 ;
30027 char * kwnames[] = {
30028 (char *) "self",(char *) "name", NULL
30029 };
30030
30031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30033 if (!SWIG_IsOK(res1)) {
30034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30035 }
30036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30037 {
30038 arg2 = wxString_in_helper(obj1);
30039 if (arg2 == NULL) SWIG_fail;
30040 temp2 = true;
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 (arg1)->SetAppName((wxString const &)*arg2);
30045 wxPyEndAllowThreads(__tstate);
30046 if (PyErr_Occurred()) SWIG_fail;
30047 }
30048 resultobj = SWIG_Py_Void();
30049 {
30050 if (temp2)
30051 delete arg2;
30052 }
30053 return resultobj;
30054 fail:
30055 {
30056 if (temp2)
30057 delete arg2;
30058 }
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30064 PyObject *resultobj = 0;
30065 wxPyApp *arg1 = (wxPyApp *) 0 ;
30066 wxString result;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 PyObject *swig_obj[1] ;
30070
30071 if (!args) SWIG_fail;
30072 swig_obj[0] = args;
30073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30076 }
30077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30078 {
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = ((wxPyApp const *)arg1)->GetClassName();
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 {
30085 #if wxUSE_UNICODE
30086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30087 #else
30088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30089 #endif
30090 }
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj = 0;
30099 wxPyApp *arg1 = (wxPyApp *) 0 ;
30100 wxString *arg2 = 0 ;
30101 void *argp1 = 0 ;
30102 int res1 = 0 ;
30103 bool temp2 = false ;
30104 PyObject * obj0 = 0 ;
30105 PyObject * obj1 = 0 ;
30106 char * kwnames[] = {
30107 (char *) "self",(char *) "name", NULL
30108 };
30109
30110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30112 if (!SWIG_IsOK(res1)) {
30113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30114 }
30115 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30116 {
30117 arg2 = wxString_in_helper(obj1);
30118 if (arg2 == NULL) SWIG_fail;
30119 temp2 = true;
30120 }
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 (arg1)->SetClassName((wxString const &)*arg2);
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_Py_Void();
30128 {
30129 if (temp2)
30130 delete arg2;
30131 }
30132 return resultobj;
30133 fail:
30134 {
30135 if (temp2)
30136 delete arg2;
30137 }
30138 return NULL;
30139 }
30140
30141
30142 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30143 PyObject *resultobj = 0;
30144 wxPyApp *arg1 = (wxPyApp *) 0 ;
30145 wxString *result = 0 ;
30146 void *argp1 = 0 ;
30147 int res1 = 0 ;
30148 PyObject *swig_obj[1] ;
30149
30150 if (!args) SWIG_fail;
30151 swig_obj[0] = args;
30152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30153 if (!SWIG_IsOK(res1)) {
30154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30155 }
30156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 {
30160 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30161 result = (wxString *) &_result_ref;
30162 }
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 {
30167 #if wxUSE_UNICODE
30168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30169 #else
30170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30171 #endif
30172 }
30173 return resultobj;
30174 fail:
30175 return NULL;
30176 }
30177
30178
30179 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30180 PyObject *resultobj = 0;
30181 wxPyApp *arg1 = (wxPyApp *) 0 ;
30182 wxString *arg2 = 0 ;
30183 void *argp1 = 0 ;
30184 int res1 = 0 ;
30185 bool temp2 = false ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 char * kwnames[] = {
30189 (char *) "self",(char *) "name", NULL
30190 };
30191
30192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30194 if (!SWIG_IsOK(res1)) {
30195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30196 }
30197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30198 {
30199 arg2 = wxString_in_helper(obj1);
30200 if (arg2 == NULL) SWIG_fail;
30201 temp2 = true;
30202 }
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 (arg1)->SetVendorName((wxString const &)*arg2);
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 resultobj = SWIG_Py_Void();
30210 {
30211 if (temp2)
30212 delete arg2;
30213 }
30214 return resultobj;
30215 fail:
30216 {
30217 if (temp2)
30218 delete arg2;
30219 }
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30225 PyObject *resultobj = 0;
30226 wxPyApp *arg1 = (wxPyApp *) 0 ;
30227 wxAppTraits *result = 0 ;
30228 void *argp1 = 0 ;
30229 int res1 = 0 ;
30230 PyObject *swig_obj[1] ;
30231
30232 if (!args) SWIG_fail;
30233 swig_obj[0] = args;
30234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30235 if (!SWIG_IsOK(res1)) {
30236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30237 }
30238 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = (wxAppTraits *)(arg1)->GetTraits();
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30246 return resultobj;
30247 fail:
30248 return NULL;
30249 }
30250
30251
30252 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30253 PyObject *resultobj = 0;
30254 wxPyApp *arg1 = (wxPyApp *) 0 ;
30255 void *argp1 = 0 ;
30256 int res1 = 0 ;
30257 PyObject *swig_obj[1] ;
30258
30259 if (!args) SWIG_fail;
30260 swig_obj[0] = args;
30261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30262 if (!SWIG_IsOK(res1)) {
30263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30264 }
30265 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30266 {
30267 PyThreadState* __tstate = wxPyBeginAllowThreads();
30268 (arg1)->ProcessPendingEvents();
30269 wxPyEndAllowThreads(__tstate);
30270 if (PyErr_Occurred()) SWIG_fail;
30271 }
30272 resultobj = SWIG_Py_Void();
30273 return resultobj;
30274 fail:
30275 return NULL;
30276 }
30277
30278
30279 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30280 PyObject *resultobj = 0;
30281 wxPyApp *arg1 = (wxPyApp *) 0 ;
30282 bool arg2 = (bool) false ;
30283 bool result;
30284 void *argp1 = 0 ;
30285 int res1 = 0 ;
30286 bool val2 ;
30287 int ecode2 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 PyObject * obj1 = 0 ;
30290 char * kwnames[] = {
30291 (char *) "self",(char *) "onlyIfNeeded", NULL
30292 };
30293
30294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30296 if (!SWIG_IsOK(res1)) {
30297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30298 }
30299 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30300 if (obj1) {
30301 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30302 if (!SWIG_IsOK(ecode2)) {
30303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30304 }
30305 arg2 = static_cast< bool >(val2);
30306 }
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = (bool)(arg1)->Yield(arg2);
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 {
30314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30315 }
30316 return resultobj;
30317 fail:
30318 return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30323 PyObject *resultobj = 0;
30324 wxPyApp *arg1 = (wxPyApp *) 0 ;
30325 void *argp1 = 0 ;
30326 int res1 = 0 ;
30327 PyObject *swig_obj[1] ;
30328
30329 if (!args) SWIG_fail;
30330 swig_obj[0] = args;
30331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30332 if (!SWIG_IsOK(res1)) {
30333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30334 }
30335 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30336 {
30337 PyThreadState* __tstate = wxPyBeginAllowThreads();
30338 (arg1)->WakeUpIdle();
30339 wxPyEndAllowThreads(__tstate);
30340 if (PyErr_Occurred()) SWIG_fail;
30341 }
30342 resultobj = SWIG_Py_Void();
30343 return resultobj;
30344 fail:
30345 return NULL;
30346 }
30347
30348
30349 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30350 PyObject *resultobj = 0;
30351 bool result;
30352
30353 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30354 {
30355 PyThreadState* __tstate = wxPyBeginAllowThreads();
30356 result = (bool)wxPyApp::IsMainLoopRunning();
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 {
30361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30362 }
30363 return resultobj;
30364 fail:
30365 return NULL;
30366 }
30367
30368
30369 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30370 PyObject *resultobj = 0;
30371 wxPyApp *arg1 = (wxPyApp *) 0 ;
30372 int result;
30373 void *argp1 = 0 ;
30374 int res1 = 0 ;
30375 PyObject *swig_obj[1] ;
30376
30377 if (!args) SWIG_fail;
30378 swig_obj[0] = args;
30379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30380 if (!SWIG_IsOK(res1)) {
30381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30382 }
30383 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30384 {
30385 PyThreadState* __tstate = wxPyBeginAllowThreads();
30386 result = (int)(arg1)->MainLoop();
30387 wxPyEndAllowThreads(__tstate);
30388 if (PyErr_Occurred()) SWIG_fail;
30389 }
30390 resultobj = SWIG_From_int(static_cast< int >(result));
30391 return resultobj;
30392 fail:
30393 return NULL;
30394 }
30395
30396
30397 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30398 PyObject *resultobj = 0;
30399 wxPyApp *arg1 = (wxPyApp *) 0 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 PyObject *swig_obj[1] ;
30403
30404 if (!args) SWIG_fail;
30405 swig_obj[0] = args;
30406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30407 if (!SWIG_IsOK(res1)) {
30408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30409 }
30410 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 (arg1)->Exit();
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30425 PyObject *resultobj = 0;
30426 wxPyApp *arg1 = (wxPyApp *) 0 ;
30427 wxLayoutDirection result;
30428 void *argp1 = 0 ;
30429 int res1 = 0 ;
30430 PyObject *swig_obj[1] ;
30431
30432 if (!args) SWIG_fail;
30433 swig_obj[0] = args;
30434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30435 if (!SWIG_IsOK(res1)) {
30436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30437 }
30438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30442 wxPyEndAllowThreads(__tstate);
30443 if (PyErr_Occurred()) SWIG_fail;
30444 }
30445 resultobj = SWIG_From_int(static_cast< int >(result));
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30453 PyObject *resultobj = 0;
30454 wxPyApp *arg1 = (wxPyApp *) 0 ;
30455 void *argp1 = 0 ;
30456 int res1 = 0 ;
30457 PyObject *swig_obj[1] ;
30458
30459 if (!args) SWIG_fail;
30460 swig_obj[0] = args;
30461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30462 if (!SWIG_IsOK(res1)) {
30463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30464 }
30465 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 (arg1)->ExitMainLoop();
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 resultobj = SWIG_Py_Void();
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30480 PyObject *resultobj = 0;
30481 wxPyApp *arg1 = (wxPyApp *) 0 ;
30482 bool result;
30483 void *argp1 = 0 ;
30484 int res1 = 0 ;
30485 PyObject *swig_obj[1] ;
30486
30487 if (!args) SWIG_fail;
30488 swig_obj[0] = args;
30489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30490 if (!SWIG_IsOK(res1)) {
30491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30492 }
30493 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30494 {
30495 PyThreadState* __tstate = wxPyBeginAllowThreads();
30496 result = (bool)(arg1)->Pending();
30497 wxPyEndAllowThreads(__tstate);
30498 if (PyErr_Occurred()) SWIG_fail;
30499 }
30500 {
30501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30502 }
30503 return resultobj;
30504 fail:
30505 return NULL;
30506 }
30507
30508
30509 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30510 PyObject *resultobj = 0;
30511 wxPyApp *arg1 = (wxPyApp *) 0 ;
30512 bool result;
30513 void *argp1 = 0 ;
30514 int res1 = 0 ;
30515 PyObject *swig_obj[1] ;
30516
30517 if (!args) SWIG_fail;
30518 swig_obj[0] = args;
30519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30520 if (!SWIG_IsOK(res1)) {
30521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30522 }
30523 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 result = (bool)(arg1)->Dispatch();
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 {
30531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30532 }
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30540 PyObject *resultobj = 0;
30541 wxPyApp *arg1 = (wxPyApp *) 0 ;
30542 bool result;
30543 void *argp1 = 0 ;
30544 int res1 = 0 ;
30545 PyObject *swig_obj[1] ;
30546
30547 if (!args) SWIG_fail;
30548 swig_obj[0] = args;
30549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30550 if (!SWIG_IsOK(res1)) {
30551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30552 }
30553 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30554 {
30555 PyThreadState* __tstate = wxPyBeginAllowThreads();
30556 result = (bool)(arg1)->ProcessIdle();
30557 wxPyEndAllowThreads(__tstate);
30558 if (PyErr_Occurred()) SWIG_fail;
30559 }
30560 {
30561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30562 }
30563 return resultobj;
30564 fail:
30565 return NULL;
30566 }
30567
30568
30569 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30570 PyObject *resultobj = 0;
30571 wxPyApp *arg1 = (wxPyApp *) 0 ;
30572 wxWindow *arg2 = (wxWindow *) 0 ;
30573 wxIdleEvent *arg3 = 0 ;
30574 bool result;
30575 void *argp1 = 0 ;
30576 int res1 = 0 ;
30577 void *argp2 = 0 ;
30578 int res2 = 0 ;
30579 void *argp3 = 0 ;
30580 int res3 = 0 ;
30581 PyObject * obj0 = 0 ;
30582 PyObject * obj1 = 0 ;
30583 PyObject * obj2 = 0 ;
30584 char * kwnames[] = {
30585 (char *) "self",(char *) "win",(char *) "event", NULL
30586 };
30587
30588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30590 if (!SWIG_IsOK(res1)) {
30591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30592 }
30593 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30594 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30595 if (!SWIG_IsOK(res2)) {
30596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30597 }
30598 arg2 = reinterpret_cast< wxWindow * >(argp2);
30599 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30600 if (!SWIG_IsOK(res3)) {
30601 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30602 }
30603 if (!argp3) {
30604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30605 }
30606 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30610 wxPyEndAllowThreads(__tstate);
30611 if (PyErr_Occurred()) SWIG_fail;
30612 }
30613 {
30614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30615 }
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30623 PyObject *resultobj = 0;
30624 wxPyApp *arg1 = (wxPyApp *) 0 ;
30625 bool result;
30626 void *argp1 = 0 ;
30627 int res1 = 0 ;
30628 PyObject *swig_obj[1] ;
30629
30630 if (!args) SWIG_fail;
30631 swig_obj[0] = args;
30632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30633 if (!SWIG_IsOK(res1)) {
30634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30635 }
30636 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 result = (bool)((wxPyApp const *)arg1)->IsActive();
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 {
30644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30645 }
30646 return resultobj;
30647 fail:
30648 return NULL;
30649 }
30650
30651
30652 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30653 PyObject *resultobj = 0;
30654 wxPyApp *arg1 = (wxPyApp *) 0 ;
30655 wxWindow *arg2 = (wxWindow *) 0 ;
30656 void *argp1 = 0 ;
30657 int res1 = 0 ;
30658 void *argp2 = 0 ;
30659 int res2 = 0 ;
30660 PyObject * obj0 = 0 ;
30661 PyObject * obj1 = 0 ;
30662 char * kwnames[] = {
30663 (char *) "self",(char *) "win", NULL
30664 };
30665
30666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30670 }
30671 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30673 if (!SWIG_IsOK(res2)) {
30674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30675 }
30676 arg2 = reinterpret_cast< wxWindow * >(argp2);
30677 {
30678 PyThreadState* __tstate = wxPyBeginAllowThreads();
30679 (arg1)->SetTopWindow(arg2);
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 resultobj = SWIG_Py_Void();
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30691 PyObject *resultobj = 0;
30692 wxPyApp *arg1 = (wxPyApp *) 0 ;
30693 wxWindow *result = 0 ;
30694 void *argp1 = 0 ;
30695 int res1 = 0 ;
30696 PyObject *swig_obj[1] ;
30697
30698 if (!args) SWIG_fail;
30699 swig_obj[0] = args;
30700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30701 if (!SWIG_IsOK(res1)) {
30702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30703 }
30704 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 {
30712 resultobj = wxPyMake_wxObject(result, (bool)0);
30713 }
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj = 0;
30722 wxPyApp *arg1 = (wxPyApp *) 0 ;
30723 bool arg2 ;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 bool val2 ;
30727 int ecode2 = 0 ;
30728 PyObject * obj0 = 0 ;
30729 PyObject * obj1 = 0 ;
30730 char * kwnames[] = {
30731 (char *) "self",(char *) "flag", NULL
30732 };
30733
30734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30736 if (!SWIG_IsOK(res1)) {
30737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30738 }
30739 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30740 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30741 if (!SWIG_IsOK(ecode2)) {
30742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30743 }
30744 arg2 = static_cast< bool >(val2);
30745 {
30746 PyThreadState* __tstate = wxPyBeginAllowThreads();
30747 (arg1)->SetExitOnFrameDelete(arg2);
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 resultobj = SWIG_Py_Void();
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30759 PyObject *resultobj = 0;
30760 wxPyApp *arg1 = (wxPyApp *) 0 ;
30761 bool result;
30762 void *argp1 = 0 ;
30763 int res1 = 0 ;
30764 PyObject *swig_obj[1] ;
30765
30766 if (!args) SWIG_fail;
30767 swig_obj[0] = args;
30768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30769 if (!SWIG_IsOK(res1)) {
30770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30771 }
30772 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30776 wxPyEndAllowThreads(__tstate);
30777 if (PyErr_Occurred()) SWIG_fail;
30778 }
30779 {
30780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30781 }
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 wxPyApp *arg1 = (wxPyApp *) 0 ;
30791 bool arg2 ;
30792 bool arg3 = (bool) false ;
30793 void *argp1 = 0 ;
30794 int res1 = 0 ;
30795 bool val2 ;
30796 int ecode2 = 0 ;
30797 bool val3 ;
30798 int ecode3 = 0 ;
30799 PyObject * obj0 = 0 ;
30800 PyObject * obj1 = 0 ;
30801 PyObject * obj2 = 0 ;
30802 char * kwnames[] = {
30803 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30804 };
30805
30806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30808 if (!SWIG_IsOK(res1)) {
30809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30810 }
30811 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30813 if (!SWIG_IsOK(ecode2)) {
30814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30815 }
30816 arg2 = static_cast< bool >(val2);
30817 if (obj2) {
30818 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30819 if (!SWIG_IsOK(ecode3)) {
30820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30821 }
30822 arg3 = static_cast< bool >(val3);
30823 }
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 (arg1)->SetUseBestVisual(arg2,arg3);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_Py_Void();
30831 return resultobj;
30832 fail:
30833 return NULL;
30834 }
30835
30836
30837 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30838 PyObject *resultobj = 0;
30839 wxPyApp *arg1 = (wxPyApp *) 0 ;
30840 bool result;
30841 void *argp1 = 0 ;
30842 int res1 = 0 ;
30843 PyObject *swig_obj[1] ;
30844
30845 if (!args) SWIG_fail;
30846 swig_obj[0] = args;
30847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30848 if (!SWIG_IsOK(res1)) {
30849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30850 }
30851 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30852 {
30853 PyThreadState* __tstate = wxPyBeginAllowThreads();
30854 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 {
30859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj = 0;
30869 wxPyApp *arg1 = (wxPyApp *) 0 ;
30870 int arg2 ;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 int val2 ;
30874 int ecode2 = 0 ;
30875 PyObject * obj0 = 0 ;
30876 PyObject * obj1 = 0 ;
30877 char * kwnames[] = {
30878 (char *) "self",(char *) "mode", NULL
30879 };
30880
30881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30883 if (!SWIG_IsOK(res1)) {
30884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30885 }
30886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30887 ecode2 = SWIG_AsVal_int(obj1, &val2);
30888 if (!SWIG_IsOK(ecode2)) {
30889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30890 }
30891 arg2 = static_cast< int >(val2);
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 (arg1)->SetPrintMode(arg2);
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = SWIG_Py_Void();
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30906 PyObject *resultobj = 0;
30907 wxPyApp *arg1 = (wxPyApp *) 0 ;
30908 int result;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 PyObject *swig_obj[1] ;
30912
30913 if (!args) SWIG_fail;
30914 swig_obj[0] = args;
30915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30916 if (!SWIG_IsOK(res1)) {
30917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30918 }
30919 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 resultobj = SWIG_From_int(static_cast< int >(result));
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30934 PyObject *resultobj = 0;
30935 wxPyApp *arg1 = (wxPyApp *) 0 ;
30936 int arg2 ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 int val2 ;
30940 int ecode2 = 0 ;
30941 PyObject * obj0 = 0 ;
30942 PyObject * obj1 = 0 ;
30943 char * kwnames[] = {
30944 (char *) "self",(char *) "mode", NULL
30945 };
30946
30947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30949 if (!SWIG_IsOK(res1)) {
30950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30951 }
30952 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30953 ecode2 = SWIG_AsVal_int(obj1, &val2);
30954 if (!SWIG_IsOK(ecode2)) {
30955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30956 }
30957 arg2 = static_cast< int >(val2);
30958 {
30959 PyThreadState* __tstate = wxPyBeginAllowThreads();
30960 (arg1)->SetAssertMode(arg2);
30961 wxPyEndAllowThreads(__tstate);
30962 if (PyErr_Occurred()) SWIG_fail;
30963 }
30964 resultobj = SWIG_Py_Void();
30965 return resultobj;
30966 fail:
30967 return NULL;
30968 }
30969
30970
30971 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30972 PyObject *resultobj = 0;
30973 wxPyApp *arg1 = (wxPyApp *) 0 ;
30974 int result;
30975 void *argp1 = 0 ;
30976 int res1 = 0 ;
30977 PyObject *swig_obj[1] ;
30978
30979 if (!args) SWIG_fail;
30980 swig_obj[0] = args;
30981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30982 if (!SWIG_IsOK(res1)) {
30983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30984 }
30985 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 result = (int)(arg1)->GetAssertMode();
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 resultobj = SWIG_From_int(static_cast< int >(result));
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31000 PyObject *resultobj = 0;
31001 bool result;
31002
31003 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 {
31011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31012 }
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31020 PyObject *resultobj = 0;
31021 long result;
31022
31023 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31024 {
31025 PyThreadState* __tstate = wxPyBeginAllowThreads();
31026 result = (long)wxPyApp::GetMacAboutMenuItemId();
31027 wxPyEndAllowThreads(__tstate);
31028 if (PyErr_Occurred()) SWIG_fail;
31029 }
31030 resultobj = SWIG_From_long(static_cast< long >(result));
31031 return resultobj;
31032 fail:
31033 return NULL;
31034 }
31035
31036
31037 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31038 PyObject *resultobj = 0;
31039 long result;
31040
31041 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31045 wxPyEndAllowThreads(__tstate);
31046 if (PyErr_Occurred()) SWIG_fail;
31047 }
31048 resultobj = SWIG_From_long(static_cast< long >(result));
31049 return resultobj;
31050 fail:
31051 return NULL;
31052 }
31053
31054
31055 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31056 PyObject *resultobj = 0;
31057 long result;
31058
31059 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31060 {
31061 PyThreadState* __tstate = wxPyBeginAllowThreads();
31062 result = (long)wxPyApp::GetMacExitMenuItemId();
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 resultobj = SWIG_From_long(static_cast< long >(result));
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074 PyObject *resultobj = 0;
31075 wxString result;
31076
31077 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = wxPyApp::GetMacHelpMenuTitleName();
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 {
31085 #if wxUSE_UNICODE
31086 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31087 #else
31088 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31089 #endif
31090 }
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj = 0;
31099 bool arg1 ;
31100 bool val1 ;
31101 int ecode1 = 0 ;
31102 PyObject * obj0 = 0 ;
31103 char * kwnames[] = {
31104 (char *) "val", NULL
31105 };
31106
31107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31108 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31109 if (!SWIG_IsOK(ecode1)) {
31110 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31111 }
31112 arg1 = static_cast< bool >(val1);
31113 {
31114 PyThreadState* __tstate = wxPyBeginAllowThreads();
31115 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 resultobj = SWIG_Py_Void();
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj = 0;
31128 long arg1 ;
31129 long val1 ;
31130 int ecode1 = 0 ;
31131 PyObject * obj0 = 0 ;
31132 char * kwnames[] = {
31133 (char *) "val", NULL
31134 };
31135
31136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31137 ecode1 = SWIG_AsVal_long(obj0, &val1);
31138 if (!SWIG_IsOK(ecode1)) {
31139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31140 }
31141 arg1 = static_cast< long >(val1);
31142 {
31143 PyThreadState* __tstate = wxPyBeginAllowThreads();
31144 wxPyApp::SetMacAboutMenuItemId(arg1);
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 resultobj = SWIG_Py_Void();
31149 return resultobj;
31150 fail:
31151 return NULL;
31152 }
31153
31154
31155 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31156 PyObject *resultobj = 0;
31157 long arg1 ;
31158 long val1 ;
31159 int ecode1 = 0 ;
31160 PyObject * obj0 = 0 ;
31161 char * kwnames[] = {
31162 (char *) "val", NULL
31163 };
31164
31165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31166 ecode1 = SWIG_AsVal_long(obj0, &val1);
31167 if (!SWIG_IsOK(ecode1)) {
31168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31169 }
31170 arg1 = static_cast< long >(val1);
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 resultobj = SWIG_Py_Void();
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj = 0;
31186 long arg1 ;
31187 long val1 ;
31188 int ecode1 = 0 ;
31189 PyObject * obj0 = 0 ;
31190 char * kwnames[] = {
31191 (char *) "val", NULL
31192 };
31193
31194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31195 ecode1 = SWIG_AsVal_long(obj0, &val1);
31196 if (!SWIG_IsOK(ecode1)) {
31197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31198 }
31199 arg1 = static_cast< long >(val1);
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 wxPyApp::SetMacExitMenuItemId(arg1);
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_Py_Void();
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj = 0;
31215 wxString *arg1 = 0 ;
31216 bool temp1 = false ;
31217 PyObject * obj0 = 0 ;
31218 char * kwnames[] = {
31219 (char *) "val", NULL
31220 };
31221
31222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31223 {
31224 arg1 = wxString_in_helper(obj0);
31225 if (arg1 == NULL) SWIG_fail;
31226 temp1 = true;
31227 }
31228 {
31229 PyThreadState* __tstate = wxPyBeginAllowThreads();
31230 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31231 wxPyEndAllowThreads(__tstate);
31232 if (PyErr_Occurred()) SWIG_fail;
31233 }
31234 resultobj = SWIG_Py_Void();
31235 {
31236 if (temp1)
31237 delete arg1;
31238 }
31239 return resultobj;
31240 fail:
31241 {
31242 if (temp1)
31243 delete arg1;
31244 }
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 wxPyApp *arg1 = (wxPyApp *) 0 ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 PyObject *swig_obj[1] ;
31255
31256 if (!args) SWIG_fail;
31257 swig_obj[0] = args;
31258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31259 if (!SWIG_IsOK(res1)) {
31260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31261 }
31262 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 (arg1)->_BootstrapApp();
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 resultobj = SWIG_Py_Void();
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31277 PyObject *resultobj = 0;
31278 int result;
31279
31280 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31281 {
31282 PyThreadState* __tstate = wxPyBeginAllowThreads();
31283 result = (int)wxPyApp::GetComCtl32Version();
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 resultobj = SWIG_From_int(static_cast< int >(result));
31288 return resultobj;
31289 fail:
31290 return NULL;
31291 }
31292
31293
31294 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31295 PyObject *resultobj = 0;
31296 bool result;
31297
31298 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31299 {
31300 PyThreadState* __tstate = wxPyBeginAllowThreads();
31301 result = (bool)wxPyApp_IsDisplayAvailable();
31302 wxPyEndAllowThreads(__tstate);
31303 if (PyErr_Occurred()) SWIG_fail;
31304 }
31305 {
31306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31307 }
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31315 PyObject *obj;
31316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31317 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31318 return SWIG_Py_Void();
31319 }
31320
31321 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31322 return SWIG_Python_InitShadowInstance(args);
31323 }
31324
31325 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31326 PyObject *resultobj = 0;
31327
31328 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31329 {
31330 PyThreadState* __tstate = wxPyBeginAllowThreads();
31331 wxExit();
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 resultobj = SWIG_Py_Void();
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31343 PyObject *resultobj = 0;
31344 bool result;
31345
31346 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31347 {
31348 PyThreadState* __tstate = wxPyBeginAllowThreads();
31349 result = (bool)wxYield();
31350 wxPyEndAllowThreads(__tstate);
31351 if (PyErr_Occurred()) SWIG_fail;
31352 }
31353 {
31354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31355 }
31356 return resultobj;
31357 fail:
31358 return NULL;
31359 }
31360
31361
31362 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31363 PyObject *resultobj = 0;
31364 bool result;
31365
31366 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31367 {
31368 PyThreadState* __tstate = wxPyBeginAllowThreads();
31369 result = (bool)wxYieldIfNeeded();
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 {
31374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31375 }
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj = 0;
31384 wxWindow *arg1 = (wxWindow *) NULL ;
31385 bool arg2 = (bool) false ;
31386 bool result;
31387 void *argp1 = 0 ;
31388 int res1 = 0 ;
31389 bool val2 ;
31390 int ecode2 = 0 ;
31391 PyObject * obj0 = 0 ;
31392 PyObject * obj1 = 0 ;
31393 char * kwnames[] = {
31394 (char *) "win",(char *) "onlyIfNeeded", NULL
31395 };
31396
31397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31398 if (obj0) {
31399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31400 if (!SWIG_IsOK(res1)) {
31401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31402 }
31403 arg1 = reinterpret_cast< wxWindow * >(argp1);
31404 }
31405 if (obj1) {
31406 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31407 if (!SWIG_IsOK(ecode2)) {
31408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31409 }
31410 arg2 = static_cast< bool >(val2);
31411 }
31412 {
31413 PyThreadState* __tstate = wxPyBeginAllowThreads();
31414 result = (bool)wxSafeYield(arg1,arg2);
31415 wxPyEndAllowThreads(__tstate);
31416 if (PyErr_Occurred()) SWIG_fail;
31417 }
31418 {
31419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31420 }
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31428 PyObject *resultobj = 0;
31429
31430 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 wxWakeUpIdle();
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_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31445 PyObject *resultobj = 0;
31446 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31447 wxEvent *arg2 = 0 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 void *argp2 = 0 ;
31451 int res2 = 0 ;
31452 PyObject * obj0 = 0 ;
31453 PyObject * obj1 = 0 ;
31454 char * kwnames[] = {
31455 (char *) "dest",(char *) "event", NULL
31456 };
31457
31458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31460 if (!SWIG_IsOK(res1)) {
31461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31462 }
31463 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31465 if (!SWIG_IsOK(res2)) {
31466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31467 }
31468 if (!argp2) {
31469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31470 }
31471 arg2 = reinterpret_cast< wxEvent * >(argp2);
31472 {
31473 PyThreadState* __tstate = wxPyBeginAllowThreads();
31474 wxPostEvent(arg1,*arg2);
31475 wxPyEndAllowThreads(__tstate);
31476 if (PyErr_Occurred()) SWIG_fail;
31477 }
31478 resultobj = SWIG_Py_Void();
31479 return resultobj;
31480 fail:
31481 return NULL;
31482 }
31483
31484
31485 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31486 PyObject *resultobj = 0;
31487
31488 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31489 {
31490 PyThreadState* __tstate = wxPyBeginAllowThreads();
31491 wxApp_CleanUp();
31492 wxPyEndAllowThreads(__tstate);
31493 if (PyErr_Occurred()) SWIG_fail;
31494 }
31495 resultobj = SWIG_Py_Void();
31496 return resultobj;
31497 fail:
31498 return NULL;
31499 }
31500
31501
31502 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31503 PyObject *resultobj = 0;
31504 wxPyApp *result = 0 ;
31505
31506 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31507 {
31508 PyThreadState* __tstate = wxPyBeginAllowThreads();
31509 result = (wxPyApp *)wxPyGetApp();
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 {
31514 resultobj = wxPyMake_wxObject(result, 0);
31515 }
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31523 PyObject *resultobj = 0;
31524 char *arg1 = (char *) 0 ;
31525 int res1 ;
31526 char *buf1 = 0 ;
31527 int alloc1 = 0 ;
31528 PyObject * obj0 = 0 ;
31529 char * kwnames[] = {
31530 (char *) "encoding", NULL
31531 };
31532
31533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31534 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31535 if (!SWIG_IsOK(res1)) {
31536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31537 }
31538 arg1 = buf1;
31539 {
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 wxSetDefaultPyEncoding((char const *)arg1);
31542 wxPyEndAllowThreads(__tstate);
31543 if (PyErr_Occurred()) SWIG_fail;
31544 }
31545 resultobj = SWIG_Py_Void();
31546 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31547 return resultobj;
31548 fail:
31549 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 PyObject *resultobj = 0;
31556 char *result = 0 ;
31557
31558 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 result = (char *)wxGetDefaultPyEncoding();
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_FromCharPtr(result);
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31573 PyObject *resultobj = 0;
31574 wxEventLoop *result = 0 ;
31575
31576 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 result = (wxEventLoop *)new wxEventLoop();
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31591 PyObject *resultobj = 0;
31592 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31593 void *argp1 = 0 ;
31594 int res1 = 0 ;
31595 PyObject *swig_obj[1] ;
31596
31597 if (!args) SWIG_fail;
31598 swig_obj[0] = args;
31599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31600 if (!SWIG_IsOK(res1)) {
31601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31602 }
31603 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 delete arg1;
31607
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 resultobj = SWIG_Py_Void();
31612 return resultobj;
31613 fail:
31614 return NULL;
31615 }
31616
31617
31618 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31619 PyObject *resultobj = 0;
31620 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31621 int result;
31622 void *argp1 = 0 ;
31623 int res1 = 0 ;
31624 PyObject *swig_obj[1] ;
31625
31626 if (!args) SWIG_fail;
31627 swig_obj[0] = args;
31628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31629 if (!SWIG_IsOK(res1)) {
31630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31631 }
31632 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 result = (int)(arg1)->Run();
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 resultobj = SWIG_From_int(static_cast< int >(result));
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31647 PyObject *resultobj = 0;
31648 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31649 int arg2 = (int) 0 ;
31650 void *argp1 = 0 ;
31651 int res1 = 0 ;
31652 int val2 ;
31653 int ecode2 = 0 ;
31654 PyObject * obj0 = 0 ;
31655 PyObject * obj1 = 0 ;
31656 char * kwnames[] = {
31657 (char *) "self",(char *) "rc", NULL
31658 };
31659
31660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31662 if (!SWIG_IsOK(res1)) {
31663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31664 }
31665 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31666 if (obj1) {
31667 ecode2 = SWIG_AsVal_int(obj1, &val2);
31668 if (!SWIG_IsOK(ecode2)) {
31669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31670 }
31671 arg2 = static_cast< int >(val2);
31672 }
31673 {
31674 PyThreadState* __tstate = wxPyBeginAllowThreads();
31675 (arg1)->Exit(arg2);
31676 wxPyEndAllowThreads(__tstate);
31677 if (PyErr_Occurred()) SWIG_fail;
31678 }
31679 resultobj = SWIG_Py_Void();
31680 return resultobj;
31681 fail:
31682 return NULL;
31683 }
31684
31685
31686 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31687 PyObject *resultobj = 0;
31688 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31689 bool result;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 PyObject *swig_obj[1] ;
31693
31694 if (!args) SWIG_fail;
31695 swig_obj[0] = args;
31696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31697 if (!SWIG_IsOK(res1)) {
31698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31699 }
31700 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31701 {
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 result = (bool)((wxEventLoop const *)arg1)->Pending();
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 {
31708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31709 }
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31719 bool result;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 PyObject *swig_obj[1] ;
31723
31724 if (!args) SWIG_fail;
31725 swig_obj[0] = args;
31726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31727 if (!SWIG_IsOK(res1)) {
31728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31729 }
31730 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = (bool)(arg1)->Dispatch();
31734 wxPyEndAllowThreads(__tstate);
31735 if (PyErr_Occurred()) SWIG_fail;
31736 }
31737 {
31738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31739 }
31740 return resultobj;
31741 fail:
31742 return NULL;
31743 }
31744
31745
31746 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31747 PyObject *resultobj = 0;
31748 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31749 bool result;
31750 void *argp1 = 0 ;
31751 int res1 = 0 ;
31752 PyObject *swig_obj[1] ;
31753
31754 if (!args) SWIG_fail;
31755 swig_obj[0] = args;
31756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31757 if (!SWIG_IsOK(res1)) {
31758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31759 }
31760 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31761 {
31762 PyThreadState* __tstate = wxPyBeginAllowThreads();
31763 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31764 wxPyEndAllowThreads(__tstate);
31765 if (PyErr_Occurred()) SWIG_fail;
31766 }
31767 {
31768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31769 }
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31777 PyObject *resultobj = 0;
31778 wxEventLoop *result = 0 ;
31779
31780 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31781 {
31782 PyThreadState* __tstate = wxPyBeginAllowThreads();
31783 result = (wxEventLoop *)wxEventLoop::GetActive();
31784 wxPyEndAllowThreads(__tstate);
31785 if (PyErr_Occurred()) SWIG_fail;
31786 }
31787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31788 return resultobj;
31789 fail:
31790 return NULL;
31791 }
31792
31793
31794 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31795 PyObject *resultobj = 0;
31796 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31797 void *argp1 = 0 ;
31798 int res1 = 0 ;
31799 PyObject * obj0 = 0 ;
31800 char * kwnames[] = {
31801 (char *) "loop", NULL
31802 };
31803
31804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31808 }
31809 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 wxEventLoop::SetActive(arg1);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_Py_Void();
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *obj;
31825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31826 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31827 return SWIG_Py_Void();
31828 }
31829
31830 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 return SWIG_Python_InitShadowInstance(args);
31832 }
31833
31834 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31835 PyObject *resultobj = 0;
31836 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31837 wxEventLoopActivator *result = 0 ;
31838 void *argp1 = 0 ;
31839 int res1 = 0 ;
31840 PyObject * obj0 = 0 ;
31841 char * kwnames[] = {
31842 (char *) "evtLoop", NULL
31843 };
31844
31845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31847 if (!SWIG_IsOK(res1)) {
31848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31849 }
31850 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31854 wxPyEndAllowThreads(__tstate);
31855 if (PyErr_Occurred()) SWIG_fail;
31856 }
31857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31865 PyObject *resultobj = 0;
31866 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 PyObject *swig_obj[1] ;
31870
31871 if (!args) SWIG_fail;
31872 swig_obj[0] = args;
31873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31874 if (!SWIG_IsOK(res1)) {
31875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31876 }
31877 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31878 {
31879 PyThreadState* __tstate = wxPyBeginAllowThreads();
31880 delete arg1;
31881
31882 wxPyEndAllowThreads(__tstate);
31883 if (PyErr_Occurred()) SWIG_fail;
31884 }
31885 resultobj = SWIG_Py_Void();
31886 return resultobj;
31887 fail:
31888 return NULL;
31889 }
31890
31891
31892 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31893 PyObject *obj;
31894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31895 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31896 return SWIG_Py_Void();
31897 }
31898
31899 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31900 return SWIG_Python_InitShadowInstance(args);
31901 }
31902
31903 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31904 PyObject *resultobj = 0;
31905 int arg1 = (int) 0 ;
31906 int arg2 = (int) 0 ;
31907 int arg3 = (int) 0 ;
31908 wxAcceleratorEntry *result = 0 ;
31909 int val1 ;
31910 int ecode1 = 0 ;
31911 int val2 ;
31912 int ecode2 = 0 ;
31913 int val3 ;
31914 int ecode3 = 0 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 PyObject * obj2 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31923 if (obj0) {
31924 ecode1 = SWIG_AsVal_int(obj0, &val1);
31925 if (!SWIG_IsOK(ecode1)) {
31926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31927 }
31928 arg1 = static_cast< int >(val1);
31929 }
31930 if (obj1) {
31931 ecode2 = SWIG_AsVal_int(obj1, &val2);
31932 if (!SWIG_IsOK(ecode2)) {
31933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31934 }
31935 arg2 = static_cast< int >(val2);
31936 }
31937 if (obj2) {
31938 ecode3 = SWIG_AsVal_int(obj2, &val3);
31939 if (!SWIG_IsOK(ecode3)) {
31940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31941 }
31942 arg3 = static_cast< int >(val3);
31943 }
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31947 wxPyEndAllowThreads(__tstate);
31948 if (PyErr_Occurred()) SWIG_fail;
31949 }
31950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31951 return resultobj;
31952 fail:
31953 return NULL;
31954 }
31955
31956
31957 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31958 PyObject *resultobj = 0;
31959 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31960 void *argp1 = 0 ;
31961 int res1 = 0 ;
31962 PyObject *swig_obj[1] ;
31963
31964 if (!args) SWIG_fail;
31965 swig_obj[0] = args;
31966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31967 if (!SWIG_IsOK(res1)) {
31968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31969 }
31970 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31971 {
31972 PyThreadState* __tstate = wxPyBeginAllowThreads();
31973 delete arg1;
31974
31975 wxPyEndAllowThreads(__tstate);
31976 if (PyErr_Occurred()) SWIG_fail;
31977 }
31978 resultobj = SWIG_Py_Void();
31979 return resultobj;
31980 fail:
31981 return NULL;
31982 }
31983
31984
31985 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31986 PyObject *resultobj = 0;
31987 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31988 int arg2 ;
31989 int arg3 ;
31990 int arg4 ;
31991 void *argp1 = 0 ;
31992 int res1 = 0 ;
31993 int val2 ;
31994 int ecode2 = 0 ;
31995 int val3 ;
31996 int ecode3 = 0 ;
31997 int val4 ;
31998 int ecode4 = 0 ;
31999 PyObject * obj0 = 0 ;
32000 PyObject * obj1 = 0 ;
32001 PyObject * obj2 = 0 ;
32002 PyObject * obj3 = 0 ;
32003 char * kwnames[] = {
32004 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32005 };
32006
32007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32009 if (!SWIG_IsOK(res1)) {
32010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32011 }
32012 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32013 ecode2 = SWIG_AsVal_int(obj1, &val2);
32014 if (!SWIG_IsOK(ecode2)) {
32015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32016 }
32017 arg2 = static_cast< int >(val2);
32018 ecode3 = SWIG_AsVal_int(obj2, &val3);
32019 if (!SWIG_IsOK(ecode3)) {
32020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32021 }
32022 arg3 = static_cast< int >(val3);
32023 ecode4 = SWIG_AsVal_int(obj3, &val4);
32024 if (!SWIG_IsOK(ecode4)) {
32025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32026 }
32027 arg4 = static_cast< int >(val4);
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 (arg1)->Set(arg2,arg3,arg4);
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = SWIG_Py_Void();
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32042 PyObject *resultobj = 0;
32043 wxString *arg1 = 0 ;
32044 wxAcceleratorEntry *result = 0 ;
32045 bool temp1 = false ;
32046 PyObject * obj0 = 0 ;
32047 char * kwnames[] = {
32048 (char *) "str", NULL
32049 };
32050
32051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32052 {
32053 arg1 = wxString_in_helper(obj0);
32054 if (arg1 == NULL) SWIG_fail;
32055 temp1 = true;
32056 }
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32060 wxPyEndAllowThreads(__tstate);
32061 if (PyErr_Occurred()) SWIG_fail;
32062 }
32063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32064 {
32065 if (temp1)
32066 delete arg1;
32067 }
32068 return resultobj;
32069 fail:
32070 {
32071 if (temp1)
32072 delete arg1;
32073 }
32074 return NULL;
32075 }
32076
32077
32078 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32079 PyObject *resultobj = 0;
32080 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32081 int result;
32082 void *argp1 = 0 ;
32083 int res1 = 0 ;
32084 PyObject *swig_obj[1] ;
32085
32086 if (!args) SWIG_fail;
32087 swig_obj[0] = args;
32088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32089 if (!SWIG_IsOK(res1)) {
32090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32091 }
32092 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32093 {
32094 PyThreadState* __tstate = wxPyBeginAllowThreads();
32095 result = (int)(arg1)->GetFlags();
32096 wxPyEndAllowThreads(__tstate);
32097 if (PyErr_Occurred()) SWIG_fail;
32098 }
32099 resultobj = SWIG_From_int(static_cast< int >(result));
32100 return resultobj;
32101 fail:
32102 return NULL;
32103 }
32104
32105
32106 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32107 PyObject *resultobj = 0;
32108 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32109 int result;
32110 void *argp1 = 0 ;
32111 int res1 = 0 ;
32112 PyObject *swig_obj[1] ;
32113
32114 if (!args) SWIG_fail;
32115 swig_obj[0] = args;
32116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32117 if (!SWIG_IsOK(res1)) {
32118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32119 }
32120 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32121 {
32122 PyThreadState* __tstate = wxPyBeginAllowThreads();
32123 result = (int)(arg1)->GetKeyCode();
32124 wxPyEndAllowThreads(__tstate);
32125 if (PyErr_Occurred()) SWIG_fail;
32126 }
32127 resultobj = SWIG_From_int(static_cast< int >(result));
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32135 PyObject *resultobj = 0;
32136 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32137 int result;
32138 void *argp1 = 0 ;
32139 int res1 = 0 ;
32140 PyObject *swig_obj[1] ;
32141
32142 if (!args) SWIG_fail;
32143 swig_obj[0] = args;
32144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32145 if (!SWIG_IsOK(res1)) {
32146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32147 }
32148 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32149 {
32150 PyThreadState* __tstate = wxPyBeginAllowThreads();
32151 result = (int)(arg1)->GetCommand();
32152 wxPyEndAllowThreads(__tstate);
32153 if (PyErr_Occurred()) SWIG_fail;
32154 }
32155 resultobj = SWIG_From_int(static_cast< int >(result));
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32163 PyObject *resultobj = 0;
32164 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32165 bool result;
32166 void *argp1 = 0 ;
32167 int res1 = 0 ;
32168 PyObject *swig_obj[1] ;
32169
32170 if (!args) SWIG_fail;
32171 swig_obj[0] = args;
32172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32173 if (!SWIG_IsOK(res1)) {
32174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32175 }
32176 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 {
32184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32185 }
32186 return resultobj;
32187 fail:
32188 return NULL;
32189 }
32190
32191
32192 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32193 PyObject *resultobj = 0;
32194 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32195 wxString result;
32196 void *argp1 = 0 ;
32197 int res1 = 0 ;
32198 PyObject *swig_obj[1] ;
32199
32200 if (!args) SWIG_fail;
32201 swig_obj[0] = args;
32202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32203 if (!SWIG_IsOK(res1)) {
32204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32205 }
32206 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32207 {
32208 PyThreadState* __tstate = wxPyBeginAllowThreads();
32209 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32210 wxPyEndAllowThreads(__tstate);
32211 if (PyErr_Occurred()) SWIG_fail;
32212 }
32213 {
32214 #if wxUSE_UNICODE
32215 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32216 #else
32217 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32218 #endif
32219 }
32220 return resultobj;
32221 fail:
32222 return NULL;
32223 }
32224
32225
32226 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32227 PyObject *resultobj = 0;
32228 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32229 wxString *arg2 = 0 ;
32230 bool result;
32231 void *argp1 = 0 ;
32232 int res1 = 0 ;
32233 bool temp2 = false ;
32234 PyObject * obj0 = 0 ;
32235 PyObject * obj1 = 0 ;
32236 char * kwnames[] = {
32237 (char *) "self",(char *) "str", NULL
32238 };
32239
32240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32244 }
32245 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32246 {
32247 arg2 = wxString_in_helper(obj1);
32248 if (arg2 == NULL) SWIG_fail;
32249 temp2 = true;
32250 }
32251 {
32252 PyThreadState* __tstate = wxPyBeginAllowThreads();
32253 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32254 wxPyEndAllowThreads(__tstate);
32255 if (PyErr_Occurred()) SWIG_fail;
32256 }
32257 {
32258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32259 }
32260 {
32261 if (temp2)
32262 delete arg2;
32263 }
32264 return resultobj;
32265 fail:
32266 {
32267 if (temp2)
32268 delete arg2;
32269 }
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32275 PyObject *obj;
32276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32277 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32278 return SWIG_Py_Void();
32279 }
32280
32281 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32282 return SWIG_Python_InitShadowInstance(args);
32283 }
32284
32285 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32286 PyObject *resultobj = 0;
32287 int arg1 ;
32288 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32289 wxAcceleratorTable *result = 0 ;
32290 PyObject * obj0 = 0 ;
32291 char * kwnames[] = {
32292 (char *) "n", NULL
32293 };
32294
32295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32296 {
32297 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32298 if (arg2) arg1 = PyList_Size(obj0);
32299 else arg1 = 0;
32300 }
32301 {
32302 PyThreadState* __tstate = wxPyBeginAllowThreads();
32303 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32304 wxPyEndAllowThreads(__tstate);
32305 if (PyErr_Occurred()) SWIG_fail;
32306 }
32307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32308 return resultobj;
32309 fail:
32310 return NULL;
32311 }
32312
32313
32314 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32315 PyObject *resultobj = 0;
32316 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32317 void *argp1 = 0 ;
32318 int res1 = 0 ;
32319 PyObject *swig_obj[1] ;
32320
32321 if (!args) SWIG_fail;
32322 swig_obj[0] = args;
32323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32324 if (!SWIG_IsOK(res1)) {
32325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32326 }
32327 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 delete arg1;
32331
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 resultobj = SWIG_Py_Void();
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32343 PyObject *resultobj = 0;
32344 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32345 bool result;
32346 void *argp1 = 0 ;
32347 int res1 = 0 ;
32348 PyObject *swig_obj[1] ;
32349
32350 if (!args) SWIG_fail;
32351 swig_obj[0] = args;
32352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32353 if (!SWIG_IsOK(res1)) {
32354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32355 }
32356 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32357 {
32358 PyThreadState* __tstate = wxPyBeginAllowThreads();
32359 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32360 wxPyEndAllowThreads(__tstate);
32361 if (PyErr_Occurred()) SWIG_fail;
32362 }
32363 {
32364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32365 }
32366 return resultobj;
32367 fail:
32368 return NULL;
32369 }
32370
32371
32372 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32373 PyObject *obj;
32374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32375 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32376 return SWIG_Py_Void();
32377 }
32378
32379 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 return SWIG_Python_InitShadowInstance(args);
32381 }
32382
32383 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32384 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32385 return 1;
32386 }
32387
32388
32389 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32390 PyObject *pyobj = 0;
32391
32392 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32393 return pyobj;
32394 }
32395
32396
32397 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32398 PyObject *resultobj = 0;
32399 wxString *arg1 = 0 ;
32400 wxAcceleratorEntry *result = 0 ;
32401 bool temp1 = false ;
32402 PyObject * obj0 = 0 ;
32403 char * kwnames[] = {
32404 (char *) "label", NULL
32405 };
32406
32407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32408 {
32409 arg1 = wxString_in_helper(obj0);
32410 if (arg1 == NULL) SWIG_fail;
32411 temp1 = true;
32412 }
32413 {
32414 PyThreadState* __tstate = wxPyBeginAllowThreads();
32415 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32416 wxPyEndAllowThreads(__tstate);
32417 if (PyErr_Occurred()) SWIG_fail;
32418 }
32419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32420 {
32421 if (temp1)
32422 delete arg1;
32423 }
32424 return resultobj;
32425 fail:
32426 {
32427 if (temp1)
32428 delete arg1;
32429 }
32430 return NULL;
32431 }
32432
32433
32434 SWIGINTERN int PanelNameStr_set(PyObject *) {
32435 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32436 return 1;
32437 }
32438
32439
32440 SWIGINTERN PyObject *PanelNameStr_get(void) {
32441 PyObject *pyobj = 0;
32442
32443 {
32444 #if wxUSE_UNICODE
32445 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32446 #else
32447 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32448 #endif
32449 }
32450 return pyobj;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32455 PyObject *resultobj = 0;
32456 wxVisualAttributes *result = 0 ;
32457
32458 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32459 {
32460 PyThreadState* __tstate = wxPyBeginAllowThreads();
32461 result = (wxVisualAttributes *)new_wxVisualAttributes();
32462 wxPyEndAllowThreads(__tstate);
32463 if (PyErr_Occurred()) SWIG_fail;
32464 }
32465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32466 return resultobj;
32467 fail:
32468 return NULL;
32469 }
32470
32471
32472 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32473 PyObject *resultobj = 0;
32474 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32475 void *argp1 = 0 ;
32476 int res1 = 0 ;
32477 PyObject *swig_obj[1] ;
32478
32479 if (!args) SWIG_fail;
32480 swig_obj[0] = args;
32481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32482 if (!SWIG_IsOK(res1)) {
32483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32484 }
32485 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 delete_wxVisualAttributes(arg1);
32489
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 resultobj = SWIG_Py_Void();
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32503 wxFont *arg2 = (wxFont *) 0 ;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 void *argp2 = 0 ;
32507 int res2 = 0 ;
32508 PyObject *swig_obj[2] ;
32509
32510 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32512 if (!SWIG_IsOK(res1)) {
32513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32514 }
32515 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32516 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32517 if (!SWIG_IsOK(res2)) {
32518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32519 }
32520 arg2 = reinterpret_cast< wxFont * >(argp2);
32521 if (arg1) (arg1)->font = *arg2;
32522
32523 resultobj = SWIG_Py_Void();
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32531 PyObject *resultobj = 0;
32532 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32533 wxFont *result = 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32543 }
32544 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32545 result = (wxFont *)& ((arg1)->font);
32546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32547 return resultobj;
32548 fail:
32549 return NULL;
32550 }
32551
32552
32553 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32554 PyObject *resultobj = 0;
32555 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32556 wxColour *arg2 = (wxColour *) 0 ;
32557 void *argp1 = 0 ;
32558 int res1 = 0 ;
32559 void *argp2 = 0 ;
32560 int res2 = 0 ;
32561 PyObject *swig_obj[2] ;
32562
32563 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32565 if (!SWIG_IsOK(res1)) {
32566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32567 }
32568 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32569 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32570 if (!SWIG_IsOK(res2)) {
32571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32572 }
32573 arg2 = reinterpret_cast< wxColour * >(argp2);
32574 if (arg1) (arg1)->colFg = *arg2;
32575
32576 resultobj = SWIG_Py_Void();
32577 return resultobj;
32578 fail:
32579 return NULL;
32580 }
32581
32582
32583 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32584 PyObject *resultobj = 0;
32585 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32586 wxColour *result = 0 ;
32587 void *argp1 = 0 ;
32588 int res1 = 0 ;
32589 PyObject *swig_obj[1] ;
32590
32591 if (!args) SWIG_fail;
32592 swig_obj[0] = args;
32593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32594 if (!SWIG_IsOK(res1)) {
32595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32596 }
32597 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32598 result = (wxColour *)& ((arg1)->colFg);
32599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32607 PyObject *resultobj = 0;
32608 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32609 wxColour *arg2 = (wxColour *) 0 ;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 void *argp2 = 0 ;
32613 int res2 = 0 ;
32614 PyObject *swig_obj[2] ;
32615
32616 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32618 if (!SWIG_IsOK(res1)) {
32619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32620 }
32621 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32623 if (!SWIG_IsOK(res2)) {
32624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32625 }
32626 arg2 = reinterpret_cast< wxColour * >(argp2);
32627 if (arg1) (arg1)->colBg = *arg2;
32628
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 PyObject *resultobj = 0;
32638 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32639 wxColour *result = 0 ;
32640 void *argp1 = 0 ;
32641 int res1 = 0 ;
32642 PyObject *swig_obj[1] ;
32643
32644 if (!args) SWIG_fail;
32645 swig_obj[0] = args;
32646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32647 if (!SWIG_IsOK(res1)) {
32648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32649 }
32650 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32651 result = (wxColour *)& ((arg1)->colBg);
32652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *obj;
32661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32662 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32663 return SWIG_Py_Void();
32664 }
32665
32666 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 return SWIG_Python_InitShadowInstance(args);
32668 }
32669
32670 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32671 PyObject *resultobj = 0;
32672 wxWindow *arg1 = (wxWindow *) 0 ;
32673 int arg2 = (int) (int)-1 ;
32674 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32675 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32676 wxSize const &arg4_defvalue = wxDefaultSize ;
32677 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32678 long arg5 = (long) 0 ;
32679 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32680 wxString *arg6 = (wxString *) &arg6_defvalue ;
32681 wxWindow *result = 0 ;
32682 void *argp1 = 0 ;
32683 int res1 = 0 ;
32684 int val2 ;
32685 int ecode2 = 0 ;
32686 wxPoint temp3 ;
32687 wxSize temp4 ;
32688 long val5 ;
32689 int ecode5 = 0 ;
32690 bool temp6 = false ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 PyObject * obj2 = 0 ;
32694 PyObject * obj3 = 0 ;
32695 PyObject * obj4 = 0 ;
32696 PyObject * obj5 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 if (obj1) {
32708 ecode2 = SWIG_AsVal_int(obj1, &val2);
32709 if (!SWIG_IsOK(ecode2)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32711 }
32712 arg2 = static_cast< int >(val2);
32713 }
32714 if (obj2) {
32715 {
32716 arg3 = &temp3;
32717 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32718 }
32719 }
32720 if (obj3) {
32721 {
32722 arg4 = &temp4;
32723 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32724 }
32725 }
32726 if (obj4) {
32727 ecode5 = SWIG_AsVal_long(obj4, &val5);
32728 if (!SWIG_IsOK(ecode5)) {
32729 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32730 }
32731 arg5 = static_cast< long >(val5);
32732 }
32733 if (obj5) {
32734 {
32735 arg6 = wxString_in_helper(obj5);
32736 if (arg6 == NULL) SWIG_fail;
32737 temp6 = true;
32738 }
32739 }
32740 {
32741 if (!wxPyCheckForApp()) SWIG_fail;
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32748 {
32749 if (temp6)
32750 delete arg6;
32751 }
32752 return resultobj;
32753 fail:
32754 {
32755 if (temp6)
32756 delete arg6;
32757 }
32758 return NULL;
32759 }
32760
32761
32762 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32763 PyObject *resultobj = 0;
32764 wxWindow *result = 0 ;
32765
32766 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32767 {
32768 if (!wxPyCheckForApp()) SWIG_fail;
32769 PyThreadState* __tstate = wxPyBeginAllowThreads();
32770 result = (wxWindow *)new wxWindow();
32771 wxPyEndAllowThreads(__tstate);
32772 if (PyErr_Occurred()) SWIG_fail;
32773 }
32774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32775 return resultobj;
32776 fail:
32777 return NULL;
32778 }
32779
32780
32781 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32782 PyObject *resultobj = 0;
32783 wxWindow *arg1 = (wxWindow *) 0 ;
32784 wxWindow *arg2 = (wxWindow *) 0 ;
32785 int arg3 = (int) (int)-1 ;
32786 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32787 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32788 wxSize const &arg5_defvalue = wxDefaultSize ;
32789 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32790 long arg6 = (long) 0 ;
32791 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32792 wxString *arg7 = (wxString *) &arg7_defvalue ;
32793 bool result;
32794 void *argp1 = 0 ;
32795 int res1 = 0 ;
32796 void *argp2 = 0 ;
32797 int res2 = 0 ;
32798 int val3 ;
32799 int ecode3 = 0 ;
32800 wxPoint temp4 ;
32801 wxSize temp5 ;
32802 long val6 ;
32803 int ecode6 = 0 ;
32804 bool temp7 = false ;
32805 PyObject * obj0 = 0 ;
32806 PyObject * obj1 = 0 ;
32807 PyObject * obj2 = 0 ;
32808 PyObject * obj3 = 0 ;
32809 PyObject * obj4 = 0 ;
32810 PyObject * obj5 = 0 ;
32811 PyObject * obj6 = 0 ;
32812 char * kwnames[] = {
32813 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32814 };
32815
32816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32818 if (!SWIG_IsOK(res1)) {
32819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32820 }
32821 arg1 = reinterpret_cast< wxWindow * >(argp1);
32822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32823 if (!SWIG_IsOK(res2)) {
32824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32825 }
32826 arg2 = reinterpret_cast< wxWindow * >(argp2);
32827 if (obj2) {
32828 ecode3 = SWIG_AsVal_int(obj2, &val3);
32829 if (!SWIG_IsOK(ecode3)) {
32830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32831 }
32832 arg3 = static_cast< int >(val3);
32833 }
32834 if (obj3) {
32835 {
32836 arg4 = &temp4;
32837 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32838 }
32839 }
32840 if (obj4) {
32841 {
32842 arg5 = &temp5;
32843 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32844 }
32845 }
32846 if (obj5) {
32847 ecode6 = SWIG_AsVal_long(obj5, &val6);
32848 if (!SWIG_IsOK(ecode6)) {
32849 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32850 }
32851 arg6 = static_cast< long >(val6);
32852 }
32853 if (obj6) {
32854 {
32855 arg7 = wxString_in_helper(obj6);
32856 if (arg7 == NULL) SWIG_fail;
32857 temp7 = true;
32858 }
32859 }
32860 {
32861 PyThreadState* __tstate = wxPyBeginAllowThreads();
32862 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32863 wxPyEndAllowThreads(__tstate);
32864 if (PyErr_Occurred()) SWIG_fail;
32865 }
32866 {
32867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32868 }
32869 {
32870 if (temp7)
32871 delete arg7;
32872 }
32873 return resultobj;
32874 fail:
32875 {
32876 if (temp7)
32877 delete arg7;
32878 }
32879 return NULL;
32880 }
32881
32882
32883 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32884 PyObject *resultobj = 0;
32885 wxWindow *arg1 = (wxWindow *) 0 ;
32886 bool arg2 = (bool) false ;
32887 bool result;
32888 void *argp1 = 0 ;
32889 int res1 = 0 ;
32890 bool val2 ;
32891 int ecode2 = 0 ;
32892 PyObject * obj0 = 0 ;
32893 PyObject * obj1 = 0 ;
32894 char * kwnames[] = {
32895 (char *) "self",(char *) "force", NULL
32896 };
32897
32898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32900 if (!SWIG_IsOK(res1)) {
32901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32902 }
32903 arg1 = reinterpret_cast< wxWindow * >(argp1);
32904 if (obj1) {
32905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32906 if (!SWIG_IsOK(ecode2)) {
32907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32908 }
32909 arg2 = static_cast< bool >(val2);
32910 }
32911 {
32912 PyThreadState* __tstate = wxPyBeginAllowThreads();
32913 result = (bool)(arg1)->Close(arg2);
32914 wxPyEndAllowThreads(__tstate);
32915 if (PyErr_Occurred()) SWIG_fail;
32916 }
32917 {
32918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32919 }
32920 return resultobj;
32921 fail:
32922 return NULL;
32923 }
32924
32925
32926 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32927 PyObject *resultobj = 0;
32928 wxWindow *arg1 = (wxWindow *) 0 ;
32929 bool result;
32930 void *argp1 = 0 ;
32931 int res1 = 0 ;
32932 PyObject *swig_obj[1] ;
32933
32934 if (!args) SWIG_fail;
32935 swig_obj[0] = args;
32936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32937 if (!SWIG_IsOK(res1)) {
32938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32939 }
32940 arg1 = reinterpret_cast< wxWindow * >(argp1);
32941 {
32942 PyThreadState* __tstate = wxPyBeginAllowThreads();
32943 result = (bool)(arg1)->Destroy();
32944 wxPyEndAllowThreads(__tstate);
32945 if (PyErr_Occurred()) SWIG_fail;
32946 }
32947 {
32948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32949 }
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32957 PyObject *resultobj = 0;
32958 wxWindow *arg1 = (wxWindow *) 0 ;
32959 bool result;
32960 void *argp1 = 0 ;
32961 int res1 = 0 ;
32962 PyObject *swig_obj[1] ;
32963
32964 if (!args) SWIG_fail;
32965 swig_obj[0] = args;
32966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32969 }
32970 arg1 = reinterpret_cast< wxWindow * >(argp1);
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 result = (bool)(arg1)->DestroyChildren();
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 {
32978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32979 }
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32987 PyObject *resultobj = 0;
32988 wxWindow *arg1 = (wxWindow *) 0 ;
32989 bool result;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 PyObject *swig_obj[1] ;
32993
32994 if (!args) SWIG_fail;
32995 swig_obj[0] = args;
32996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32997 if (!SWIG_IsOK(res1)) {
32998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
32999 }
33000 arg1 = reinterpret_cast< wxWindow * >(argp1);
33001 {
33002 PyThreadState* __tstate = wxPyBeginAllowThreads();
33003 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33004 wxPyEndAllowThreads(__tstate);
33005 if (PyErr_Occurred()) SWIG_fail;
33006 }
33007 {
33008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33009 }
33010 return resultobj;
33011 fail:
33012 return NULL;
33013 }
33014
33015
33016 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33017 PyObject *resultobj = 0;
33018 wxWindow *arg1 = (wxWindow *) 0 ;
33019 wxString *arg2 = 0 ;
33020 void *argp1 = 0 ;
33021 int res1 = 0 ;
33022 bool temp2 = false ;
33023 PyObject * obj0 = 0 ;
33024 PyObject * obj1 = 0 ;
33025 char * kwnames[] = {
33026 (char *) "self",(char *) "label", NULL
33027 };
33028
33029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33031 if (!SWIG_IsOK(res1)) {
33032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33033 }
33034 arg1 = reinterpret_cast< wxWindow * >(argp1);
33035 {
33036 arg2 = wxString_in_helper(obj1);
33037 if (arg2 == NULL) SWIG_fail;
33038 temp2 = true;
33039 }
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 (arg1)->SetLabel((wxString const &)*arg2);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_Py_Void();
33047 {
33048 if (temp2)
33049 delete arg2;
33050 }
33051 return resultobj;
33052 fail:
33053 {
33054 if (temp2)
33055 delete arg2;
33056 }
33057 return NULL;
33058 }
33059
33060
33061 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33062 PyObject *resultobj = 0;
33063 wxWindow *arg1 = (wxWindow *) 0 ;
33064 wxString result;
33065 void *argp1 = 0 ;
33066 int res1 = 0 ;
33067 PyObject *swig_obj[1] ;
33068
33069 if (!args) SWIG_fail;
33070 swig_obj[0] = args;
33071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33072 if (!SWIG_IsOK(res1)) {
33073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33074 }
33075 arg1 = reinterpret_cast< wxWindow * >(argp1);
33076 {
33077 PyThreadState* __tstate = wxPyBeginAllowThreads();
33078 result = ((wxWindow const *)arg1)->GetLabel();
33079 wxPyEndAllowThreads(__tstate);
33080 if (PyErr_Occurred()) SWIG_fail;
33081 }
33082 {
33083 #if wxUSE_UNICODE
33084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33085 #else
33086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33087 #endif
33088 }
33089 return resultobj;
33090 fail:
33091 return NULL;
33092 }
33093
33094
33095 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33096 PyObject *resultobj = 0;
33097 wxWindow *arg1 = (wxWindow *) 0 ;
33098 wxString *arg2 = 0 ;
33099 void *argp1 = 0 ;
33100 int res1 = 0 ;
33101 bool temp2 = false ;
33102 PyObject * obj0 = 0 ;
33103 PyObject * obj1 = 0 ;
33104 char * kwnames[] = {
33105 (char *) "self",(char *) "name", NULL
33106 };
33107
33108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33110 if (!SWIG_IsOK(res1)) {
33111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33112 }
33113 arg1 = reinterpret_cast< wxWindow * >(argp1);
33114 {
33115 arg2 = wxString_in_helper(obj1);
33116 if (arg2 == NULL) SWIG_fail;
33117 temp2 = true;
33118 }
33119 {
33120 PyThreadState* __tstate = wxPyBeginAllowThreads();
33121 (arg1)->SetName((wxString const &)*arg2);
33122 wxPyEndAllowThreads(__tstate);
33123 if (PyErr_Occurred()) SWIG_fail;
33124 }
33125 resultobj = SWIG_Py_Void();
33126 {
33127 if (temp2)
33128 delete arg2;
33129 }
33130 return resultobj;
33131 fail:
33132 {
33133 if (temp2)
33134 delete arg2;
33135 }
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 wxString result;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = ((wxWindow const *)arg1)->GetName();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 {
33162 #if wxUSE_UNICODE
33163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33164 #else
33165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33166 #endif
33167 }
33168 return resultobj;
33169 fail:
33170 return NULL;
33171 }
33172
33173
33174 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33175 PyObject *resultobj = 0;
33176 wxWindow *arg1 = (wxWindow *) 0 ;
33177 wxWindowVariant arg2 ;
33178 void *argp1 = 0 ;
33179 int res1 = 0 ;
33180 int val2 ;
33181 int ecode2 = 0 ;
33182 PyObject * obj0 = 0 ;
33183 PyObject * obj1 = 0 ;
33184 char * kwnames[] = {
33185 (char *) "self",(char *) "variant", NULL
33186 };
33187
33188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33190 if (!SWIG_IsOK(res1)) {
33191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33192 }
33193 arg1 = reinterpret_cast< wxWindow * >(argp1);
33194 ecode2 = SWIG_AsVal_int(obj1, &val2);
33195 if (!SWIG_IsOK(ecode2)) {
33196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33197 }
33198 arg2 = static_cast< wxWindowVariant >(val2);
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 (arg1)->SetWindowVariant(arg2);
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_Py_Void();
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 wxWindowVariant result;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 PyObject *swig_obj[1] ;
33219
33220 if (!args) SWIG_fail;
33221 swig_obj[0] = args;
33222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33223 if (!SWIG_IsOK(res1)) {
33224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33225 }
33226 arg1 = reinterpret_cast< wxWindow * >(argp1);
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33230 wxPyEndAllowThreads(__tstate);
33231 if (PyErr_Occurred()) SWIG_fail;
33232 }
33233 resultobj = SWIG_From_int(static_cast< int >(result));
33234 return resultobj;
33235 fail:
33236 return NULL;
33237 }
33238
33239
33240 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33241 PyObject *resultobj = 0;
33242 wxWindow *arg1 = (wxWindow *) 0 ;
33243 int arg2 ;
33244 void *argp1 = 0 ;
33245 int res1 = 0 ;
33246 int val2 ;
33247 int ecode2 = 0 ;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 char * kwnames[] = {
33251 (char *) "self",(char *) "winid", NULL
33252 };
33253
33254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33258 }
33259 arg1 = reinterpret_cast< wxWindow * >(argp1);
33260 ecode2 = SWIG_AsVal_int(obj1, &val2);
33261 if (!SWIG_IsOK(ecode2)) {
33262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33263 }
33264 arg2 = static_cast< int >(val2);
33265 {
33266 PyThreadState* __tstate = wxPyBeginAllowThreads();
33267 (arg1)->SetId(arg2);
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 resultobj = SWIG_Py_Void();
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33279 PyObject *resultobj = 0;
33280 wxWindow *arg1 = (wxWindow *) 0 ;
33281 int result;
33282 void *argp1 = 0 ;
33283 int res1 = 0 ;
33284 PyObject *swig_obj[1] ;
33285
33286 if (!args) SWIG_fail;
33287 swig_obj[0] = args;
33288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33291 }
33292 arg1 = reinterpret_cast< wxWindow * >(argp1);
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (int)((wxWindow const *)arg1)->GetId();
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 resultobj = SWIG_From_int(static_cast< int >(result));
33300 return resultobj;
33301 fail:
33302 return NULL;
33303 }
33304
33305
33306 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33307 PyObject *resultobj = 0;
33308 int result;
33309
33310 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 result = (int)wxWindow::NewControlId();
33314 wxPyEndAllowThreads(__tstate);
33315 if (PyErr_Occurred()) SWIG_fail;
33316 }
33317 resultobj = SWIG_From_int(static_cast< int >(result));
33318 return resultobj;
33319 fail:
33320 return NULL;
33321 }
33322
33323
33324 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33325 PyObject *resultobj = 0;
33326 int arg1 ;
33327 int result;
33328 int val1 ;
33329 int ecode1 = 0 ;
33330 PyObject * obj0 = 0 ;
33331 char * kwnames[] = {
33332 (char *) "winid", NULL
33333 };
33334
33335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33336 ecode1 = SWIG_AsVal_int(obj0, &val1);
33337 if (!SWIG_IsOK(ecode1)) {
33338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33339 }
33340 arg1 = static_cast< int >(val1);
33341 {
33342 PyThreadState* __tstate = wxPyBeginAllowThreads();
33343 result = (int)wxWindow::NextControlId(arg1);
33344 wxPyEndAllowThreads(__tstate);
33345 if (PyErr_Occurred()) SWIG_fail;
33346 }
33347 resultobj = SWIG_From_int(static_cast< int >(result));
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33355 PyObject *resultobj = 0;
33356 int arg1 ;
33357 int result;
33358 int val1 ;
33359 int ecode1 = 0 ;
33360 PyObject * obj0 = 0 ;
33361 char * kwnames[] = {
33362 (char *) "winid", NULL
33363 };
33364
33365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33366 ecode1 = SWIG_AsVal_int(obj0, &val1);
33367 if (!SWIG_IsOK(ecode1)) {
33368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33369 }
33370 arg1 = static_cast< int >(val1);
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 result = (int)wxWindow::PrevControlId(arg1);
33374 wxPyEndAllowThreads(__tstate);
33375 if (PyErr_Occurred()) SWIG_fail;
33376 }
33377 resultobj = SWIG_From_int(static_cast< int >(result));
33378 return resultobj;
33379 fail:
33380 return NULL;
33381 }
33382
33383
33384 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33385 PyObject *resultobj = 0;
33386 wxWindow *arg1 = (wxWindow *) 0 ;
33387 wxLayoutDirection result;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 PyObject *swig_obj[1] ;
33391
33392 if (!args) SWIG_fail;
33393 swig_obj[0] = args;
33394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33395 if (!SWIG_IsOK(res1)) {
33396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33397 }
33398 arg1 = reinterpret_cast< wxWindow * >(argp1);
33399 {
33400 PyThreadState* __tstate = wxPyBeginAllowThreads();
33401 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33402 wxPyEndAllowThreads(__tstate);
33403 if (PyErr_Occurred()) SWIG_fail;
33404 }
33405 resultobj = SWIG_From_int(static_cast< int >(result));
33406 return resultobj;
33407 fail:
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33413 PyObject *resultobj = 0;
33414 wxWindow *arg1 = (wxWindow *) 0 ;
33415 wxLayoutDirection arg2 ;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 int val2 ;
33419 int ecode2 = 0 ;
33420 PyObject * obj0 = 0 ;
33421 PyObject * obj1 = 0 ;
33422 char * kwnames[] = {
33423 (char *) "self",(char *) "dir", NULL
33424 };
33425
33426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33428 if (!SWIG_IsOK(res1)) {
33429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33430 }
33431 arg1 = reinterpret_cast< wxWindow * >(argp1);
33432 ecode2 = SWIG_AsVal_int(obj1, &val2);
33433 if (!SWIG_IsOK(ecode2)) {
33434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33435 }
33436 arg2 = static_cast< wxLayoutDirection >(val2);
33437 {
33438 PyThreadState* __tstate = wxPyBeginAllowThreads();
33439 (arg1)->SetLayoutDirection(arg2);
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 resultobj = SWIG_Py_Void();
33444 return resultobj;
33445 fail:
33446 return NULL;
33447 }
33448
33449
33450 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj = 0;
33452 wxWindow *arg1 = (wxWindow *) 0 ;
33453 int arg2 ;
33454 int arg3 ;
33455 int arg4 ;
33456 int result;
33457 void *argp1 = 0 ;
33458 int res1 = 0 ;
33459 int val2 ;
33460 int ecode2 = 0 ;
33461 int val3 ;
33462 int ecode3 = 0 ;
33463 int val4 ;
33464 int ecode4 = 0 ;
33465 PyObject * obj0 = 0 ;
33466 PyObject * obj1 = 0 ;
33467 PyObject * obj2 = 0 ;
33468 PyObject * obj3 = 0 ;
33469 char * kwnames[] = {
33470 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33471 };
33472
33473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33475 if (!SWIG_IsOK(res1)) {
33476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33477 }
33478 arg1 = reinterpret_cast< wxWindow * >(argp1);
33479 ecode2 = SWIG_AsVal_int(obj1, &val2);
33480 if (!SWIG_IsOK(ecode2)) {
33481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33482 }
33483 arg2 = static_cast< int >(val2);
33484 ecode3 = SWIG_AsVal_int(obj2, &val3);
33485 if (!SWIG_IsOK(ecode3)) {
33486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33487 }
33488 arg3 = static_cast< int >(val3);
33489 ecode4 = SWIG_AsVal_int(obj3, &val4);
33490 if (!SWIG_IsOK(ecode4)) {
33491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33492 }
33493 arg4 = static_cast< int >(val4);
33494 {
33495 PyThreadState* __tstate = wxPyBeginAllowThreads();
33496 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33497 wxPyEndAllowThreads(__tstate);
33498 if (PyErr_Occurred()) SWIG_fail;
33499 }
33500 resultobj = SWIG_From_int(static_cast< int >(result));
33501 return resultobj;
33502 fail:
33503 return NULL;
33504 }
33505
33506
33507 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33508 PyObject *resultobj = 0;
33509 wxWindow *arg1 = (wxWindow *) 0 ;
33510 wxSize *arg2 = 0 ;
33511 void *argp1 = 0 ;
33512 int res1 = 0 ;
33513 wxSize temp2 ;
33514 PyObject * obj0 = 0 ;
33515 PyObject * obj1 = 0 ;
33516 char * kwnames[] = {
33517 (char *) "self",(char *) "size", NULL
33518 };
33519
33520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33522 if (!SWIG_IsOK(res1)) {
33523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33524 }
33525 arg1 = reinterpret_cast< wxWindow * >(argp1);
33526 {
33527 arg2 = &temp2;
33528 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33529 }
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 (arg1)->SetSize((wxSize const &)*arg2);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 resultobj = SWIG_Py_Void();
33537 return resultobj;
33538 fail:
33539 return NULL;
33540 }
33541
33542
33543 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33544 PyObject *resultobj = 0;
33545 wxWindow *arg1 = (wxWindow *) 0 ;
33546 int arg2 ;
33547 int arg3 ;
33548 int arg4 ;
33549 int arg5 ;
33550 int arg6 = (int) wxSIZE_AUTO ;
33551 void *argp1 = 0 ;
33552 int res1 = 0 ;
33553 int val2 ;
33554 int ecode2 = 0 ;
33555 int val3 ;
33556 int ecode3 = 0 ;
33557 int val4 ;
33558 int ecode4 = 0 ;
33559 int val5 ;
33560 int ecode5 = 0 ;
33561 int val6 ;
33562 int ecode6 = 0 ;
33563 PyObject * obj0 = 0 ;
33564 PyObject * obj1 = 0 ;
33565 PyObject * obj2 = 0 ;
33566 PyObject * obj3 = 0 ;
33567 PyObject * obj4 = 0 ;
33568 PyObject * obj5 = 0 ;
33569 char * kwnames[] = {
33570 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33571 };
33572
33573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33577 }
33578 arg1 = reinterpret_cast< wxWindow * >(argp1);
33579 ecode2 = SWIG_AsVal_int(obj1, &val2);
33580 if (!SWIG_IsOK(ecode2)) {
33581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33582 }
33583 arg2 = static_cast< int >(val2);
33584 ecode3 = SWIG_AsVal_int(obj2, &val3);
33585 if (!SWIG_IsOK(ecode3)) {
33586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33587 }
33588 arg3 = static_cast< int >(val3);
33589 ecode4 = SWIG_AsVal_int(obj3, &val4);
33590 if (!SWIG_IsOK(ecode4)) {
33591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33592 }
33593 arg4 = static_cast< int >(val4);
33594 ecode5 = SWIG_AsVal_int(obj4, &val5);
33595 if (!SWIG_IsOK(ecode5)) {
33596 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33597 }
33598 arg5 = static_cast< int >(val5);
33599 if (obj5) {
33600 ecode6 = SWIG_AsVal_int(obj5, &val6);
33601 if (!SWIG_IsOK(ecode6)) {
33602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33603 }
33604 arg6 = static_cast< int >(val6);
33605 }
33606 {
33607 PyThreadState* __tstate = wxPyBeginAllowThreads();
33608 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33609 wxPyEndAllowThreads(__tstate);
33610 if (PyErr_Occurred()) SWIG_fail;
33611 }
33612 resultobj = SWIG_Py_Void();
33613 return resultobj;
33614 fail:
33615 return NULL;
33616 }
33617
33618
33619 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33620 PyObject *resultobj = 0;
33621 wxWindow *arg1 = (wxWindow *) 0 ;
33622 wxRect *arg2 = 0 ;
33623 int arg3 = (int) wxSIZE_AUTO ;
33624 void *argp1 = 0 ;
33625 int res1 = 0 ;
33626 wxRect temp2 ;
33627 int val3 ;
33628 int ecode3 = 0 ;
33629 PyObject * obj0 = 0 ;
33630 PyObject * obj1 = 0 ;
33631 PyObject * obj2 = 0 ;
33632 char * kwnames[] = {
33633 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33634 };
33635
33636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33638 if (!SWIG_IsOK(res1)) {
33639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33640 }
33641 arg1 = reinterpret_cast< wxWindow * >(argp1);
33642 {
33643 arg2 = &temp2;
33644 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33645 }
33646 if (obj2) {
33647 ecode3 = SWIG_AsVal_int(obj2, &val3);
33648 if (!SWIG_IsOK(ecode3)) {
33649 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33650 }
33651 arg3 = static_cast< int >(val3);
33652 }
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 resultobj = SWIG_Py_Void();
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj = 0;
33668 wxWindow *arg1 = (wxWindow *) 0 ;
33669 int arg2 ;
33670 int arg3 ;
33671 void *argp1 = 0 ;
33672 int res1 = 0 ;
33673 int val2 ;
33674 int ecode2 = 0 ;
33675 int val3 ;
33676 int ecode3 = 0 ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 PyObject * obj2 = 0 ;
33680 char * kwnames[] = {
33681 (char *) "self",(char *) "width",(char *) "height", NULL
33682 };
33683
33684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33686 if (!SWIG_IsOK(res1)) {
33687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33688 }
33689 arg1 = reinterpret_cast< wxWindow * >(argp1);
33690 ecode2 = SWIG_AsVal_int(obj1, &val2);
33691 if (!SWIG_IsOK(ecode2)) {
33692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33693 }
33694 arg2 = static_cast< int >(val2);
33695 ecode3 = SWIG_AsVal_int(obj2, &val3);
33696 if (!SWIG_IsOK(ecode3)) {
33697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33698 }
33699 arg3 = static_cast< int >(val3);
33700 {
33701 PyThreadState* __tstate = wxPyBeginAllowThreads();
33702 (arg1)->SetSize(arg2,arg3);
33703 wxPyEndAllowThreads(__tstate);
33704 if (PyErr_Occurred()) SWIG_fail;
33705 }
33706 resultobj = SWIG_Py_Void();
33707 return resultobj;
33708 fail:
33709 return NULL;
33710 }
33711
33712
33713 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33714 PyObject *resultobj = 0;
33715 wxWindow *arg1 = (wxWindow *) 0 ;
33716 wxPoint *arg2 = 0 ;
33717 int arg3 = (int) wxSIZE_USE_EXISTING ;
33718 void *argp1 = 0 ;
33719 int res1 = 0 ;
33720 wxPoint temp2 ;
33721 int val3 ;
33722 int ecode3 = 0 ;
33723 PyObject * obj0 = 0 ;
33724 PyObject * obj1 = 0 ;
33725 PyObject * obj2 = 0 ;
33726 char * kwnames[] = {
33727 (char *) "self",(char *) "pt",(char *) "flags", NULL
33728 };
33729
33730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33732 if (!SWIG_IsOK(res1)) {
33733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33734 }
33735 arg1 = reinterpret_cast< wxWindow * >(argp1);
33736 {
33737 arg2 = &temp2;
33738 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33739 }
33740 if (obj2) {
33741 ecode3 = SWIG_AsVal_int(obj2, &val3);
33742 if (!SWIG_IsOK(ecode3)) {
33743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33744 }
33745 arg3 = static_cast< int >(val3);
33746 }
33747 {
33748 PyThreadState* __tstate = wxPyBeginAllowThreads();
33749 (arg1)->Move((wxPoint const &)*arg2,arg3);
33750 wxPyEndAllowThreads(__tstate);
33751 if (PyErr_Occurred()) SWIG_fail;
33752 }
33753 resultobj = SWIG_Py_Void();
33754 return resultobj;
33755 fail:
33756 return NULL;
33757 }
33758
33759
33760 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33761 PyObject *resultobj = 0;
33762 wxWindow *arg1 = (wxWindow *) 0 ;
33763 int arg2 ;
33764 int arg3 ;
33765 int arg4 = (int) wxSIZE_USE_EXISTING ;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 int val2 ;
33769 int ecode2 = 0 ;
33770 int val3 ;
33771 int ecode3 = 0 ;
33772 int val4 ;
33773 int ecode4 = 0 ;
33774 PyObject * obj0 = 0 ;
33775 PyObject * obj1 = 0 ;
33776 PyObject * obj2 = 0 ;
33777 PyObject * obj3 = 0 ;
33778 char * kwnames[] = {
33779 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33780 };
33781
33782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33784 if (!SWIG_IsOK(res1)) {
33785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33786 }
33787 arg1 = reinterpret_cast< wxWindow * >(argp1);
33788 ecode2 = SWIG_AsVal_int(obj1, &val2);
33789 if (!SWIG_IsOK(ecode2)) {
33790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33791 }
33792 arg2 = static_cast< int >(val2);
33793 ecode3 = SWIG_AsVal_int(obj2, &val3);
33794 if (!SWIG_IsOK(ecode3)) {
33795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33796 }
33797 arg3 = static_cast< int >(val3);
33798 if (obj3) {
33799 ecode4 = SWIG_AsVal_int(obj3, &val4);
33800 if (!SWIG_IsOK(ecode4)) {
33801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33802 }
33803 arg4 = static_cast< int >(val4);
33804 }
33805 {
33806 PyThreadState* __tstate = wxPyBeginAllowThreads();
33807 (arg1)->Move(arg2,arg3,arg4);
33808 wxPyEndAllowThreads(__tstate);
33809 if (PyErr_Occurred()) SWIG_fail;
33810 }
33811 resultobj = SWIG_Py_Void();
33812 return resultobj;
33813 fail:
33814 return NULL;
33815 }
33816
33817
33818 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33819 PyObject *resultobj = 0;
33820 wxWindow *arg1 = (wxWindow *) 0 ;
33821 wxSize const &arg2_defvalue = wxDefaultSize ;
33822 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 wxSize temp2 ;
33826 PyObject * obj0 = 0 ;
33827 PyObject * obj1 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "size", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 if (obj1) {
33839 {
33840 arg2 = &temp2;
33841 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33842 }
33843 }
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 (arg1)->SetInitialSize((wxSize const &)*arg2);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_Py_Void();
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 void *argp1 = 0 ;
33861 int res1 = 0 ;
33862 PyObject *swig_obj[1] ;
33863
33864 if (!args) SWIG_fail;
33865 swig_obj[0] = args;
33866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33867 if (!SWIG_IsOK(res1)) {
33868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33869 }
33870 arg1 = reinterpret_cast< wxWindow * >(argp1);
33871 {
33872 PyThreadState* __tstate = wxPyBeginAllowThreads();
33873 (arg1)->Raise();
33874 wxPyEndAllowThreads(__tstate);
33875 if (PyErr_Occurred()) SWIG_fail;
33876 }
33877 resultobj = SWIG_Py_Void();
33878 return resultobj;
33879 fail:
33880 return NULL;
33881 }
33882
33883
33884 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33885 PyObject *resultobj = 0;
33886 wxWindow *arg1 = (wxWindow *) 0 ;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33896 }
33897 arg1 = reinterpret_cast< wxWindow * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 (arg1)->Lower();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 resultobj = SWIG_Py_Void();
33905 return resultobj;
33906 fail:
33907 return NULL;
33908 }
33909
33910
33911 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33912 PyObject *resultobj = 0;
33913 wxWindow *arg1 = (wxWindow *) 0 ;
33914 wxSize *arg2 = 0 ;
33915 void *argp1 = 0 ;
33916 int res1 = 0 ;
33917 wxSize temp2 ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 char * kwnames[] = {
33921 (char *) "self",(char *) "size", NULL
33922 };
33923
33924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33926 if (!SWIG_IsOK(res1)) {
33927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33928 }
33929 arg1 = reinterpret_cast< wxWindow * >(argp1);
33930 {
33931 arg2 = &temp2;
33932 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33933 }
33934 {
33935 PyThreadState* __tstate = wxPyBeginAllowThreads();
33936 (arg1)->SetClientSize((wxSize const &)*arg2);
33937 wxPyEndAllowThreads(__tstate);
33938 if (PyErr_Occurred()) SWIG_fail;
33939 }
33940 resultobj = SWIG_Py_Void();
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj = 0;
33949 wxWindow *arg1 = (wxWindow *) 0 ;
33950 int arg2 ;
33951 int arg3 ;
33952 void *argp1 = 0 ;
33953 int res1 = 0 ;
33954 int val2 ;
33955 int ecode2 = 0 ;
33956 int val3 ;
33957 int ecode3 = 0 ;
33958 PyObject * obj0 = 0 ;
33959 PyObject * obj1 = 0 ;
33960 PyObject * obj2 = 0 ;
33961 char * kwnames[] = {
33962 (char *) "self",(char *) "width",(char *) "height", NULL
33963 };
33964
33965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33967 if (!SWIG_IsOK(res1)) {
33968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33969 }
33970 arg1 = reinterpret_cast< wxWindow * >(argp1);
33971 ecode2 = SWIG_AsVal_int(obj1, &val2);
33972 if (!SWIG_IsOK(ecode2)) {
33973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33974 }
33975 arg2 = static_cast< int >(val2);
33976 ecode3 = SWIG_AsVal_int(obj2, &val3);
33977 if (!SWIG_IsOK(ecode3)) {
33978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33979 }
33980 arg3 = static_cast< int >(val3);
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 (arg1)->SetClientSize(arg2,arg3);
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_Py_Void();
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33995 PyObject *resultobj = 0;
33996 wxWindow *arg1 = (wxWindow *) 0 ;
33997 wxRect *arg2 = 0 ;
33998 void *argp1 = 0 ;
33999 int res1 = 0 ;
34000 wxRect temp2 ;
34001 PyObject * obj0 = 0 ;
34002 PyObject * obj1 = 0 ;
34003 char * kwnames[] = {
34004 (char *) "self",(char *) "rect", NULL
34005 };
34006
34007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34009 if (!SWIG_IsOK(res1)) {
34010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34011 }
34012 arg1 = reinterpret_cast< wxWindow * >(argp1);
34013 {
34014 arg2 = &temp2;
34015 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34016 }
34017 {
34018 PyThreadState* __tstate = wxPyBeginAllowThreads();
34019 (arg1)->SetClientSize((wxRect const &)*arg2);
34020 wxPyEndAllowThreads(__tstate);
34021 if (PyErr_Occurred()) SWIG_fail;
34022 }
34023 resultobj = SWIG_Py_Void();
34024 return resultobj;
34025 fail:
34026 return NULL;
34027 }
34028
34029
34030 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34031 PyObject *resultobj = 0;
34032 wxWindow *arg1 = (wxWindow *) 0 ;
34033 wxPoint result;
34034 void *argp1 = 0 ;
34035 int res1 = 0 ;
34036 PyObject *swig_obj[1] ;
34037
34038 if (!args) SWIG_fail;
34039 swig_obj[0] = args;
34040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34041 if (!SWIG_IsOK(res1)) {
34042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34043 }
34044 arg1 = reinterpret_cast< wxWindow * >(argp1);
34045 {
34046 PyThreadState* __tstate = wxPyBeginAllowThreads();
34047 result = ((wxWindow const *)arg1)->GetPosition();
34048 wxPyEndAllowThreads(__tstate);
34049 if (PyErr_Occurred()) SWIG_fail;
34050 }
34051 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34052 return resultobj;
34053 fail:
34054 return NULL;
34055 }
34056
34057
34058 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34059 PyObject *resultobj = 0;
34060 wxWindow *arg1 = (wxWindow *) 0 ;
34061 int *arg2 = (int *) 0 ;
34062 int *arg3 = (int *) 0 ;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 int temp2 ;
34066 int res2 = SWIG_TMPOBJ ;
34067 int temp3 ;
34068 int res3 = SWIG_TMPOBJ ;
34069 PyObject *swig_obj[1] ;
34070
34071 arg2 = &temp2;
34072 arg3 = &temp3;
34073 if (!args) SWIG_fail;
34074 swig_obj[0] = args;
34075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34078 }
34079 arg1 = reinterpret_cast< wxWindow * >(argp1);
34080 {
34081 PyThreadState* __tstate = wxPyBeginAllowThreads();
34082 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 resultobj = SWIG_Py_Void();
34087 if (SWIG_IsTmpObj(res2)) {
34088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34089 } else {
34090 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34092 }
34093 if (SWIG_IsTmpObj(res3)) {
34094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34095 } else {
34096 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34098 }
34099 return resultobj;
34100 fail:
34101 return NULL;
34102 }
34103
34104
34105 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34106 PyObject *resultobj = 0;
34107 wxWindow *arg1 = (wxWindow *) 0 ;
34108 wxPoint result;
34109 void *argp1 = 0 ;
34110 int res1 = 0 ;
34111 PyObject *swig_obj[1] ;
34112
34113 if (!args) SWIG_fail;
34114 swig_obj[0] = args;
34115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 result = ((wxWindow const *)arg1)->GetScreenPosition();
34123 wxPyEndAllowThreads(__tstate);
34124 if (PyErr_Occurred()) SWIG_fail;
34125 }
34126 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34134 PyObject *resultobj = 0;
34135 wxWindow *arg1 = (wxWindow *) 0 ;
34136 int *arg2 = (int *) 0 ;
34137 int *arg3 = (int *) 0 ;
34138 void *argp1 = 0 ;
34139 int res1 = 0 ;
34140 int temp2 ;
34141 int res2 = SWIG_TMPOBJ ;
34142 int temp3 ;
34143 int res3 = SWIG_TMPOBJ ;
34144 PyObject *swig_obj[1] ;
34145
34146 arg2 = &temp2;
34147 arg3 = &temp3;
34148 if (!args) SWIG_fail;
34149 swig_obj[0] = args;
34150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34151 if (!SWIG_IsOK(res1)) {
34152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34153 }
34154 arg1 = reinterpret_cast< wxWindow * >(argp1);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_Py_Void();
34162 if (SWIG_IsTmpObj(res2)) {
34163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34164 } else {
34165 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34167 }
34168 if (SWIG_IsTmpObj(res3)) {
34169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34170 } else {
34171 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34173 }
34174 return resultobj;
34175 fail:
34176 return NULL;
34177 }
34178
34179
34180 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34181 PyObject *resultobj = 0;
34182 wxWindow *arg1 = (wxWindow *) 0 ;
34183 wxRect result;
34184 void *argp1 = 0 ;
34185 int res1 = 0 ;
34186 PyObject *swig_obj[1] ;
34187
34188 if (!args) SWIG_fail;
34189 swig_obj[0] = args;
34190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34191 if (!SWIG_IsOK(res1)) {
34192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34193 }
34194 arg1 = reinterpret_cast< wxWindow * >(argp1);
34195 {
34196 PyThreadState* __tstate = wxPyBeginAllowThreads();
34197 result = ((wxWindow const *)arg1)->GetScreenRect();
34198 wxPyEndAllowThreads(__tstate);
34199 if (PyErr_Occurred()) SWIG_fail;
34200 }
34201 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34202 return resultobj;
34203 fail:
34204 return NULL;
34205 }
34206
34207
34208 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34209 PyObject *resultobj = 0;
34210 wxWindow *arg1 = (wxWindow *) 0 ;
34211 wxSize result;
34212 void *argp1 = 0 ;
34213 int res1 = 0 ;
34214 PyObject *swig_obj[1] ;
34215
34216 if (!args) SWIG_fail;
34217 swig_obj[0] = args;
34218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34219 if (!SWIG_IsOK(res1)) {
34220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34221 }
34222 arg1 = reinterpret_cast< wxWindow * >(argp1);
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 result = ((wxWindow const *)arg1)->GetSize();
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 int *arg2 = (int *) 0 ;
34240 int *arg3 = (int *) 0 ;
34241 void *argp1 = 0 ;
34242 int res1 = 0 ;
34243 int temp2 ;
34244 int res2 = SWIG_TMPOBJ ;
34245 int temp3 ;
34246 int res3 = SWIG_TMPOBJ ;
34247 PyObject *swig_obj[1] ;
34248
34249 arg2 = &temp2;
34250 arg3 = &temp3;
34251 if (!args) SWIG_fail;
34252 swig_obj[0] = args;
34253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34254 if (!SWIG_IsOK(res1)) {
34255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34256 }
34257 arg1 = reinterpret_cast< wxWindow * >(argp1);
34258 {
34259 PyThreadState* __tstate = wxPyBeginAllowThreads();
34260 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34261 wxPyEndAllowThreads(__tstate);
34262 if (PyErr_Occurred()) SWIG_fail;
34263 }
34264 resultobj = SWIG_Py_Void();
34265 if (SWIG_IsTmpObj(res2)) {
34266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34267 } else {
34268 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34270 }
34271 if (SWIG_IsTmpObj(res3)) {
34272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34273 } else {
34274 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34276 }
34277 return resultobj;
34278 fail:
34279 return NULL;
34280 }
34281
34282
34283 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34284 PyObject *resultobj = 0;
34285 wxWindow *arg1 = (wxWindow *) 0 ;
34286 wxRect result;
34287 void *argp1 = 0 ;
34288 int res1 = 0 ;
34289 PyObject *swig_obj[1] ;
34290
34291 if (!args) SWIG_fail;
34292 swig_obj[0] = args;
34293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34294 if (!SWIG_IsOK(res1)) {
34295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34296 }
34297 arg1 = reinterpret_cast< wxWindow * >(argp1);
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 result = ((wxWindow const *)arg1)->GetRect();
34301 wxPyEndAllowThreads(__tstate);
34302 if (PyErr_Occurred()) SWIG_fail;
34303 }
34304 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34312 PyObject *resultobj = 0;
34313 wxWindow *arg1 = (wxWindow *) 0 ;
34314 wxSize result;
34315 void *argp1 = 0 ;
34316 int res1 = 0 ;
34317 PyObject *swig_obj[1] ;
34318
34319 if (!args) SWIG_fail;
34320 swig_obj[0] = args;
34321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34322 if (!SWIG_IsOK(res1)) {
34323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34324 }
34325 arg1 = reinterpret_cast< wxWindow * >(argp1);
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = ((wxWindow const *)arg1)->GetClientSize();
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 int *arg2 = (int *) 0 ;
34343 int *arg3 = (int *) 0 ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 int temp2 ;
34347 int res2 = SWIG_TMPOBJ ;
34348 int temp3 ;
34349 int res3 = SWIG_TMPOBJ ;
34350 PyObject *swig_obj[1] ;
34351
34352 arg2 = &temp2;
34353 arg3 = &temp3;
34354 if (!args) SWIG_fail;
34355 swig_obj[0] = args;
34356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34357 if (!SWIG_IsOK(res1)) {
34358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34359 }
34360 arg1 = reinterpret_cast< wxWindow * >(argp1);
34361 {
34362 PyThreadState* __tstate = wxPyBeginAllowThreads();
34363 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34364 wxPyEndAllowThreads(__tstate);
34365 if (PyErr_Occurred()) SWIG_fail;
34366 }
34367 resultobj = SWIG_Py_Void();
34368 if (SWIG_IsTmpObj(res2)) {
34369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34370 } else {
34371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34373 }
34374 if (SWIG_IsTmpObj(res3)) {
34375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34376 } else {
34377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34379 }
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 wxPoint result;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 PyObject *swig_obj[1] ;
34393
34394 if (!args) SWIG_fail;
34395 swig_obj[0] = args;
34396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res1)) {
34398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 wxRect result;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = ((wxWindow const *)arg1)->GetClientRect();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 wxSize result;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 PyObject *swig_obj[1] ;
34449
34450 if (!args) SWIG_fail;
34451 swig_obj[0] = args;
34452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34453 if (!SWIG_IsOK(res1)) {
34454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34455 }
34456 arg1 = reinterpret_cast< wxWindow * >(argp1);
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 result = ((wxWindow const *)arg1)->GetBestSize();
34460 wxPyEndAllowThreads(__tstate);
34461 if (PyErr_Occurred()) SWIG_fail;
34462 }
34463 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34464 return resultobj;
34465 fail:
34466 return NULL;
34467 }
34468
34469
34470 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34471 PyObject *resultobj = 0;
34472 wxWindow *arg1 = (wxWindow *) 0 ;
34473 int *arg2 = (int *) 0 ;
34474 int *arg3 = (int *) 0 ;
34475 void *argp1 = 0 ;
34476 int res1 = 0 ;
34477 int temp2 ;
34478 int res2 = SWIG_TMPOBJ ;
34479 int temp3 ;
34480 int res3 = SWIG_TMPOBJ ;
34481 PyObject *swig_obj[1] ;
34482
34483 arg2 = &temp2;
34484 arg3 = &temp3;
34485 if (!args) SWIG_fail;
34486 swig_obj[0] = args;
34487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34490 }
34491 arg1 = reinterpret_cast< wxWindow * >(argp1);
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_Py_Void();
34499 if (SWIG_IsTmpObj(res2)) {
34500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34501 } else {
34502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34504 }
34505 if (SWIG_IsTmpObj(res3)) {
34506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34507 } else {
34508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 void *argp1 = 0 ;
34521 int res1 = 0 ;
34522 PyObject *swig_obj[1] ;
34523
34524 if (!args) SWIG_fail;
34525 swig_obj[0] = args;
34526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34527 if (!SWIG_IsOK(res1)) {
34528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34529 }
34530 arg1 = reinterpret_cast< wxWindow * >(argp1);
34531 {
34532 PyThreadState* __tstate = wxPyBeginAllowThreads();
34533 (arg1)->InvalidateBestSize();
34534 wxPyEndAllowThreads(__tstate);
34535 if (PyErr_Occurred()) SWIG_fail;
34536 }
34537 resultobj = SWIG_Py_Void();
34538 return resultobj;
34539 fail:
34540 return NULL;
34541 }
34542
34543
34544 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34545 PyObject *resultobj = 0;
34546 wxWindow *arg1 = (wxWindow *) 0 ;
34547 wxSize *arg2 = 0 ;
34548 void *argp1 = 0 ;
34549 int res1 = 0 ;
34550 wxSize temp2 ;
34551 PyObject * obj0 = 0 ;
34552 PyObject * obj1 = 0 ;
34553 char * kwnames[] = {
34554 (char *) "self",(char *) "size", NULL
34555 };
34556
34557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34559 if (!SWIG_IsOK(res1)) {
34560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34561 }
34562 arg1 = reinterpret_cast< wxWindow * >(argp1);
34563 {
34564 arg2 = &temp2;
34565 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34566 }
34567 {
34568 PyThreadState* __tstate = wxPyBeginAllowThreads();
34569 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34570 wxPyEndAllowThreads(__tstate);
34571 if (PyErr_Occurred()) SWIG_fail;
34572 }
34573 resultobj = SWIG_Py_Void();
34574 return resultobj;
34575 fail:
34576 return NULL;
34577 }
34578
34579
34580 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34581 PyObject *resultobj = 0;
34582 wxWindow *arg1 = (wxWindow *) 0 ;
34583 wxSize result;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 PyObject *swig_obj[1] ;
34587
34588 if (!args) SWIG_fail;
34589 swig_obj[0] = args;
34590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34598 wxPyEndAllowThreads(__tstate);
34599 if (PyErr_Occurred()) SWIG_fail;
34600 }
34601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34602 return resultobj;
34603 fail:
34604 return NULL;
34605 }
34606
34607
34608 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34609 PyObject *resultobj = 0;
34610 wxWindow *arg1 = (wxWindow *) 0 ;
34611 int arg2 = (int) wxBOTH ;
34612 void *argp1 = 0 ;
34613 int res1 = 0 ;
34614 int val2 ;
34615 int ecode2 = 0 ;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 char * kwnames[] = {
34619 (char *) "self",(char *) "direction", NULL
34620 };
34621
34622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34624 if (!SWIG_IsOK(res1)) {
34625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34626 }
34627 arg1 = reinterpret_cast< wxWindow * >(argp1);
34628 if (obj1) {
34629 ecode2 = SWIG_AsVal_int(obj1, &val2);
34630 if (!SWIG_IsOK(ecode2)) {
34631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34632 }
34633 arg2 = static_cast< int >(val2);
34634 }
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 (arg1)->Center(arg2);
34638 wxPyEndAllowThreads(__tstate);
34639 if (PyErr_Occurred()) SWIG_fail;
34640 }
34641 resultobj = SWIG_Py_Void();
34642 return resultobj;
34643 fail:
34644 return NULL;
34645 }
34646
34647
34648 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34649 PyObject *resultobj = 0;
34650 wxWindow *arg1 = (wxWindow *) 0 ;
34651 int arg2 = (int) wxBOTH ;
34652 void *argp1 = 0 ;
34653 int res1 = 0 ;
34654 int val2 ;
34655 int ecode2 = 0 ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 char * kwnames[] = {
34659 (char *) "self",(char *) "dir", NULL
34660 };
34661
34662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34664 if (!SWIG_IsOK(res1)) {
34665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34666 }
34667 arg1 = reinterpret_cast< wxWindow * >(argp1);
34668 if (obj1) {
34669 ecode2 = SWIG_AsVal_int(obj1, &val2);
34670 if (!SWIG_IsOK(ecode2)) {
34671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34672 }
34673 arg2 = static_cast< int >(val2);
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 (arg1)->CenterOnParent(arg2);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 resultobj = SWIG_Py_Void();
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34689 PyObject *resultobj = 0;
34690 wxWindow *arg1 = (wxWindow *) 0 ;
34691 void *argp1 = 0 ;
34692 int res1 = 0 ;
34693 PyObject *swig_obj[1] ;
34694
34695 if (!args) SWIG_fail;
34696 swig_obj[0] = args;
34697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34698 if (!SWIG_IsOK(res1)) {
34699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34700 }
34701 arg1 = reinterpret_cast< wxWindow * >(argp1);
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 (arg1)->Fit();
34705 wxPyEndAllowThreads(__tstate);
34706 if (PyErr_Occurred()) SWIG_fail;
34707 }
34708 resultobj = SWIG_Py_Void();
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34716 PyObject *resultobj = 0;
34717 wxWindow *arg1 = (wxWindow *) 0 ;
34718 void *argp1 = 0 ;
34719 int res1 = 0 ;
34720 PyObject *swig_obj[1] ;
34721
34722 if (!args) SWIG_fail;
34723 swig_obj[0] = args;
34724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34725 if (!SWIG_IsOK(res1)) {
34726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34727 }
34728 arg1 = reinterpret_cast< wxWindow * >(argp1);
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 (arg1)->FitInside();
34732 wxPyEndAllowThreads(__tstate);
34733 if (PyErr_Occurred()) SWIG_fail;
34734 }
34735 resultobj = SWIG_Py_Void();
34736 return resultobj;
34737 fail:
34738 return NULL;
34739 }
34740
34741
34742 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34743 PyObject *resultobj = 0;
34744 wxWindow *arg1 = (wxWindow *) 0 ;
34745 int arg2 ;
34746 int arg3 ;
34747 int arg4 = (int) -1 ;
34748 int arg5 = (int) -1 ;
34749 int arg6 = (int) -1 ;
34750 int arg7 = (int) -1 ;
34751 void *argp1 = 0 ;
34752 int res1 = 0 ;
34753 int val2 ;
34754 int ecode2 = 0 ;
34755 int val3 ;
34756 int ecode3 = 0 ;
34757 int val4 ;
34758 int ecode4 = 0 ;
34759 int val5 ;
34760 int ecode5 = 0 ;
34761 int val6 ;
34762 int ecode6 = 0 ;
34763 int val7 ;
34764 int ecode7 = 0 ;
34765 PyObject * obj0 = 0 ;
34766 PyObject * obj1 = 0 ;
34767 PyObject * obj2 = 0 ;
34768 PyObject * obj3 = 0 ;
34769 PyObject * obj4 = 0 ;
34770 PyObject * obj5 = 0 ;
34771 PyObject * obj6 = 0 ;
34772 char * kwnames[] = {
34773 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34774 };
34775
34776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34778 if (!SWIG_IsOK(res1)) {
34779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34780 }
34781 arg1 = reinterpret_cast< wxWindow * >(argp1);
34782 ecode2 = SWIG_AsVal_int(obj1, &val2);
34783 if (!SWIG_IsOK(ecode2)) {
34784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34785 }
34786 arg2 = static_cast< int >(val2);
34787 ecode3 = SWIG_AsVal_int(obj2, &val3);
34788 if (!SWIG_IsOK(ecode3)) {
34789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34790 }
34791 arg3 = static_cast< int >(val3);
34792 if (obj3) {
34793 ecode4 = SWIG_AsVal_int(obj3, &val4);
34794 if (!SWIG_IsOK(ecode4)) {
34795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34796 }
34797 arg4 = static_cast< int >(val4);
34798 }
34799 if (obj4) {
34800 ecode5 = SWIG_AsVal_int(obj4, &val5);
34801 if (!SWIG_IsOK(ecode5)) {
34802 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34803 }
34804 arg5 = static_cast< int >(val5);
34805 }
34806 if (obj5) {
34807 ecode6 = SWIG_AsVal_int(obj5, &val6);
34808 if (!SWIG_IsOK(ecode6)) {
34809 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34810 }
34811 arg6 = static_cast< int >(val6);
34812 }
34813 if (obj6) {
34814 ecode7 = SWIG_AsVal_int(obj6, &val7);
34815 if (!SWIG_IsOK(ecode7)) {
34816 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34817 }
34818 arg7 = static_cast< int >(val7);
34819 }
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 resultobj = SWIG_Py_Void();
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 wxSize *arg2 = 0 ;
34837 wxSize const &arg3_defvalue = wxDefaultSize ;
34838 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34839 wxSize const &arg4_defvalue = wxDefaultSize ;
34840 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34841 void *argp1 = 0 ;
34842 int res1 = 0 ;
34843 wxSize temp2 ;
34844 wxSize temp3 ;
34845 wxSize temp4 ;
34846 PyObject * obj0 = 0 ;
34847 PyObject * obj1 = 0 ;
34848 PyObject * obj2 = 0 ;
34849 PyObject * obj3 = 0 ;
34850 char * kwnames[] = {
34851 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34852 };
34853
34854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34856 if (!SWIG_IsOK(res1)) {
34857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34858 }
34859 arg1 = reinterpret_cast< wxWindow * >(argp1);
34860 {
34861 arg2 = &temp2;
34862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34863 }
34864 if (obj2) {
34865 {
34866 arg3 = &temp3;
34867 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34868 }
34869 }
34870 if (obj3) {
34871 {
34872 arg4 = &temp4;
34873 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34874 }
34875 }
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 resultobj = SWIG_Py_Void();
34883 return resultobj;
34884 fail:
34885 return NULL;
34886 }
34887
34888
34889 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34890 PyObject *resultobj = 0;
34891 wxWindow *arg1 = (wxWindow *) 0 ;
34892 int arg2 ;
34893 int arg3 ;
34894 int arg4 = (int) -1 ;
34895 int arg5 = (int) -1 ;
34896 void *argp1 = 0 ;
34897 int res1 = 0 ;
34898 int val2 ;
34899 int ecode2 = 0 ;
34900 int val3 ;
34901 int ecode3 = 0 ;
34902 int val4 ;
34903 int ecode4 = 0 ;
34904 int val5 ;
34905 int ecode5 = 0 ;
34906 PyObject * obj0 = 0 ;
34907 PyObject * obj1 = 0 ;
34908 PyObject * obj2 = 0 ;
34909 PyObject * obj3 = 0 ;
34910 PyObject * obj4 = 0 ;
34911 char * kwnames[] = {
34912 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34913 };
34914
34915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34917 if (!SWIG_IsOK(res1)) {
34918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 ecode2 = SWIG_AsVal_int(obj1, &val2);
34922 if (!SWIG_IsOK(ecode2)) {
34923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34924 }
34925 arg2 = static_cast< int >(val2);
34926 ecode3 = SWIG_AsVal_int(obj2, &val3);
34927 if (!SWIG_IsOK(ecode3)) {
34928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34929 }
34930 arg3 = static_cast< int >(val3);
34931 if (obj3) {
34932 ecode4 = SWIG_AsVal_int(obj3, &val4);
34933 if (!SWIG_IsOK(ecode4)) {
34934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34935 }
34936 arg4 = static_cast< int >(val4);
34937 }
34938 if (obj4) {
34939 ecode5 = SWIG_AsVal_int(obj4, &val5);
34940 if (!SWIG_IsOK(ecode5)) {
34941 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34942 }
34943 arg5 = static_cast< int >(val5);
34944 }
34945 {
34946 PyThreadState* __tstate = wxPyBeginAllowThreads();
34947 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34948 wxPyEndAllowThreads(__tstate);
34949 if (PyErr_Occurred()) SWIG_fail;
34950 }
34951 resultobj = SWIG_Py_Void();
34952 return resultobj;
34953 fail:
34954 return NULL;
34955 }
34956
34957
34958 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34959 PyObject *resultobj = 0;
34960 wxWindow *arg1 = (wxWindow *) 0 ;
34961 wxSize *arg2 = 0 ;
34962 wxSize const &arg3_defvalue = wxDefaultSize ;
34963 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34964 void *argp1 = 0 ;
34965 int res1 = 0 ;
34966 wxSize temp2 ;
34967 wxSize temp3 ;
34968 PyObject * obj0 = 0 ;
34969 PyObject * obj1 = 0 ;
34970 PyObject * obj2 = 0 ;
34971 char * kwnames[] = {
34972 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34973 };
34974
34975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34977 if (!SWIG_IsOK(res1)) {
34978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34979 }
34980 arg1 = reinterpret_cast< wxWindow * >(argp1);
34981 {
34982 arg2 = &temp2;
34983 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34984 }
34985 if (obj2) {
34986 {
34987 arg3 = &temp3;
34988 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34989 }
34990 }
34991 {
34992 PyThreadState* __tstate = wxPyBeginAllowThreads();
34993 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34994 wxPyEndAllowThreads(__tstate);
34995 if (PyErr_Occurred()) SWIG_fail;
34996 }
34997 resultobj = SWIG_Py_Void();
34998 return resultobj;
34999 fail:
35000 return NULL;
35001 }
35002
35003
35004 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35005 PyObject *resultobj = 0;
35006 wxWindow *arg1 = (wxWindow *) 0 ;
35007 wxSize result;
35008 void *argp1 = 0 ;
35009 int res1 = 0 ;
35010 PyObject *swig_obj[1] ;
35011
35012 if (!args) SWIG_fail;
35013 swig_obj[0] = args;
35014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 result = ((wxWindow const *)arg1)->GetMaxSize();
35022 wxPyEndAllowThreads(__tstate);
35023 if (PyErr_Occurred()) SWIG_fail;
35024 }
35025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35026 return resultobj;
35027 fail:
35028 return NULL;
35029 }
35030
35031
35032 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35033 PyObject *resultobj = 0;
35034 wxWindow *arg1 = (wxWindow *) 0 ;
35035 wxSize result;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 PyObject *swig_obj[1] ;
35039
35040 if (!args) SWIG_fail;
35041 swig_obj[0] = args;
35042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35043 if (!SWIG_IsOK(res1)) {
35044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35045 }
35046 arg1 = reinterpret_cast< wxWindow * >(argp1);
35047 {
35048 PyThreadState* __tstate = wxPyBeginAllowThreads();
35049 result = ((wxWindow const *)arg1)->GetMinSize();
35050 wxPyEndAllowThreads(__tstate);
35051 if (PyErr_Occurred()) SWIG_fail;
35052 }
35053 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxWindow *arg1 = (wxWindow *) 0 ;
35063 wxSize *arg2 = 0 ;
35064 void *argp1 = 0 ;
35065 int res1 = 0 ;
35066 wxSize temp2 ;
35067 PyObject * obj0 = 0 ;
35068 PyObject * obj1 = 0 ;
35069 char * kwnames[] = {
35070 (char *) "self",(char *) "minSize", NULL
35071 };
35072
35073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35075 if (!SWIG_IsOK(res1)) {
35076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35077 }
35078 arg1 = reinterpret_cast< wxWindow * >(argp1);
35079 {
35080 arg2 = &temp2;
35081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35082 }
35083 {
35084 PyThreadState* __tstate = wxPyBeginAllowThreads();
35085 (arg1)->SetMinSize((wxSize const &)*arg2);
35086 wxPyEndAllowThreads(__tstate);
35087 if (PyErr_Occurred()) SWIG_fail;
35088 }
35089 resultobj = SWIG_Py_Void();
35090 return resultobj;
35091 fail:
35092 return NULL;
35093 }
35094
35095
35096 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35097 PyObject *resultobj = 0;
35098 wxWindow *arg1 = (wxWindow *) 0 ;
35099 wxSize *arg2 = 0 ;
35100 void *argp1 = 0 ;
35101 int res1 = 0 ;
35102 wxSize temp2 ;
35103 PyObject * obj0 = 0 ;
35104 PyObject * obj1 = 0 ;
35105 char * kwnames[] = {
35106 (char *) "self",(char *) "maxSize", NULL
35107 };
35108
35109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 arg2 = &temp2;
35117 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35118 }
35119 {
35120 PyThreadState* __tstate = wxPyBeginAllowThreads();
35121 (arg1)->SetMaxSize((wxSize const &)*arg2);
35122 wxPyEndAllowThreads(__tstate);
35123 if (PyErr_Occurred()) SWIG_fail;
35124 }
35125 resultobj = SWIG_Py_Void();
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35133 PyObject *resultobj = 0;
35134 wxWindow *arg1 = (wxWindow *) 0 ;
35135 int result;
35136 void *argp1 = 0 ;
35137 int res1 = 0 ;
35138 PyObject *swig_obj[1] ;
35139
35140 if (!args) SWIG_fail;
35141 swig_obj[0] = args;
35142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35143 if (!SWIG_IsOK(res1)) {
35144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35145 }
35146 arg1 = reinterpret_cast< wxWindow * >(argp1);
35147 {
35148 PyThreadState* __tstate = wxPyBeginAllowThreads();
35149 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35150 wxPyEndAllowThreads(__tstate);
35151 if (PyErr_Occurred()) SWIG_fail;
35152 }
35153 resultobj = SWIG_From_int(static_cast< int >(result));
35154 return resultobj;
35155 fail:
35156 return NULL;
35157 }
35158
35159
35160 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35161 PyObject *resultobj = 0;
35162 wxWindow *arg1 = (wxWindow *) 0 ;
35163 int result;
35164 void *argp1 = 0 ;
35165 int res1 = 0 ;
35166 PyObject *swig_obj[1] ;
35167
35168 if (!args) SWIG_fail;
35169 swig_obj[0] = args;
35170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35171 if (!SWIG_IsOK(res1)) {
35172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35173 }
35174 arg1 = reinterpret_cast< wxWindow * >(argp1);
35175 {
35176 PyThreadState* __tstate = wxPyBeginAllowThreads();
35177 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35178 wxPyEndAllowThreads(__tstate);
35179 if (PyErr_Occurred()) SWIG_fail;
35180 }
35181 resultobj = SWIG_From_int(static_cast< int >(result));
35182 return resultobj;
35183 fail:
35184 return NULL;
35185 }
35186
35187
35188 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35189 PyObject *resultobj = 0;
35190 wxWindow *arg1 = (wxWindow *) 0 ;
35191 int result;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 PyObject *swig_obj[1] ;
35195
35196 if (!args) SWIG_fail;
35197 swig_obj[0] = args;
35198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35199 if (!SWIG_IsOK(res1)) {
35200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35201 }
35202 arg1 = reinterpret_cast< wxWindow * >(argp1);
35203 {
35204 PyThreadState* __tstate = wxPyBeginAllowThreads();
35205 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 resultobj = SWIG_From_int(static_cast< int >(result));
35210 return resultobj;
35211 fail:
35212 return NULL;
35213 }
35214
35215
35216 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35217 PyObject *resultobj = 0;
35218 wxWindow *arg1 = (wxWindow *) 0 ;
35219 int result;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 PyObject *swig_obj[1] ;
35223
35224 if (!args) SWIG_fail;
35225 swig_obj[0] = args;
35226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35227 if (!SWIG_IsOK(res1)) {
35228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35229 }
35230 arg1 = reinterpret_cast< wxWindow * >(argp1);
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 resultobj = SWIG_From_int(static_cast< int >(result));
35238 return resultobj;
35239 fail:
35240 return NULL;
35241 }
35242
35243
35244 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35245 PyObject *resultobj = 0;
35246 wxWindow *arg1 = (wxWindow *) 0 ;
35247 wxSize *arg2 = 0 ;
35248 void *argp1 = 0 ;
35249 int res1 = 0 ;
35250 wxSize temp2 ;
35251 PyObject * obj0 = 0 ;
35252 PyObject * obj1 = 0 ;
35253 char * kwnames[] = {
35254 (char *) "self",(char *) "size", NULL
35255 };
35256
35257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35259 if (!SWIG_IsOK(res1)) {
35260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35261 }
35262 arg1 = reinterpret_cast< wxWindow * >(argp1);
35263 {
35264 arg2 = &temp2;
35265 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35266 }
35267 {
35268 PyThreadState* __tstate = wxPyBeginAllowThreads();
35269 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35270 wxPyEndAllowThreads(__tstate);
35271 if (PyErr_Occurred()) SWIG_fail;
35272 }
35273 resultobj = SWIG_Py_Void();
35274 return resultobj;
35275 fail:
35276 return NULL;
35277 }
35278
35279
35280 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35281 PyObject *resultobj = 0;
35282 wxWindow *arg1 = (wxWindow *) 0 ;
35283 int arg2 ;
35284 int arg3 ;
35285 void *argp1 = 0 ;
35286 int res1 = 0 ;
35287 int val2 ;
35288 int ecode2 = 0 ;
35289 int val3 ;
35290 int ecode3 = 0 ;
35291 PyObject * obj0 = 0 ;
35292 PyObject * obj1 = 0 ;
35293 PyObject * obj2 = 0 ;
35294 char * kwnames[] = {
35295 (char *) "self",(char *) "w",(char *) "h", NULL
35296 };
35297
35298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35300 if (!SWIG_IsOK(res1)) {
35301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35302 }
35303 arg1 = reinterpret_cast< wxWindow * >(argp1);
35304 ecode2 = SWIG_AsVal_int(obj1, &val2);
35305 if (!SWIG_IsOK(ecode2)) {
35306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35307 }
35308 arg2 = static_cast< int >(val2);
35309 ecode3 = SWIG_AsVal_int(obj2, &val3);
35310 if (!SWIG_IsOK(ecode3)) {
35311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35312 }
35313 arg3 = static_cast< int >(val3);
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 (arg1)->SetVirtualSize(arg2,arg3);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 resultobj = SWIG_Py_Void();
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35328 PyObject *resultobj = 0;
35329 wxWindow *arg1 = (wxWindow *) 0 ;
35330 wxSize result;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 PyObject *swig_obj[1] ;
35334
35335 if (!args) SWIG_fail;
35336 swig_obj[0] = args;
35337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35338 if (!SWIG_IsOK(res1)) {
35339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35340 }
35341 arg1 = reinterpret_cast< wxWindow * >(argp1);
35342 {
35343 PyThreadState* __tstate = wxPyBeginAllowThreads();
35344 result = ((wxWindow const *)arg1)->GetVirtualSize();
35345 wxPyEndAllowThreads(__tstate);
35346 if (PyErr_Occurred()) SWIG_fail;
35347 }
35348 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35356 PyObject *resultobj = 0;
35357 wxWindow *arg1 = (wxWindow *) 0 ;
35358 int *arg2 = (int *) 0 ;
35359 int *arg3 = (int *) 0 ;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 int temp2 ;
35363 int res2 = SWIG_TMPOBJ ;
35364 int temp3 ;
35365 int res3 = SWIG_TMPOBJ ;
35366 PyObject *swig_obj[1] ;
35367
35368 arg2 = &temp2;
35369 arg3 = &temp3;
35370 if (!args) SWIG_fail;
35371 swig_obj[0] = args;
35372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35373 if (!SWIG_IsOK(res1)) {
35374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35375 }
35376 arg1 = reinterpret_cast< wxWindow * >(argp1);
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35380 wxPyEndAllowThreads(__tstate);
35381 if (PyErr_Occurred()) SWIG_fail;
35382 }
35383 resultobj = SWIG_Py_Void();
35384 if (SWIG_IsTmpObj(res2)) {
35385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35386 } else {
35387 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35388 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35389 }
35390 if (SWIG_IsTmpObj(res3)) {
35391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35392 } else {
35393 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35395 }
35396 return resultobj;
35397 fail:
35398 return NULL;
35399 }
35400
35401
35402 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35403 PyObject *resultobj = 0;
35404 wxWindow *arg1 = (wxWindow *) 0 ;
35405 wxSize result;
35406 void *argp1 = 0 ;
35407 int res1 = 0 ;
35408 PyObject *swig_obj[1] ;
35409
35410 if (!args) SWIG_fail;
35411 swig_obj[0] = args;
35412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35413 if (!SWIG_IsOK(res1)) {
35414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35415 }
35416 arg1 = reinterpret_cast< wxWindow * >(argp1);
35417 {
35418 PyThreadState* __tstate = wxPyBeginAllowThreads();
35419 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35424 return resultobj;
35425 fail:
35426 return NULL;
35427 }
35428
35429
35430 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35431 PyObject *resultobj = 0;
35432 wxWindow *arg1 = (wxWindow *) 0 ;
35433 wxSize result;
35434 void *argp1 = 0 ;
35435 int res1 = 0 ;
35436 PyObject *swig_obj[1] ;
35437
35438 if (!args) SWIG_fail;
35439 swig_obj[0] = args;
35440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35441 if (!SWIG_IsOK(res1)) {
35442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35443 }
35444 arg1 = reinterpret_cast< wxWindow * >(argp1);
35445 {
35446 PyThreadState* __tstate = wxPyBeginAllowThreads();
35447 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj = 0;
35460 wxWindow *arg1 = (wxWindow *) 0 ;
35461 bool arg2 = (bool) true ;
35462 bool result;
35463 void *argp1 = 0 ;
35464 int res1 = 0 ;
35465 bool val2 ;
35466 int ecode2 = 0 ;
35467 PyObject * obj0 = 0 ;
35468 PyObject * obj1 = 0 ;
35469 char * kwnames[] = {
35470 (char *) "self",(char *) "show", NULL
35471 };
35472
35473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35475 if (!SWIG_IsOK(res1)) {
35476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35477 }
35478 arg1 = reinterpret_cast< wxWindow * >(argp1);
35479 if (obj1) {
35480 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35481 if (!SWIG_IsOK(ecode2)) {
35482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35483 }
35484 arg2 = static_cast< bool >(val2);
35485 }
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = (bool)(arg1)->Show(arg2);
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 {
35493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35494 }
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 bool result;
35505 void *argp1 = 0 ;
35506 int res1 = 0 ;
35507 PyObject *swig_obj[1] ;
35508
35509 if (!args) SWIG_fail;
35510 swig_obj[0] = args;
35511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35512 if (!SWIG_IsOK(res1)) {
35513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35514 }
35515 arg1 = reinterpret_cast< wxWindow * >(argp1);
35516 {
35517 PyThreadState* __tstate = wxPyBeginAllowThreads();
35518 result = (bool)(arg1)->Hide();
35519 wxPyEndAllowThreads(__tstate);
35520 if (PyErr_Occurred()) SWIG_fail;
35521 }
35522 {
35523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj = 0;
35533 wxWindow *arg1 = (wxWindow *) 0 ;
35534 bool arg2 = (bool) true ;
35535 bool result;
35536 void *argp1 = 0 ;
35537 int res1 = 0 ;
35538 bool val2 ;
35539 int ecode2 = 0 ;
35540 PyObject * obj0 = 0 ;
35541 PyObject * obj1 = 0 ;
35542 char * kwnames[] = {
35543 (char *) "self",(char *) "enable", NULL
35544 };
35545
35546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35548 if (!SWIG_IsOK(res1)) {
35549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35550 }
35551 arg1 = reinterpret_cast< wxWindow * >(argp1);
35552 if (obj1) {
35553 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35554 if (!SWIG_IsOK(ecode2)) {
35555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35556 }
35557 arg2 = static_cast< bool >(val2);
35558 }
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 result = (bool)(arg1)->Enable(arg2);
35562 wxPyEndAllowThreads(__tstate);
35563 if (PyErr_Occurred()) SWIG_fail;
35564 }
35565 {
35566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35567 }
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35575 PyObject *resultobj = 0;
35576 wxWindow *arg1 = (wxWindow *) 0 ;
35577 bool result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 PyObject *swig_obj[1] ;
35581
35582 if (!args) SWIG_fail;
35583 swig_obj[0] = args;
35584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35585 if (!SWIG_IsOK(res1)) {
35586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35587 }
35588 arg1 = reinterpret_cast< wxWindow * >(argp1);
35589 {
35590 PyThreadState* __tstate = wxPyBeginAllowThreads();
35591 result = (bool)(arg1)->Disable();
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 {
35596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35597 }
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35605 PyObject *resultobj = 0;
35606 wxWindow *arg1 = (wxWindow *) 0 ;
35607 bool result;
35608 void *argp1 = 0 ;
35609 int res1 = 0 ;
35610 PyObject *swig_obj[1] ;
35611
35612 if (!args) SWIG_fail;
35613 swig_obj[0] = args;
35614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35615 if (!SWIG_IsOK(res1)) {
35616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35617 }
35618 arg1 = reinterpret_cast< wxWindow * >(argp1);
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 result = (bool)((wxWindow const *)arg1)->IsShown();
35622 wxPyEndAllowThreads(__tstate);
35623 if (PyErr_Occurred()) SWIG_fail;
35624 }
35625 {
35626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35627 }
35628 return resultobj;
35629 fail:
35630 return NULL;
35631 }
35632
35633
35634 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35635 PyObject *resultobj = 0;
35636 wxWindow *arg1 = (wxWindow *) 0 ;
35637 bool result;
35638 void *argp1 = 0 ;
35639 int res1 = 0 ;
35640 PyObject *swig_obj[1] ;
35641
35642 if (!args) SWIG_fail;
35643 swig_obj[0] = args;
35644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35645 if (!SWIG_IsOK(res1)) {
35646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35647 }
35648 arg1 = reinterpret_cast< wxWindow * >(argp1);
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 {
35656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35657 }
35658 return resultobj;
35659 fail:
35660 return NULL;
35661 }
35662
35663
35664 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35665 PyObject *resultobj = 0;
35666 wxWindow *arg1 = (wxWindow *) 0 ;
35667 bool result;
35668 void *argp1 = 0 ;
35669 int res1 = 0 ;
35670 PyObject *swig_obj[1] ;
35671
35672 if (!args) SWIG_fail;
35673 swig_obj[0] = args;
35674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35675 if (!SWIG_IsOK(res1)) {
35676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35677 }
35678 arg1 = reinterpret_cast< wxWindow * >(argp1);
35679 {
35680 PyThreadState* __tstate = wxPyBeginAllowThreads();
35681 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35682 wxPyEndAllowThreads(__tstate);
35683 if (PyErr_Occurred()) SWIG_fail;
35684 }
35685 {
35686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35687 }
35688 return resultobj;
35689 fail:
35690 return NULL;
35691 }
35692
35693
35694 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35695 PyObject *resultobj = 0;
35696 wxWindow *arg1 = (wxWindow *) 0 ;
35697 long arg2 ;
35698 void *argp1 = 0 ;
35699 int res1 = 0 ;
35700 long val2 ;
35701 int ecode2 = 0 ;
35702 PyObject * obj0 = 0 ;
35703 PyObject * obj1 = 0 ;
35704 char * kwnames[] = {
35705 (char *) "self",(char *) "style", NULL
35706 };
35707
35708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35710 if (!SWIG_IsOK(res1)) {
35711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35712 }
35713 arg1 = reinterpret_cast< wxWindow * >(argp1);
35714 ecode2 = SWIG_AsVal_long(obj1, &val2);
35715 if (!SWIG_IsOK(ecode2)) {
35716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35717 }
35718 arg2 = static_cast< long >(val2);
35719 {
35720 PyThreadState* __tstate = wxPyBeginAllowThreads();
35721 (arg1)->SetWindowStyleFlag(arg2);
35722 wxPyEndAllowThreads(__tstate);
35723 if (PyErr_Occurred()) SWIG_fail;
35724 }
35725 resultobj = SWIG_Py_Void();
35726 return resultobj;
35727 fail:
35728 return NULL;
35729 }
35730
35731
35732 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35733 PyObject *resultobj = 0;
35734 wxWindow *arg1 = (wxWindow *) 0 ;
35735 long result;
35736 void *argp1 = 0 ;
35737 int res1 = 0 ;
35738 PyObject *swig_obj[1] ;
35739
35740 if (!args) SWIG_fail;
35741 swig_obj[0] = args;
35742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35743 if (!SWIG_IsOK(res1)) {
35744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35745 }
35746 arg1 = reinterpret_cast< wxWindow * >(argp1);
35747 {
35748 PyThreadState* __tstate = wxPyBeginAllowThreads();
35749 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35750 wxPyEndAllowThreads(__tstate);
35751 if (PyErr_Occurred()) SWIG_fail;
35752 }
35753 resultobj = SWIG_From_long(static_cast< long >(result));
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35761 PyObject *resultobj = 0;
35762 wxWindow *arg1 = (wxWindow *) 0 ;
35763 int arg2 ;
35764 bool result;
35765 void *argp1 = 0 ;
35766 int res1 = 0 ;
35767 int val2 ;
35768 int ecode2 = 0 ;
35769 PyObject * obj0 = 0 ;
35770 PyObject * obj1 = 0 ;
35771 char * kwnames[] = {
35772 (char *) "self",(char *) "flag", NULL
35773 };
35774
35775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35777 if (!SWIG_IsOK(res1)) {
35778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35779 }
35780 arg1 = reinterpret_cast< wxWindow * >(argp1);
35781 ecode2 = SWIG_AsVal_int(obj1, &val2);
35782 if (!SWIG_IsOK(ecode2)) {
35783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35784 }
35785 arg2 = static_cast< int >(val2);
35786 {
35787 PyThreadState* __tstate = wxPyBeginAllowThreads();
35788 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 {
35793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35794 }
35795 return resultobj;
35796 fail:
35797 return NULL;
35798 }
35799
35800
35801 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35802 PyObject *resultobj = 0;
35803 wxWindow *arg1 = (wxWindow *) 0 ;
35804 bool result;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 PyObject *swig_obj[1] ;
35808
35809 if (!args) SWIG_fail;
35810 swig_obj[0] = args;
35811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35814 }
35815 arg1 = reinterpret_cast< wxWindow * >(argp1);
35816 {
35817 PyThreadState* __tstate = wxPyBeginAllowThreads();
35818 result = (bool)((wxWindow const *)arg1)->IsRetained();
35819 wxPyEndAllowThreads(__tstate);
35820 if (PyErr_Occurred()) SWIG_fail;
35821 }
35822 {
35823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35824 }
35825 return resultobj;
35826 fail:
35827 return NULL;
35828 }
35829
35830
35831 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35832 PyObject *resultobj = 0;
35833 wxWindow *arg1 = (wxWindow *) 0 ;
35834 int arg2 ;
35835 bool result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 int val2 ;
35839 int ecode2 = 0 ;
35840 PyObject * obj0 = 0 ;
35841 PyObject * obj1 = 0 ;
35842 char * kwnames[] = {
35843 (char *) "self",(char *) "flag", NULL
35844 };
35845
35846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35848 if (!SWIG_IsOK(res1)) {
35849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35850 }
35851 arg1 = reinterpret_cast< wxWindow * >(argp1);
35852 ecode2 = SWIG_AsVal_int(obj1, &val2);
35853 if (!SWIG_IsOK(ecode2)) {
35854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
35855 }
35856 arg2 = static_cast< int >(val2);
35857 {
35858 PyThreadState* __tstate = wxPyBeginAllowThreads();
35859 result = (bool)(arg1)->ToggleWindowStyle(arg2);
35860 wxPyEndAllowThreads(__tstate);
35861 if (PyErr_Occurred()) SWIG_fail;
35862 }
35863 {
35864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35865 }
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj = 0;
35874 wxWindow *arg1 = (wxWindow *) 0 ;
35875 long arg2 ;
35876 void *argp1 = 0 ;
35877 int res1 = 0 ;
35878 long val2 ;
35879 int ecode2 = 0 ;
35880 PyObject * obj0 = 0 ;
35881 PyObject * obj1 = 0 ;
35882 char * kwnames[] = {
35883 (char *) "self",(char *) "exStyle", NULL
35884 };
35885
35886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35890 }
35891 arg1 = reinterpret_cast< wxWindow * >(argp1);
35892 ecode2 = SWIG_AsVal_long(obj1, &val2);
35893 if (!SWIG_IsOK(ecode2)) {
35894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35895 }
35896 arg2 = static_cast< long >(val2);
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 (arg1)->SetExtraStyle(arg2);
35900 wxPyEndAllowThreads(__tstate);
35901 if (PyErr_Occurred()) SWIG_fail;
35902 }
35903 resultobj = SWIG_Py_Void();
35904 return resultobj;
35905 fail:
35906 return NULL;
35907 }
35908
35909
35910 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35911 PyObject *resultobj = 0;
35912 wxWindow *arg1 = (wxWindow *) 0 ;
35913 long result;
35914 void *argp1 = 0 ;
35915 int res1 = 0 ;
35916 PyObject *swig_obj[1] ;
35917
35918 if (!args) SWIG_fail;
35919 swig_obj[0] = args;
35920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_From_long(static_cast< long >(result));
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 bool arg2 = (bool) true ;
35942 void *argp1 = 0 ;
35943 int res1 = 0 ;
35944 bool val2 ;
35945 int ecode2 = 0 ;
35946 PyObject * obj0 = 0 ;
35947 PyObject * obj1 = 0 ;
35948 char * kwnames[] = {
35949 (char *) "self",(char *) "modal", NULL
35950 };
35951
35952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35954 if (!SWIG_IsOK(res1)) {
35955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35956 }
35957 arg1 = reinterpret_cast< wxWindow * >(argp1);
35958 if (obj1) {
35959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35960 if (!SWIG_IsOK(ecode2)) {
35961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35962 }
35963 arg2 = static_cast< bool >(val2);
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 (arg1)->MakeModal(arg2);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_Py_Void();
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 bool arg2 ;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 bool val2 ;
35985 int ecode2 = 0 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 char * kwnames[] = {
35989 (char *) "self",(char *) "enableTheme", NULL
35990 };
35991
35992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35994 if (!SWIG_IsOK(res1)) {
35995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35996 }
35997 arg1 = reinterpret_cast< wxWindow * >(argp1);
35998 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35999 if (!SWIG_IsOK(ecode2)) {
36000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36001 }
36002 arg2 = static_cast< bool >(val2);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 (arg1)->SetThemeEnabled(arg2);
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 resultobj = SWIG_Py_Void();
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 bool result;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 PyObject *swig_obj[1] ;
36023
36024 if (!args) SWIG_fail;
36025 swig_obj[0] = args;
36026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36027 if (!SWIG_IsOK(res1)) {
36028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36029 }
36030 arg1 = reinterpret_cast< wxWindow * >(argp1);
36031 {
36032 PyThreadState* __tstate = wxPyBeginAllowThreads();
36033 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 {
36038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36039 }
36040 return resultobj;
36041 fail:
36042 return NULL;
36043 }
36044
36045
36046 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36047 PyObject *resultobj = 0;
36048 wxWindow *arg1 = (wxWindow *) 0 ;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 PyObject *swig_obj[1] ;
36052
36053 if (!args) SWIG_fail;
36054 swig_obj[0] = args;
36055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36056 if (!SWIG_IsOK(res1)) {
36057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36058 }
36059 arg1 = reinterpret_cast< wxWindow * >(argp1);
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 (arg1)->SetFocus();
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 resultobj = SWIG_Py_Void();
36067 return resultobj;
36068 fail:
36069 return NULL;
36070 }
36071
36072
36073 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36074 PyObject *resultobj = 0;
36075 wxWindow *arg1 = (wxWindow *) 0 ;
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_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36085 }
36086 arg1 = reinterpret_cast< wxWindow * >(argp1);
36087 {
36088 PyThreadState* __tstate = wxPyBeginAllowThreads();
36089 (arg1)->SetFocusFromKbd();
36090 wxPyEndAllowThreads(__tstate);
36091 if (PyErr_Occurred()) SWIG_fail;
36092 }
36093 resultobj = SWIG_Py_Void();
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36101 PyObject *resultobj = 0;
36102 wxWindow *result = 0 ;
36103
36104 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36105 {
36106 if (!wxPyCheckForApp()) SWIG_fail;
36107 PyThreadState* __tstate = wxPyBeginAllowThreads();
36108 result = (wxWindow *)wxWindow::FindFocus();
36109 wxPyEndAllowThreads(__tstate);
36110 if (PyErr_Occurred()) SWIG_fail;
36111 }
36112 {
36113 resultobj = wxPyMake_wxObject(result, 0);
36114 }
36115 return resultobj;
36116 fail:
36117 return NULL;
36118 }
36119
36120
36121 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36122 PyObject *resultobj = 0;
36123 wxWindow *arg1 = (wxWindow *) 0 ;
36124 bool result;
36125 void *argp1 = 0 ;
36126 int res1 = 0 ;
36127 PyObject *swig_obj[1] ;
36128
36129 if (!args) SWIG_fail;
36130 swig_obj[0] = args;
36131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36132 if (!SWIG_IsOK(res1)) {
36133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36134 }
36135 arg1 = reinterpret_cast< wxWindow * >(argp1);
36136 {
36137 PyThreadState* __tstate = wxPyBeginAllowThreads();
36138 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 {
36143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36144 }
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36152 PyObject *resultobj = 0;
36153 wxWindow *arg1 = (wxWindow *) 0 ;
36154 bool result;
36155 void *argp1 = 0 ;
36156 int res1 = 0 ;
36157 PyObject *swig_obj[1] ;
36158
36159 if (!args) SWIG_fail;
36160 swig_obj[0] = args;
36161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36162 if (!SWIG_IsOK(res1)) {
36163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36164 }
36165 arg1 = reinterpret_cast< wxWindow * >(argp1);
36166 {
36167 PyThreadState* __tstate = wxPyBeginAllowThreads();
36168 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36169 wxPyEndAllowThreads(__tstate);
36170 if (PyErr_Occurred()) SWIG_fail;
36171 }
36172 {
36173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36174 }
36175 return resultobj;
36176 fail:
36177 return NULL;
36178 }
36179
36180
36181 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36182 PyObject *resultobj = 0;
36183 wxWindow *arg1 = (wxWindow *) 0 ;
36184 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36185 bool result;
36186 void *argp1 = 0 ;
36187 int res1 = 0 ;
36188 int val2 ;
36189 int ecode2 = 0 ;
36190 PyObject * obj0 = 0 ;
36191 PyObject * obj1 = 0 ;
36192 char * kwnames[] = {
36193 (char *) "self",(char *) "flags", NULL
36194 };
36195
36196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36198 if (!SWIG_IsOK(res1)) {
36199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36200 }
36201 arg1 = reinterpret_cast< wxWindow * >(argp1);
36202 if (obj1) {
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 }
36209 {
36210 PyThreadState* __tstate = wxPyBeginAllowThreads();
36211 result = (bool)(arg1)->Navigate(arg2);
36212 wxPyEndAllowThreads(__tstate);
36213 if (PyErr_Occurred()) SWIG_fail;
36214 }
36215 {
36216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36217 }
36218 return resultobj;
36219 fail:
36220 return NULL;
36221 }
36222
36223
36224 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36225 PyObject *resultobj = 0;
36226 wxWindow *arg1 = (wxWindow *) 0 ;
36227 wxWindow *arg2 = (wxWindow *) 0 ;
36228 void *argp1 = 0 ;
36229 int res1 = 0 ;
36230 void *argp2 = 0 ;
36231 int res2 = 0 ;
36232 PyObject * obj0 = 0 ;
36233 PyObject * obj1 = 0 ;
36234 char * kwnames[] = {
36235 (char *) "self",(char *) "win", NULL
36236 };
36237
36238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36240 if (!SWIG_IsOK(res1)) {
36241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36242 }
36243 arg1 = reinterpret_cast< wxWindow * >(argp1);
36244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36245 if (!SWIG_IsOK(res2)) {
36246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36247 }
36248 arg2 = reinterpret_cast< wxWindow * >(argp2);
36249 {
36250 PyThreadState* __tstate = wxPyBeginAllowThreads();
36251 (arg1)->MoveAfterInTabOrder(arg2);
36252 wxPyEndAllowThreads(__tstate);
36253 if (PyErr_Occurred()) SWIG_fail;
36254 }
36255 resultobj = SWIG_Py_Void();
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 wxWindow *arg2 = (wxWindow *) 0 ;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 void *argp2 = 0 ;
36269 int res2 = 0 ;
36270 PyObject * obj0 = 0 ;
36271 PyObject * obj1 = 0 ;
36272 char * kwnames[] = {
36273 (char *) "self",(char *) "win", NULL
36274 };
36275
36276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36278 if (!SWIG_IsOK(res1)) {
36279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36280 }
36281 arg1 = reinterpret_cast< wxWindow * >(argp1);
36282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36283 if (!SWIG_IsOK(res2)) {
36284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36285 }
36286 arg2 = reinterpret_cast< wxWindow * >(argp2);
36287 {
36288 PyThreadState* __tstate = wxPyBeginAllowThreads();
36289 (arg1)->MoveBeforeInTabOrder(arg2);
36290 wxPyEndAllowThreads(__tstate);
36291 if (PyErr_Occurred()) SWIG_fail;
36292 }
36293 resultobj = SWIG_Py_Void();
36294 return resultobj;
36295 fail:
36296 return NULL;
36297 }
36298
36299
36300 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36301 PyObject *resultobj = 0;
36302 wxWindow *arg1 = (wxWindow *) 0 ;
36303 PyObject *result = 0 ;
36304 void *argp1 = 0 ;
36305 int res1 = 0 ;
36306 PyObject *swig_obj[1] ;
36307
36308 if (!args) SWIG_fail;
36309 swig_obj[0] = args;
36310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36311 if (!SWIG_IsOK(res1)) {
36312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36313 }
36314 arg1 = reinterpret_cast< wxWindow * >(argp1);
36315 {
36316 PyThreadState* __tstate = wxPyBeginAllowThreads();
36317 result = (PyObject *)wxWindow_GetChildren(arg1);
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 resultobj = result;
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 PyObject *resultobj = 0;
36330 wxWindow *arg1 = (wxWindow *) 0 ;
36331 wxWindow *result = 0 ;
36332 void *argp1 = 0 ;
36333 int res1 = 0 ;
36334 PyObject *swig_obj[1] ;
36335
36336 if (!args) SWIG_fail;
36337 swig_obj[0] = args;
36338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36339 if (!SWIG_IsOK(res1)) {
36340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36341 }
36342 arg1 = reinterpret_cast< wxWindow * >(argp1);
36343 {
36344 PyThreadState* __tstate = wxPyBeginAllowThreads();
36345 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 {
36350 resultobj = wxPyMake_wxObject(result, 0);
36351 }
36352 return resultobj;
36353 fail:
36354 return NULL;
36355 }
36356
36357
36358 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36359 PyObject *resultobj = 0;
36360 wxWindow *arg1 = (wxWindow *) 0 ;
36361 wxWindow *result = 0 ;
36362 void *argp1 = 0 ;
36363 int res1 = 0 ;
36364 PyObject *swig_obj[1] ;
36365
36366 if (!args) SWIG_fail;
36367 swig_obj[0] = args;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36371 }
36372 arg1 = reinterpret_cast< wxWindow * >(argp1);
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36376 wxPyEndAllowThreads(__tstate);
36377 if (PyErr_Occurred()) SWIG_fail;
36378 }
36379 {
36380 resultobj = wxPyMake_wxObject(result, 0);
36381 }
36382 return resultobj;
36383 fail:
36384 return NULL;
36385 }
36386
36387
36388 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36389 PyObject *resultobj = 0;
36390 wxWindow *arg1 = (wxWindow *) 0 ;
36391 bool result;
36392 void *argp1 = 0 ;
36393 int res1 = 0 ;
36394 PyObject *swig_obj[1] ;
36395
36396 if (!args) SWIG_fail;
36397 swig_obj[0] = args;
36398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36399 if (!SWIG_IsOK(res1)) {
36400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36401 }
36402 arg1 = reinterpret_cast< wxWindow * >(argp1);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 {
36410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36411 }
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 wxWindow *arg2 = (wxWindow *) 0 ;
36422 bool result;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 void *argp2 = 0 ;
36426 int res2 = 0 ;
36427 PyObject * obj0 = 0 ;
36428 PyObject * obj1 = 0 ;
36429 char * kwnames[] = {
36430 (char *) "self",(char *) "newParent", NULL
36431 };
36432
36433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36435 if (!SWIG_IsOK(res1)) {
36436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36437 }
36438 arg1 = reinterpret_cast< wxWindow * >(argp1);
36439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36440 if (!SWIG_IsOK(res2)) {
36441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36442 }
36443 arg2 = reinterpret_cast< wxWindow * >(argp2);
36444 {
36445 PyThreadState* __tstate = wxPyBeginAllowThreads();
36446 result = (bool)(arg1)->Reparent(arg2);
36447 wxPyEndAllowThreads(__tstate);
36448 if (PyErr_Occurred()) SWIG_fail;
36449 }
36450 {
36451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36452 }
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 wxWindow *arg2 = (wxWindow *) 0 ;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 void *argp2 = 0 ;
36466 int res2 = 0 ;
36467 PyObject * obj0 = 0 ;
36468 PyObject * obj1 = 0 ;
36469 char * kwnames[] = {
36470 (char *) "self",(char *) "child", NULL
36471 };
36472
36473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36475 if (!SWIG_IsOK(res1)) {
36476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36477 }
36478 arg1 = reinterpret_cast< wxWindow * >(argp1);
36479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36480 if (!SWIG_IsOK(res2)) {
36481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36482 }
36483 arg2 = reinterpret_cast< wxWindow * >(argp2);
36484 {
36485 PyThreadState* __tstate = wxPyBeginAllowThreads();
36486 (arg1)->AddChild(arg2);
36487 wxPyEndAllowThreads(__tstate);
36488 if (PyErr_Occurred()) SWIG_fail;
36489 }
36490 resultobj = SWIG_Py_Void();
36491 return resultobj;
36492 fail:
36493 return NULL;
36494 }
36495
36496
36497 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36498 PyObject *resultobj = 0;
36499 wxWindow *arg1 = (wxWindow *) 0 ;
36500 wxWindow *arg2 = (wxWindow *) 0 ;
36501 void *argp1 = 0 ;
36502 int res1 = 0 ;
36503 void *argp2 = 0 ;
36504 int res2 = 0 ;
36505 PyObject * obj0 = 0 ;
36506 PyObject * obj1 = 0 ;
36507 char * kwnames[] = {
36508 (char *) "self",(char *) "child", NULL
36509 };
36510
36511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36513 if (!SWIG_IsOK(res1)) {
36514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36515 }
36516 arg1 = reinterpret_cast< wxWindow * >(argp1);
36517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36518 if (!SWIG_IsOK(res2)) {
36519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36520 }
36521 arg2 = reinterpret_cast< wxWindow * >(argp2);
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 (arg1)->RemoveChild(arg2);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 resultobj = SWIG_Py_Void();
36529 return resultobj;
36530 fail:
36531 return NULL;
36532 }
36533
36534
36535 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36536 PyObject *resultobj = 0;
36537 wxWindow *arg1 = (wxWindow *) 0 ;
36538 bool arg2 ;
36539 void *argp1 = 0 ;
36540 int res1 = 0 ;
36541 bool val2 ;
36542 int ecode2 = 0 ;
36543 PyObject * obj0 = 0 ;
36544 PyObject * obj1 = 0 ;
36545 char * kwnames[] = {
36546 (char *) "self",(char *) "on", NULL
36547 };
36548
36549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36551 if (!SWIG_IsOK(res1)) {
36552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36553 }
36554 arg1 = reinterpret_cast< wxWindow * >(argp1);
36555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36556 if (!SWIG_IsOK(ecode2)) {
36557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36558 }
36559 arg2 = static_cast< bool >(val2);
36560 {
36561 PyThreadState* __tstate = wxPyBeginAllowThreads();
36562 wxWindow_SetDoubleBuffered(arg1,arg2);
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 resultobj = SWIG_Py_Void();
36567 return resultobj;
36568 fail:
36569 return NULL;
36570 }
36571
36572
36573 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36574 PyObject *resultobj = 0;
36575 wxWindow *arg1 = (wxWindow *) 0 ;
36576 long arg2 ;
36577 wxWindow *result = 0 ;
36578 void *argp1 = 0 ;
36579 int res1 = 0 ;
36580 long val2 ;
36581 int ecode2 = 0 ;
36582 PyObject * obj0 = 0 ;
36583 PyObject * obj1 = 0 ;
36584 char * kwnames[] = {
36585 (char *) "self",(char *) "winid", NULL
36586 };
36587
36588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36592 }
36593 arg1 = reinterpret_cast< wxWindow * >(argp1);
36594 ecode2 = SWIG_AsVal_long(obj1, &val2);
36595 if (!SWIG_IsOK(ecode2)) {
36596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36597 }
36598 arg2 = static_cast< long >(val2);
36599 {
36600 PyThreadState* __tstate = wxPyBeginAllowThreads();
36601 result = (wxWindow *)(arg1)->FindWindow(arg2);
36602 wxPyEndAllowThreads(__tstate);
36603 if (PyErr_Occurred()) SWIG_fail;
36604 }
36605 {
36606 resultobj = wxPyMake_wxObject(result, 0);
36607 }
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36615 PyObject *resultobj = 0;
36616 wxWindow *arg1 = (wxWindow *) 0 ;
36617 wxString *arg2 = 0 ;
36618 wxWindow *result = 0 ;
36619 void *argp1 = 0 ;
36620 int res1 = 0 ;
36621 bool temp2 = false ;
36622 PyObject * obj0 = 0 ;
36623 PyObject * obj1 = 0 ;
36624 char * kwnames[] = {
36625 (char *) "self",(char *) "name", NULL
36626 };
36627
36628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36630 if (!SWIG_IsOK(res1)) {
36631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36632 }
36633 arg1 = reinterpret_cast< wxWindow * >(argp1);
36634 {
36635 arg2 = wxString_in_helper(obj1);
36636 if (arg2 == NULL) SWIG_fail;
36637 temp2 = true;
36638 }
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 {
36646 resultobj = wxPyMake_wxObject(result, 0);
36647 }
36648 {
36649 if (temp2)
36650 delete arg2;
36651 }
36652 return resultobj;
36653 fail:
36654 {
36655 if (temp2)
36656 delete arg2;
36657 }
36658 return NULL;
36659 }
36660
36661
36662 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36663 PyObject *resultobj = 0;
36664 wxWindow *arg1 = (wxWindow *) 0 ;
36665 wxEvtHandler *result = 0 ;
36666 void *argp1 = 0 ;
36667 int res1 = 0 ;
36668 PyObject *swig_obj[1] ;
36669
36670 if (!args) SWIG_fail;
36671 swig_obj[0] = args;
36672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36673 if (!SWIG_IsOK(res1)) {
36674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36675 }
36676 arg1 = reinterpret_cast< wxWindow * >(argp1);
36677 {
36678 PyThreadState* __tstate = wxPyBeginAllowThreads();
36679 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 {
36684 resultobj = wxPyMake_wxObject(result, 0);
36685 }
36686 return resultobj;
36687 fail:
36688 return NULL;
36689 }
36690
36691
36692 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36693 PyObject *resultobj = 0;
36694 wxWindow *arg1 = (wxWindow *) 0 ;
36695 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36696 void *argp1 = 0 ;
36697 int res1 = 0 ;
36698 void *argp2 = 0 ;
36699 int res2 = 0 ;
36700 PyObject * obj0 = 0 ;
36701 PyObject * obj1 = 0 ;
36702 char * kwnames[] = {
36703 (char *) "self",(char *) "handler", NULL
36704 };
36705
36706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36708 if (!SWIG_IsOK(res1)) {
36709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36710 }
36711 arg1 = reinterpret_cast< wxWindow * >(argp1);
36712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36713 if (!SWIG_IsOK(res2)) {
36714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36715 }
36716 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 (arg1)->SetEventHandler(arg2);
36720 wxPyEndAllowThreads(__tstate);
36721 if (PyErr_Occurred()) SWIG_fail;
36722 }
36723 resultobj = SWIG_Py_Void();
36724 return resultobj;
36725 fail:
36726 return NULL;
36727 }
36728
36729
36730 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36731 PyObject *resultobj = 0;
36732 wxWindow *arg1 = (wxWindow *) 0 ;
36733 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36734 void *argp1 = 0 ;
36735 int res1 = 0 ;
36736 void *argp2 = 0 ;
36737 int res2 = 0 ;
36738 PyObject * obj0 = 0 ;
36739 PyObject * obj1 = 0 ;
36740 char * kwnames[] = {
36741 (char *) "self",(char *) "handler", NULL
36742 };
36743
36744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36748 }
36749 arg1 = reinterpret_cast< wxWindow * >(argp1);
36750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36751 if (!SWIG_IsOK(res2)) {
36752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36753 }
36754 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 (arg1)->PushEventHandler(arg2);
36758 wxPyEndAllowThreads(__tstate);
36759 if (PyErr_Occurred()) SWIG_fail;
36760 }
36761 resultobj = SWIG_Py_Void();
36762 return resultobj;
36763 fail:
36764 return NULL;
36765 }
36766
36767
36768 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36769 PyObject *resultobj = 0;
36770 wxWindow *arg1 = (wxWindow *) 0 ;
36771 bool arg2 = (bool) false ;
36772 wxEvtHandler *result = 0 ;
36773 void *argp1 = 0 ;
36774 int res1 = 0 ;
36775 bool val2 ;
36776 int ecode2 = 0 ;
36777 PyObject * obj0 = 0 ;
36778 PyObject * obj1 = 0 ;
36779 char * kwnames[] = {
36780 (char *) "self",(char *) "deleteHandler", NULL
36781 };
36782
36783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36785 if (!SWIG_IsOK(res1)) {
36786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36787 }
36788 arg1 = reinterpret_cast< wxWindow * >(argp1);
36789 if (obj1) {
36790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36791 if (!SWIG_IsOK(ecode2)) {
36792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36793 }
36794 arg2 = static_cast< bool >(val2);
36795 }
36796 {
36797 PyThreadState* __tstate = wxPyBeginAllowThreads();
36798 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36799 wxPyEndAllowThreads(__tstate);
36800 if (PyErr_Occurred()) SWIG_fail;
36801 }
36802 {
36803 resultobj = wxPyMake_wxObject(result, 0);
36804 }
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36812 PyObject *resultobj = 0;
36813 wxWindow *arg1 = (wxWindow *) 0 ;
36814 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36815 bool result;
36816 void *argp1 = 0 ;
36817 int res1 = 0 ;
36818 void *argp2 = 0 ;
36819 int res2 = 0 ;
36820 PyObject * obj0 = 0 ;
36821 PyObject * obj1 = 0 ;
36822 char * kwnames[] = {
36823 (char *) "self",(char *) "handler", NULL
36824 };
36825
36826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36828 if (!SWIG_IsOK(res1)) {
36829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36830 }
36831 arg1 = reinterpret_cast< wxWindow * >(argp1);
36832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36833 if (!SWIG_IsOK(res2)) {
36834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36835 }
36836 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36837 {
36838 PyThreadState* __tstate = wxPyBeginAllowThreads();
36839 result = (bool)(arg1)->RemoveEventHandler(arg2);
36840 wxPyEndAllowThreads(__tstate);
36841 if (PyErr_Occurred()) SWIG_fail;
36842 }
36843 {
36844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36845 }
36846 return resultobj;
36847 fail:
36848 return NULL;
36849 }
36850
36851
36852 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj = 0;
36854 wxWindow *arg1 = (wxWindow *) 0 ;
36855 wxValidator *arg2 = 0 ;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 void *argp2 = 0 ;
36859 int res2 = 0 ;
36860 PyObject * obj0 = 0 ;
36861 PyObject * obj1 = 0 ;
36862 char * kwnames[] = {
36863 (char *) "self",(char *) "validator", NULL
36864 };
36865
36866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36868 if (!SWIG_IsOK(res1)) {
36869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36870 }
36871 arg1 = reinterpret_cast< wxWindow * >(argp1);
36872 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36873 if (!SWIG_IsOK(res2)) {
36874 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36875 }
36876 if (!argp2) {
36877 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36878 }
36879 arg2 = reinterpret_cast< wxValidator * >(argp2);
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 (arg1)->SetValidator((wxValidator const &)*arg2);
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 resultobj = SWIG_Py_Void();
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36894 PyObject *resultobj = 0;
36895 wxWindow *arg1 = (wxWindow *) 0 ;
36896 wxValidator *result = 0 ;
36897 void *argp1 = 0 ;
36898 int res1 = 0 ;
36899 PyObject *swig_obj[1] ;
36900
36901 if (!args) SWIG_fail;
36902 swig_obj[0] = args;
36903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36904 if (!SWIG_IsOK(res1)) {
36905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36906 }
36907 arg1 = reinterpret_cast< wxWindow * >(argp1);
36908 {
36909 PyThreadState* __tstate = wxPyBeginAllowThreads();
36910 result = (wxValidator *)(arg1)->GetValidator();
36911 wxPyEndAllowThreads(__tstate);
36912 if (PyErr_Occurred()) SWIG_fail;
36913 }
36914 {
36915 resultobj = wxPyMake_wxObject(result, (bool)0);
36916 }
36917 return resultobj;
36918 fail:
36919 return NULL;
36920 }
36921
36922
36923 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36924 PyObject *resultobj = 0;
36925 wxWindow *arg1 = (wxWindow *) 0 ;
36926 bool result;
36927 void *argp1 = 0 ;
36928 int res1 = 0 ;
36929 PyObject *swig_obj[1] ;
36930
36931 if (!args) SWIG_fail;
36932 swig_obj[0] = args;
36933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36934 if (!SWIG_IsOK(res1)) {
36935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36936 }
36937 arg1 = reinterpret_cast< wxWindow * >(argp1);
36938 {
36939 PyThreadState* __tstate = wxPyBeginAllowThreads();
36940 result = (bool)(arg1)->Validate();
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 {
36945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36954 PyObject *resultobj = 0;
36955 wxWindow *arg1 = (wxWindow *) 0 ;
36956 bool result;
36957 void *argp1 = 0 ;
36958 int res1 = 0 ;
36959 PyObject *swig_obj[1] ;
36960
36961 if (!args) SWIG_fail;
36962 swig_obj[0] = args;
36963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36964 if (!SWIG_IsOK(res1)) {
36965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36966 }
36967 arg1 = reinterpret_cast< wxWindow * >(argp1);
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 result = (bool)(arg1)->TransferDataToWindow();
36971 wxPyEndAllowThreads(__tstate);
36972 if (PyErr_Occurred()) SWIG_fail;
36973 }
36974 {
36975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36976 }
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36984 PyObject *resultobj = 0;
36985 wxWindow *arg1 = (wxWindow *) 0 ;
36986 bool result;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 PyObject *swig_obj[1] ;
36990
36991 if (!args) SWIG_fail;
36992 swig_obj[0] = args;
36993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36996 }
36997 arg1 = reinterpret_cast< wxWindow * >(argp1);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (bool)(arg1)->TransferDataFromWindow();
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 {
37005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37006 }
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37014 PyObject *resultobj = 0;
37015 wxWindow *arg1 = (wxWindow *) 0 ;
37016 void *argp1 = 0 ;
37017 int res1 = 0 ;
37018 PyObject *swig_obj[1] ;
37019
37020 if (!args) SWIG_fail;
37021 swig_obj[0] = args;
37022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37023 if (!SWIG_IsOK(res1)) {
37024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37025 }
37026 arg1 = reinterpret_cast< wxWindow * >(argp1);
37027 {
37028 PyThreadState* __tstate = wxPyBeginAllowThreads();
37029 (arg1)->InitDialog();
37030 wxPyEndAllowThreads(__tstate);
37031 if (PyErr_Occurred()) SWIG_fail;
37032 }
37033 resultobj = SWIG_Py_Void();
37034 return resultobj;
37035 fail:
37036 return NULL;
37037 }
37038
37039
37040 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37041 PyObject *resultobj = 0;
37042 wxWindow *arg1 = (wxWindow *) 0 ;
37043 wxAcceleratorTable *arg2 = 0 ;
37044 void *argp1 = 0 ;
37045 int res1 = 0 ;
37046 void *argp2 = 0 ;
37047 int res2 = 0 ;
37048 PyObject * obj0 = 0 ;
37049 PyObject * obj1 = 0 ;
37050 char * kwnames[] = {
37051 (char *) "self",(char *) "accel", NULL
37052 };
37053
37054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37056 if (!SWIG_IsOK(res1)) {
37057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37058 }
37059 arg1 = reinterpret_cast< wxWindow * >(argp1);
37060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37061 if (!SWIG_IsOK(res2)) {
37062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37063 }
37064 if (!argp2) {
37065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37066 }
37067 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 resultobj = SWIG_Py_Void();
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37082 PyObject *resultobj = 0;
37083 wxWindow *arg1 = (wxWindow *) 0 ;
37084 wxAcceleratorTable *result = 0 ;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 PyObject *swig_obj[1] ;
37088
37089 if (!args) SWIG_fail;
37090 swig_obj[0] = args;
37091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37092 if (!SWIG_IsOK(res1)) {
37093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37094 }
37095 arg1 = reinterpret_cast< wxWindow * >(argp1);
37096 {
37097 PyThreadState* __tstate = wxPyBeginAllowThreads();
37098 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 int arg2 ;
37113 int arg3 ;
37114 int arg4 ;
37115 bool result;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 int val2 ;
37119 int ecode2 = 0 ;
37120 int val3 ;
37121 int ecode3 = 0 ;
37122 int val4 ;
37123 int ecode4 = 0 ;
37124 PyObject * obj0 = 0 ;
37125 PyObject * obj1 = 0 ;
37126 PyObject * obj2 = 0 ;
37127 PyObject * obj3 = 0 ;
37128 char * kwnames[] = {
37129 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37130 };
37131
37132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37136 }
37137 arg1 = reinterpret_cast< wxWindow * >(argp1);
37138 ecode2 = SWIG_AsVal_int(obj1, &val2);
37139 if (!SWIG_IsOK(ecode2)) {
37140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37141 }
37142 arg2 = static_cast< int >(val2);
37143 ecode3 = SWIG_AsVal_int(obj2, &val3);
37144 if (!SWIG_IsOK(ecode3)) {
37145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37146 }
37147 arg3 = static_cast< int >(val3);
37148 ecode4 = SWIG_AsVal_int(obj3, &val4);
37149 if (!SWIG_IsOK(ecode4)) {
37150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37151 }
37152 arg4 = static_cast< int >(val4);
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37161 }
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 int arg2 ;
37172 bool result;
37173 void *argp1 = 0 ;
37174 int res1 = 0 ;
37175 int val2 ;
37176 int ecode2 = 0 ;
37177 PyObject * obj0 = 0 ;
37178 PyObject * obj1 = 0 ;
37179 char * kwnames[] = {
37180 (char *) "self",(char *) "hotkeyId", NULL
37181 };
37182
37183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37185 if (!SWIG_IsOK(res1)) {
37186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37187 }
37188 arg1 = reinterpret_cast< wxWindow * >(argp1);
37189 ecode2 = SWIG_AsVal_int(obj1, &val2);
37190 if (!SWIG_IsOK(ecode2)) {
37191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37192 }
37193 arg2 = static_cast< int >(val2);
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37202 }
37203 return resultobj;
37204 fail:
37205 return NULL;
37206 }
37207
37208
37209 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37210 PyObject *resultobj = 0;
37211 wxWindow *arg1 = (wxWindow *) 0 ;
37212 wxPoint *arg2 = 0 ;
37213 wxPoint result;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 wxPoint temp2 ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "pt", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 {
37230 arg2 = &temp2;
37231 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37232 }
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37236 wxPyEndAllowThreads(__tstate);
37237 if (PyErr_Occurred()) SWIG_fail;
37238 }
37239 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 wxSize *arg2 = 0 ;
37250 wxSize result;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 wxSize temp2 ;
37254 PyObject * obj0 = 0 ;
37255 PyObject * obj1 = 0 ;
37256 char * kwnames[] = {
37257 (char *) "self",(char *) "sz", NULL
37258 };
37259
37260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37264 }
37265 arg1 = reinterpret_cast< wxWindow * >(argp1);
37266 {
37267 arg2 = &temp2;
37268 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37269 }
37270 {
37271 PyThreadState* __tstate = wxPyBeginAllowThreads();
37272 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37273 wxPyEndAllowThreads(__tstate);
37274 if (PyErr_Occurred()) SWIG_fail;
37275 }
37276 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37277 return resultobj;
37278 fail:
37279 return NULL;
37280 }
37281
37282
37283 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37284 PyObject *resultobj = 0;
37285 wxWindow *arg1 = (wxWindow *) 0 ;
37286 wxPoint *arg2 = 0 ;
37287 wxPoint result;
37288 void *argp1 = 0 ;
37289 int res1 = 0 ;
37290 wxPoint temp2 ;
37291 PyObject * obj0 = 0 ;
37292 PyObject * obj1 = 0 ;
37293 char * kwnames[] = {
37294 (char *) "self",(char *) "pt", NULL
37295 };
37296
37297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 {
37304 arg2 = &temp2;
37305 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37306 }
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37310 wxPyEndAllowThreads(__tstate);
37311 if (PyErr_Occurred()) SWIG_fail;
37312 }
37313 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37314 return resultobj;
37315 fail:
37316 return NULL;
37317 }
37318
37319
37320 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37321 PyObject *resultobj = 0;
37322 wxWindow *arg1 = (wxWindow *) 0 ;
37323 wxSize *arg2 = 0 ;
37324 wxSize result;
37325 void *argp1 = 0 ;
37326 int res1 = 0 ;
37327 wxSize temp2 ;
37328 PyObject * obj0 = 0 ;
37329 PyObject * obj1 = 0 ;
37330 char * kwnames[] = {
37331 (char *) "self",(char *) "sz", NULL
37332 };
37333
37334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37336 if (!SWIG_IsOK(res1)) {
37337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37338 }
37339 arg1 = reinterpret_cast< wxWindow * >(argp1);
37340 {
37341 arg2 = &temp2;
37342 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37343 }
37344 {
37345 PyThreadState* __tstate = wxPyBeginAllowThreads();
37346 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37358 PyObject *resultobj = 0;
37359 wxWindow *arg1 = (wxWindow *) 0 ;
37360 wxPoint *arg2 = 0 ;
37361 wxPoint result;
37362 void *argp1 = 0 ;
37363 int res1 = 0 ;
37364 wxPoint temp2 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 char * kwnames[] = {
37368 (char *) "self",(char *) "pt", NULL
37369 };
37370
37371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37373 if (!SWIG_IsOK(res1)) {
37374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37375 }
37376 arg1 = reinterpret_cast< wxWindow * >(argp1);
37377 {
37378 arg2 = &temp2;
37379 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37380 }
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 wxSize *arg2 = 0 ;
37398 wxSize result;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 wxSize temp2 ;
37402 PyObject * obj0 = 0 ;
37403 PyObject * obj1 = 0 ;
37404 char * kwnames[] = {
37405 (char *) "self",(char *) "sz", NULL
37406 };
37407
37408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 {
37415 arg2 = &temp2;
37416 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37417 }
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37425 return resultobj;
37426 fail:
37427 return NULL;
37428 }
37429
37430
37431 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37432 PyObject *resultobj = 0;
37433 wxWindow *arg1 = (wxWindow *) 0 ;
37434 int arg2 ;
37435 int arg3 ;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 int val2 ;
37439 int ecode2 = 0 ;
37440 int val3 ;
37441 int ecode3 = 0 ;
37442 PyObject * obj0 = 0 ;
37443 PyObject * obj1 = 0 ;
37444 PyObject * obj2 = 0 ;
37445 char * kwnames[] = {
37446 (char *) "self",(char *) "x",(char *) "y", NULL
37447 };
37448
37449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37451 if (!SWIG_IsOK(res1)) {
37452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37453 }
37454 arg1 = reinterpret_cast< wxWindow * >(argp1);
37455 ecode2 = SWIG_AsVal_int(obj1, &val2);
37456 if (!SWIG_IsOK(ecode2)) {
37457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37458 }
37459 arg2 = static_cast< int >(val2);
37460 ecode3 = SWIG_AsVal_int(obj2, &val3);
37461 if (!SWIG_IsOK(ecode3)) {
37462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37463 }
37464 arg3 = static_cast< int >(val3);
37465 {
37466 PyThreadState* __tstate = wxPyBeginAllowThreads();
37467 (arg1)->WarpPointer(arg2,arg3);
37468 wxPyEndAllowThreads(__tstate);
37469 if (PyErr_Occurred()) SWIG_fail;
37470 }
37471 resultobj = SWIG_Py_Void();
37472 return resultobj;
37473 fail:
37474 return NULL;
37475 }
37476
37477
37478 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37479 PyObject *resultobj = 0;
37480 wxWindow *arg1 = (wxWindow *) 0 ;
37481 void *argp1 = 0 ;
37482 int res1 = 0 ;
37483 PyObject *swig_obj[1] ;
37484
37485 if (!args) SWIG_fail;
37486 swig_obj[0] = args;
37487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37488 if (!SWIG_IsOK(res1)) {
37489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37490 }
37491 arg1 = reinterpret_cast< wxWindow * >(argp1);
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 (arg1)->CaptureMouse();
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 resultobj = SWIG_Py_Void();
37499 return resultobj;
37500 fail:
37501 return NULL;
37502 }
37503
37504
37505 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37506 PyObject *resultobj = 0;
37507 wxWindow *arg1 = (wxWindow *) 0 ;
37508 void *argp1 = 0 ;
37509 int res1 = 0 ;
37510 PyObject *swig_obj[1] ;
37511
37512 if (!args) SWIG_fail;
37513 swig_obj[0] = args;
37514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37515 if (!SWIG_IsOK(res1)) {
37516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37517 }
37518 arg1 = reinterpret_cast< wxWindow * >(argp1);
37519 {
37520 PyThreadState* __tstate = wxPyBeginAllowThreads();
37521 (arg1)->ReleaseMouse();
37522 wxPyEndAllowThreads(__tstate);
37523 if (PyErr_Occurred()) SWIG_fail;
37524 }
37525 resultobj = SWIG_Py_Void();
37526 return resultobj;
37527 fail:
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37533 PyObject *resultobj = 0;
37534 wxWindow *result = 0 ;
37535
37536 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37537 {
37538 if (!wxPyCheckForApp()) SWIG_fail;
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 result = (wxWindow *)wxWindow::GetCapture();
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 {
37545 resultobj = wxPyMake_wxObject(result, 0);
37546 }
37547 return resultobj;
37548 fail:
37549 return NULL;
37550 }
37551
37552
37553 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37554 PyObject *resultobj = 0;
37555 wxWindow *arg1 = (wxWindow *) 0 ;
37556 bool result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 PyObject *swig_obj[1] ;
37560
37561 if (!args) SWIG_fail;
37562 swig_obj[0] = args;
37563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37564 if (!SWIG_IsOK(res1)) {
37565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37566 }
37567 arg1 = reinterpret_cast< wxWindow * >(argp1);
37568 {
37569 PyThreadState* __tstate = wxPyBeginAllowThreads();
37570 result = (bool)((wxWindow const *)arg1)->HasCapture();
37571 wxPyEndAllowThreads(__tstate);
37572 if (PyErr_Occurred()) SWIG_fail;
37573 }
37574 {
37575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37576 }
37577 return resultobj;
37578 fail:
37579 return NULL;
37580 }
37581
37582
37583 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj = 0;
37585 wxWindow *arg1 = (wxWindow *) 0 ;
37586 bool arg2 = (bool) true ;
37587 wxRect *arg3 = (wxRect *) NULL ;
37588 void *argp1 = 0 ;
37589 int res1 = 0 ;
37590 bool val2 ;
37591 int ecode2 = 0 ;
37592 void *argp3 = 0 ;
37593 int res3 = 0 ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 PyObject * obj2 = 0 ;
37597 char * kwnames[] = {
37598 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37599 };
37600
37601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37605 }
37606 arg1 = reinterpret_cast< wxWindow * >(argp1);
37607 if (obj1) {
37608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37609 if (!SWIG_IsOK(ecode2)) {
37610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37611 }
37612 arg2 = static_cast< bool >(val2);
37613 }
37614 if (obj2) {
37615 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37616 if (!SWIG_IsOK(res3)) {
37617 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37618 }
37619 arg3 = reinterpret_cast< wxRect * >(argp3);
37620 }
37621 {
37622 PyThreadState* __tstate = wxPyBeginAllowThreads();
37623 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 resultobj = SWIG_Py_Void();
37628 return resultobj;
37629 fail:
37630 return NULL;
37631 }
37632
37633
37634 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37635 PyObject *resultobj = 0;
37636 wxWindow *arg1 = (wxWindow *) 0 ;
37637 wxRect *arg2 = 0 ;
37638 bool arg3 = (bool) true ;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 wxRect temp2 ;
37642 bool val3 ;
37643 int ecode3 = 0 ;
37644 PyObject * obj0 = 0 ;
37645 PyObject * obj1 = 0 ;
37646 PyObject * obj2 = 0 ;
37647 char * kwnames[] = {
37648 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37649 };
37650
37651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37653 if (!SWIG_IsOK(res1)) {
37654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37655 }
37656 arg1 = reinterpret_cast< wxWindow * >(argp1);
37657 {
37658 arg2 = &temp2;
37659 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37660 }
37661 if (obj2) {
37662 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37663 if (!SWIG_IsOK(ecode3)) {
37664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37665 }
37666 arg3 = static_cast< bool >(val3);
37667 }
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37671 wxPyEndAllowThreads(__tstate);
37672 if (PyErr_Occurred()) SWIG_fail;
37673 }
37674 resultobj = SWIG_Py_Void();
37675 return resultobj;
37676 fail:
37677 return NULL;
37678 }
37679
37680
37681 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37682 PyObject *resultobj = 0;
37683 wxWindow *arg1 = (wxWindow *) 0 ;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 PyObject *swig_obj[1] ;
37687
37688 if (!args) SWIG_fail;
37689 swig_obj[0] = args;
37690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37691 if (!SWIG_IsOK(res1)) {
37692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37693 }
37694 arg1 = reinterpret_cast< wxWindow * >(argp1);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 (arg1)->Update();
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 resultobj = SWIG_Py_Void();
37702 return resultobj;
37703 fail:
37704 return NULL;
37705 }
37706
37707
37708 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37709 PyObject *resultobj = 0;
37710 wxWindow *arg1 = (wxWindow *) 0 ;
37711 void *argp1 = 0 ;
37712 int res1 = 0 ;
37713 PyObject *swig_obj[1] ;
37714
37715 if (!args) SWIG_fail;
37716 swig_obj[0] = args;
37717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37718 if (!SWIG_IsOK(res1)) {
37719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37720 }
37721 arg1 = reinterpret_cast< wxWindow * >(argp1);
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 (arg1)->ClearBackground();
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 resultobj = SWIG_Py_Void();
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37736 PyObject *resultobj = 0;
37737 wxWindow *arg1 = (wxWindow *) 0 ;
37738 void *argp1 = 0 ;
37739 int res1 = 0 ;
37740 PyObject *swig_obj[1] ;
37741
37742 if (!args) SWIG_fail;
37743 swig_obj[0] = args;
37744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37745 if (!SWIG_IsOK(res1)) {
37746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37747 }
37748 arg1 = reinterpret_cast< wxWindow * >(argp1);
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 (arg1)->Freeze();
37752 wxPyEndAllowThreads(__tstate);
37753 if (PyErr_Occurred()) SWIG_fail;
37754 }
37755 resultobj = SWIG_Py_Void();
37756 return resultobj;
37757 fail:
37758 return NULL;
37759 }
37760
37761
37762 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37763 PyObject *resultobj = 0;
37764 wxWindow *arg1 = (wxWindow *) 0 ;
37765 bool result;
37766 void *argp1 = 0 ;
37767 int res1 = 0 ;
37768 PyObject *swig_obj[1] ;
37769
37770 if (!args) SWIG_fail;
37771 swig_obj[0] = args;
37772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37773 if (!SWIG_IsOK(res1)) {
37774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37775 }
37776 arg1 = reinterpret_cast< wxWindow * >(argp1);
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37780 wxPyEndAllowThreads(__tstate);
37781 if (PyErr_Occurred()) SWIG_fail;
37782 }
37783 {
37784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37785 }
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37793 PyObject *resultobj = 0;
37794 wxWindow *arg1 = (wxWindow *) 0 ;
37795 void *argp1 = 0 ;
37796 int res1 = 0 ;
37797 PyObject *swig_obj[1] ;
37798
37799 if (!args) SWIG_fail;
37800 swig_obj[0] = args;
37801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37802 if (!SWIG_IsOK(res1)) {
37803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37804 }
37805 arg1 = reinterpret_cast< wxWindow * >(argp1);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 (arg1)->Thaw();
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 resultobj = SWIG_Py_Void();
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxWindow *arg1 = (wxWindow *) 0 ;
37822 wxDC *arg2 = 0 ;
37823 void *argp1 = 0 ;
37824 int res1 = 0 ;
37825 void *argp2 = 0 ;
37826 int res2 = 0 ;
37827 PyObject * obj0 = 0 ;
37828 PyObject * obj1 = 0 ;
37829 char * kwnames[] = {
37830 (char *) "self",(char *) "dc", NULL
37831 };
37832
37833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37840 if (!SWIG_IsOK(res2)) {
37841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37842 }
37843 if (!argp2) {
37844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37845 }
37846 arg2 = reinterpret_cast< wxDC * >(argp2);
37847 {
37848 PyThreadState* __tstate = wxPyBeginAllowThreads();
37849 (arg1)->PrepareDC(*arg2);
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 resultobj = SWIG_Py_Void();
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37861 PyObject *resultobj = 0;
37862 wxWindow *arg1 = (wxWindow *) 0 ;
37863 bool result;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 PyObject *swig_obj[1] ;
37867
37868 if (!args) SWIG_fail;
37869 swig_obj[0] = args;
37870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37871 if (!SWIG_IsOK(res1)) {
37872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37873 }
37874 arg1 = reinterpret_cast< wxWindow * >(argp1);
37875 {
37876 PyThreadState* __tstate = wxPyBeginAllowThreads();
37877 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37878 wxPyEndAllowThreads(__tstate);
37879 if (PyErr_Occurred()) SWIG_fail;
37880 }
37881 {
37882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37883 }
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxWindow *arg1 = (wxWindow *) 0 ;
37893 wxRegion *result = 0 ;
37894 void *argp1 = 0 ;
37895 int res1 = 0 ;
37896 PyObject *swig_obj[1] ;
37897
37898 if (!args) SWIG_fail;
37899 swig_obj[0] = args;
37900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37901 if (!SWIG_IsOK(res1)) {
37902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37903 }
37904 arg1 = reinterpret_cast< wxWindow * >(argp1);
37905 {
37906 PyThreadState* __tstate = wxPyBeginAllowThreads();
37907 {
37908 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37909 result = (wxRegion *) &_result_ref;
37910 }
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxWindow *arg1 = (wxWindow *) 0 ;
37924 wxRect result;
37925 void *argp1 = 0 ;
37926 int res1 = 0 ;
37927 PyObject *swig_obj[1] ;
37928
37929 if (!args) SWIG_fail;
37930 swig_obj[0] = args;
37931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37932 if (!SWIG_IsOK(res1)) {
37933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37934 }
37935 arg1 = reinterpret_cast< wxWindow * >(argp1);
37936 {
37937 PyThreadState* __tstate = wxPyBeginAllowThreads();
37938 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37943 return resultobj;
37944 fail:
37945 return NULL;
37946 }
37947
37948
37949 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37950 PyObject *resultobj = 0;
37951 wxWindow *arg1 = (wxWindow *) 0 ;
37952 int arg2 ;
37953 int arg3 ;
37954 int arg4 = (int) 1 ;
37955 int arg5 = (int) 1 ;
37956 bool result;
37957 void *argp1 = 0 ;
37958 int res1 = 0 ;
37959 int val2 ;
37960 int ecode2 = 0 ;
37961 int val3 ;
37962 int ecode3 = 0 ;
37963 int val4 ;
37964 int ecode4 = 0 ;
37965 int val5 ;
37966 int ecode5 = 0 ;
37967 PyObject * obj0 = 0 ;
37968 PyObject * obj1 = 0 ;
37969 PyObject * obj2 = 0 ;
37970 PyObject * obj3 = 0 ;
37971 PyObject * obj4 = 0 ;
37972 char * kwnames[] = {
37973 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37974 };
37975
37976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37978 if (!SWIG_IsOK(res1)) {
37979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37980 }
37981 arg1 = reinterpret_cast< wxWindow * >(argp1);
37982 ecode2 = SWIG_AsVal_int(obj1, &val2);
37983 if (!SWIG_IsOK(ecode2)) {
37984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37985 }
37986 arg2 = static_cast< int >(val2);
37987 ecode3 = SWIG_AsVal_int(obj2, &val3);
37988 if (!SWIG_IsOK(ecode3)) {
37989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37990 }
37991 arg3 = static_cast< int >(val3);
37992 if (obj3) {
37993 ecode4 = SWIG_AsVal_int(obj3, &val4);
37994 if (!SWIG_IsOK(ecode4)) {
37995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37996 }
37997 arg4 = static_cast< int >(val4);
37998 }
37999 if (obj4) {
38000 ecode5 = SWIG_AsVal_int(obj4, &val5);
38001 if (!SWIG_IsOK(ecode5)) {
38002 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38003 }
38004 arg5 = static_cast< int >(val5);
38005 }
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 {
38013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38014 }
38015 return resultobj;
38016 fail:
38017 return NULL;
38018 }
38019
38020
38021 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38022 PyObject *resultobj = 0;
38023 wxWindow *arg1 = (wxWindow *) 0 ;
38024 wxPoint *arg2 = 0 ;
38025 bool result;
38026 void *argp1 = 0 ;
38027 int res1 = 0 ;
38028 wxPoint temp2 ;
38029 PyObject * obj0 = 0 ;
38030 PyObject * obj1 = 0 ;
38031 char * kwnames[] = {
38032 (char *) "self",(char *) "pt", NULL
38033 };
38034
38035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38037 if (!SWIG_IsOK(res1)) {
38038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38039 }
38040 arg1 = reinterpret_cast< wxWindow * >(argp1);
38041 {
38042 arg2 = &temp2;
38043 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38044 }
38045 {
38046 PyThreadState* __tstate = wxPyBeginAllowThreads();
38047 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38048 wxPyEndAllowThreads(__tstate);
38049 if (PyErr_Occurred()) SWIG_fail;
38050 }
38051 {
38052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38053 }
38054 return resultobj;
38055 fail:
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxWindow *arg1 = (wxWindow *) 0 ;
38063 wxRect *arg2 = 0 ;
38064 bool result;
38065 void *argp1 = 0 ;
38066 int res1 = 0 ;
38067 wxRect temp2 ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 char * kwnames[] = {
38071 (char *) "self",(char *) "rect", NULL
38072 };
38073
38074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38078 }
38079 arg1 = reinterpret_cast< wxWindow * >(argp1);
38080 {
38081 arg2 = &temp2;
38082 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38083 }
38084 {
38085 PyThreadState* __tstate = wxPyBeginAllowThreads();
38086 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38087 wxPyEndAllowThreads(__tstate);
38088 if (PyErr_Occurred()) SWIG_fail;
38089 }
38090 {
38091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38092 }
38093 return resultobj;
38094 fail:
38095 return NULL;
38096 }
38097
38098
38099 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38100 PyObject *resultobj = 0;
38101 wxWindow *arg1 = (wxWindow *) 0 ;
38102 SwigValueWrapper<wxVisualAttributes > result;
38103 void *argp1 = 0 ;
38104 int res1 = 0 ;
38105 PyObject *swig_obj[1] ;
38106
38107 if (!args) SWIG_fail;
38108 swig_obj[0] = args;
38109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38112 }
38113 arg1 = reinterpret_cast< wxWindow * >(argp1);
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38121 return resultobj;
38122 fail:
38123 return NULL;
38124 }
38125
38126
38127 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38128 PyObject *resultobj = 0;
38129 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38130 SwigValueWrapper<wxVisualAttributes > result;
38131 int val1 ;
38132 int ecode1 = 0 ;
38133 PyObject * obj0 = 0 ;
38134 char * kwnames[] = {
38135 (char *) "variant", NULL
38136 };
38137
38138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38139 if (obj0) {
38140 ecode1 = SWIG_AsVal_int(obj0, &val1);
38141 if (!SWIG_IsOK(ecode1)) {
38142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38143 }
38144 arg1 = static_cast< wxWindowVariant >(val1);
38145 }
38146 {
38147 if (!wxPyCheckForApp()) SWIG_fail;
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 result = wxWindow::GetClassDefaultAttributes(arg1);
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38154 return resultobj;
38155 fail:
38156 return NULL;
38157 }
38158
38159
38160 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj = 0;
38162 wxWindow *arg1 = (wxWindow *) 0 ;
38163 wxColour *arg2 = 0 ;
38164 bool result;
38165 void *argp1 = 0 ;
38166 int res1 = 0 ;
38167 wxColour temp2 ;
38168 PyObject * obj0 = 0 ;
38169 PyObject * obj1 = 0 ;
38170 char * kwnames[] = {
38171 (char *) "self",(char *) "colour", NULL
38172 };
38173
38174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38176 if (!SWIG_IsOK(res1)) {
38177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38178 }
38179 arg1 = reinterpret_cast< wxWindow * >(argp1);
38180 {
38181 arg2 = &temp2;
38182 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38183 }
38184 {
38185 PyThreadState* __tstate = wxPyBeginAllowThreads();
38186 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38187 wxPyEndAllowThreads(__tstate);
38188 if (PyErr_Occurred()) SWIG_fail;
38189 }
38190 {
38191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38192 }
38193 return resultobj;
38194 fail:
38195 return NULL;
38196 }
38197
38198
38199 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38200 PyObject *resultobj = 0;
38201 wxWindow *arg1 = (wxWindow *) 0 ;
38202 wxColour *arg2 = 0 ;
38203 void *argp1 = 0 ;
38204 int res1 = 0 ;
38205 wxColour temp2 ;
38206 PyObject * obj0 = 0 ;
38207 PyObject * obj1 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "colour", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 arg2 = &temp2;
38220 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38221 }
38222 {
38223 PyThreadState* __tstate = wxPyBeginAllowThreads();
38224 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38225 wxPyEndAllowThreads(__tstate);
38226 if (PyErr_Occurred()) SWIG_fail;
38227 }
38228 resultobj = SWIG_Py_Void();
38229 return resultobj;
38230 fail:
38231 return NULL;
38232 }
38233
38234
38235 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38236 PyObject *resultobj = 0;
38237 wxWindow *arg1 = (wxWindow *) 0 ;
38238 wxColour *arg2 = 0 ;
38239 bool result;
38240 void *argp1 = 0 ;
38241 int res1 = 0 ;
38242 wxColour temp2 ;
38243 PyObject * obj0 = 0 ;
38244 PyObject * obj1 = 0 ;
38245 char * kwnames[] = {
38246 (char *) "self",(char *) "colour", NULL
38247 };
38248
38249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38251 if (!SWIG_IsOK(res1)) {
38252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38253 }
38254 arg1 = reinterpret_cast< wxWindow * >(argp1);
38255 {
38256 arg2 = &temp2;
38257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38258 }
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38262 wxPyEndAllowThreads(__tstate);
38263 if (PyErr_Occurred()) SWIG_fail;
38264 }
38265 {
38266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38267 }
38268 return resultobj;
38269 fail:
38270 return NULL;
38271 }
38272
38273
38274 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38275 PyObject *resultobj = 0;
38276 wxWindow *arg1 = (wxWindow *) 0 ;
38277 wxColour *arg2 = 0 ;
38278 void *argp1 = 0 ;
38279 int res1 = 0 ;
38280 wxColour temp2 ;
38281 PyObject * obj0 = 0 ;
38282 PyObject * obj1 = 0 ;
38283 char * kwnames[] = {
38284 (char *) "self",(char *) "colour", NULL
38285 };
38286
38287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38289 if (!SWIG_IsOK(res1)) {
38290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38291 }
38292 arg1 = reinterpret_cast< wxWindow * >(argp1);
38293 {
38294 arg2 = &temp2;
38295 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38296 }
38297 {
38298 PyThreadState* __tstate = wxPyBeginAllowThreads();
38299 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38300 wxPyEndAllowThreads(__tstate);
38301 if (PyErr_Occurred()) SWIG_fail;
38302 }
38303 resultobj = SWIG_Py_Void();
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38311 PyObject *resultobj = 0;
38312 wxWindow *arg1 = (wxWindow *) 0 ;
38313 wxColour result;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 PyObject *swig_obj[1] ;
38317
38318 if (!args) SWIG_fail;
38319 swig_obj[0] = args;
38320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxWindow * >(argp1);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38332 return resultobj;
38333 fail:
38334 return NULL;
38335 }
38336
38337
38338 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38339 PyObject *resultobj = 0;
38340 wxWindow *arg1 = (wxWindow *) 0 ;
38341 wxColour result;
38342 void *argp1 = 0 ;
38343 int res1 = 0 ;
38344 PyObject *swig_obj[1] ;
38345
38346 if (!args) SWIG_fail;
38347 swig_obj[0] = args;
38348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38349 if (!SWIG_IsOK(res1)) {
38350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38351 }
38352 arg1 = reinterpret_cast< wxWindow * >(argp1);
38353 {
38354 PyThreadState* __tstate = wxPyBeginAllowThreads();
38355 result = ((wxWindow const *)arg1)->GetForegroundColour();
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38360 return resultobj;
38361 fail:
38362 return NULL;
38363 }
38364
38365
38366 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38367 PyObject *resultobj = 0;
38368 wxWindow *arg1 = (wxWindow *) 0 ;
38369 bool result;
38370 void *argp1 = 0 ;
38371 int res1 = 0 ;
38372 PyObject *swig_obj[1] ;
38373
38374 if (!args) SWIG_fail;
38375 swig_obj[0] = args;
38376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38377 if (!SWIG_IsOK(res1)) {
38378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38379 }
38380 arg1 = reinterpret_cast< wxWindow * >(argp1);
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 {
38388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38389 }
38390 return resultobj;
38391 fail:
38392 return NULL;
38393 }
38394
38395
38396 SWIGINTERN PyObject *_wrap_Window_UseBgCol(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_UseBgCol" "', 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)->UseBgCol();
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_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38427 PyObject *resultobj = 0;
38428 wxWindow *arg1 = (wxWindow *) 0 ;
38429 wxBackgroundStyle arg2 ;
38430 bool result;
38431 void *argp1 = 0 ;
38432 int res1 = 0 ;
38433 int val2 ;
38434 int ecode2 = 0 ;
38435 PyObject * obj0 = 0 ;
38436 PyObject * obj1 = 0 ;
38437 char * kwnames[] = {
38438 (char *) "self",(char *) "style", NULL
38439 };
38440
38441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38443 if (!SWIG_IsOK(res1)) {
38444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38445 }
38446 arg1 = reinterpret_cast< wxWindow * >(argp1);
38447 ecode2 = SWIG_AsVal_int(obj1, &val2);
38448 if (!SWIG_IsOK(ecode2)) {
38449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38450 }
38451 arg2 = static_cast< wxBackgroundStyle >(val2);
38452 {
38453 PyThreadState* __tstate = wxPyBeginAllowThreads();
38454 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38455 wxPyEndAllowThreads(__tstate);
38456 if (PyErr_Occurred()) SWIG_fail;
38457 }
38458 {
38459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38460 }
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38468 PyObject *resultobj = 0;
38469 wxWindow *arg1 = (wxWindow *) 0 ;
38470 wxBackgroundStyle result;
38471 void *argp1 = 0 ;
38472 int res1 = 0 ;
38473 PyObject *swig_obj[1] ;
38474
38475 if (!args) SWIG_fail;
38476 swig_obj[0] = args;
38477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38478 if (!SWIG_IsOK(res1)) {
38479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38480 }
38481 arg1 = reinterpret_cast< wxWindow * >(argp1);
38482 {
38483 PyThreadState* __tstate = wxPyBeginAllowThreads();
38484 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 resultobj = SWIG_From_int(static_cast< int >(result));
38489 return resultobj;
38490 fail:
38491 return NULL;
38492 }
38493
38494
38495 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38496 PyObject *resultobj = 0;
38497 wxWindow *arg1 = (wxWindow *) 0 ;
38498 bool result;
38499 void *argp1 = 0 ;
38500 int res1 = 0 ;
38501 PyObject *swig_obj[1] ;
38502
38503 if (!args) SWIG_fail;
38504 swig_obj[0] = args;
38505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38506 if (!SWIG_IsOK(res1)) {
38507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38508 }
38509 arg1 = reinterpret_cast< wxWindow * >(argp1);
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 result = (bool)(arg1)->HasTransparentBackground();
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 {
38517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38518 }
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38526 PyObject *resultobj = 0;
38527 wxWindow *arg1 = (wxWindow *) 0 ;
38528 wxCursor *arg2 = 0 ;
38529 bool result;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 void *argp2 = 0 ;
38533 int res2 = 0 ;
38534 PyObject * obj0 = 0 ;
38535 PyObject * obj1 = 0 ;
38536 char * kwnames[] = {
38537 (char *) "self",(char *) "cursor", NULL
38538 };
38539
38540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38542 if (!SWIG_IsOK(res1)) {
38543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38544 }
38545 arg1 = reinterpret_cast< wxWindow * >(argp1);
38546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38547 if (!SWIG_IsOK(res2)) {
38548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38549 }
38550 if (!argp2) {
38551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38552 }
38553 arg2 = reinterpret_cast< wxCursor * >(argp2);
38554 {
38555 PyThreadState* __tstate = wxPyBeginAllowThreads();
38556 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 {
38561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38562 }
38563 return resultobj;
38564 fail:
38565 return NULL;
38566 }
38567
38568
38569 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38570 PyObject *resultobj = 0;
38571 wxWindow *arg1 = (wxWindow *) 0 ;
38572 wxCursor result;
38573 void *argp1 = 0 ;
38574 int res1 = 0 ;
38575 PyObject *swig_obj[1] ;
38576
38577 if (!args) SWIG_fail;
38578 swig_obj[0] = args;
38579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38580 if (!SWIG_IsOK(res1)) {
38581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38582 }
38583 arg1 = reinterpret_cast< wxWindow * >(argp1);
38584 {
38585 PyThreadState* __tstate = wxPyBeginAllowThreads();
38586 result = (arg1)->GetCursor();
38587 wxPyEndAllowThreads(__tstate);
38588 if (PyErr_Occurred()) SWIG_fail;
38589 }
38590 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38591 return resultobj;
38592 fail:
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38598 PyObject *resultobj = 0;
38599 wxWindow *arg1 = (wxWindow *) 0 ;
38600 wxFont *arg2 = 0 ;
38601 bool result;
38602 void *argp1 = 0 ;
38603 int res1 = 0 ;
38604 void *argp2 = 0 ;
38605 int res2 = 0 ;
38606 PyObject * obj0 = 0 ;
38607 PyObject * obj1 = 0 ;
38608 char * kwnames[] = {
38609 (char *) "self",(char *) "font", NULL
38610 };
38611
38612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38619 if (!SWIG_IsOK(res2)) {
38620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38621 }
38622 if (!argp2) {
38623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38624 }
38625 arg2 = reinterpret_cast< wxFont * >(argp2);
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38629 wxPyEndAllowThreads(__tstate);
38630 if (PyErr_Occurred()) SWIG_fail;
38631 }
38632 {
38633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38634 }
38635 return resultobj;
38636 fail:
38637 return NULL;
38638 }
38639
38640
38641 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38642 PyObject *resultobj = 0;
38643 wxWindow *arg1 = (wxWindow *) 0 ;
38644 wxFont *arg2 = 0 ;
38645 void *argp1 = 0 ;
38646 int res1 = 0 ;
38647 void *argp2 = 0 ;
38648 int res2 = 0 ;
38649 PyObject * obj0 = 0 ;
38650 PyObject * obj1 = 0 ;
38651 char * kwnames[] = {
38652 (char *) "self",(char *) "font", NULL
38653 };
38654
38655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38659 }
38660 arg1 = reinterpret_cast< wxWindow * >(argp1);
38661 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38662 if (!SWIG_IsOK(res2)) {
38663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38664 }
38665 if (!argp2) {
38666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38667 }
38668 arg2 = reinterpret_cast< wxFont * >(argp2);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 (arg1)->SetOwnFont((wxFont const &)*arg2);
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 resultobj = SWIG_Py_Void();
38676 return resultobj;
38677 fail:
38678 return NULL;
38679 }
38680
38681
38682 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38683 PyObject *resultobj = 0;
38684 wxWindow *arg1 = (wxWindow *) 0 ;
38685 wxFont result;
38686 void *argp1 = 0 ;
38687 int res1 = 0 ;
38688 PyObject *swig_obj[1] ;
38689
38690 if (!args) SWIG_fail;
38691 swig_obj[0] = args;
38692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38693 if (!SWIG_IsOK(res1)) {
38694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38695 }
38696 arg1 = reinterpret_cast< wxWindow * >(argp1);
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (arg1)->GetFont();
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj = 0;
38712 wxWindow *arg1 = (wxWindow *) 0 ;
38713 wxCaret *arg2 = (wxCaret *) 0 ;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 int res2 = 0 ;
38717 PyObject * obj0 = 0 ;
38718 PyObject * obj1 = 0 ;
38719 char * kwnames[] = {
38720 (char *) "self",(char *) "caret", NULL
38721 };
38722
38723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38727 }
38728 arg1 = reinterpret_cast< wxWindow * >(argp1);
38729 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38730 if (!SWIG_IsOK(res2)) {
38731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38732 }
38733 {
38734 PyThreadState* __tstate = wxPyBeginAllowThreads();
38735 (arg1)->SetCaret(arg2);
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 resultobj = SWIG_Py_Void();
38740 return resultobj;
38741 fail:
38742 return NULL;
38743 }
38744
38745
38746 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38747 PyObject *resultobj = 0;
38748 wxWindow *arg1 = (wxWindow *) 0 ;
38749 wxCaret *result = 0 ;
38750 void *argp1 = 0 ;
38751 int res1 = 0 ;
38752 PyObject *swig_obj[1] ;
38753
38754 if (!args) SWIG_fail;
38755 swig_obj[0] = args;
38756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38757 if (!SWIG_IsOK(res1)) {
38758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38759 }
38760 arg1 = reinterpret_cast< wxWindow * >(argp1);
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38764 wxPyEndAllowThreads(__tstate);
38765 if (PyErr_Occurred()) SWIG_fail;
38766 }
38767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *resultobj = 0;
38776 wxWindow *arg1 = (wxWindow *) 0 ;
38777 int result;
38778 void *argp1 = 0 ;
38779 int res1 = 0 ;
38780 PyObject *swig_obj[1] ;
38781
38782 if (!args) SWIG_fail;
38783 swig_obj[0] = args;
38784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38785 if (!SWIG_IsOK(res1)) {
38786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38787 }
38788 arg1 = reinterpret_cast< wxWindow * >(argp1);
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 resultobj = SWIG_From_int(static_cast< int >(result));
38796 return resultobj;
38797 fail:
38798 return NULL;
38799 }
38800
38801
38802 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38803 PyObject *resultobj = 0;
38804 wxWindow *arg1 = (wxWindow *) 0 ;
38805 int result;
38806 void *argp1 = 0 ;
38807 int res1 = 0 ;
38808 PyObject *swig_obj[1] ;
38809
38810 if (!args) SWIG_fail;
38811 swig_obj[0] = args;
38812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38813 if (!SWIG_IsOK(res1)) {
38814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38815 }
38816 arg1 = reinterpret_cast< wxWindow * >(argp1);
38817 {
38818 PyThreadState* __tstate = wxPyBeginAllowThreads();
38819 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38820 wxPyEndAllowThreads(__tstate);
38821 if (PyErr_Occurred()) SWIG_fail;
38822 }
38823 resultobj = SWIG_From_int(static_cast< int >(result));
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38831 PyObject *resultobj = 0;
38832 wxWindow *arg1 = (wxWindow *) 0 ;
38833 wxString *arg2 = 0 ;
38834 int *arg3 = (int *) 0 ;
38835 int *arg4 = (int *) 0 ;
38836 void *argp1 = 0 ;
38837 int res1 = 0 ;
38838 bool temp2 = false ;
38839 int temp3 ;
38840 int res3 = SWIG_TMPOBJ ;
38841 int temp4 ;
38842 int res4 = SWIG_TMPOBJ ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char * kwnames[] = {
38846 (char *) "self",(char *) "string", NULL
38847 };
38848
38849 arg3 = &temp3;
38850 arg4 = &temp4;
38851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38853 if (!SWIG_IsOK(res1)) {
38854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38855 }
38856 arg1 = reinterpret_cast< wxWindow * >(argp1);
38857 {
38858 arg2 = wxString_in_helper(obj1);
38859 if (arg2 == NULL) SWIG_fail;
38860 temp2 = true;
38861 }
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38865 wxPyEndAllowThreads(__tstate);
38866 if (PyErr_Occurred()) SWIG_fail;
38867 }
38868 resultobj = SWIG_Py_Void();
38869 if (SWIG_IsTmpObj(res3)) {
38870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38871 } else {
38872 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38874 }
38875 if (SWIG_IsTmpObj(res4)) {
38876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38877 } else {
38878 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38880 }
38881 {
38882 if (temp2)
38883 delete arg2;
38884 }
38885 return resultobj;
38886 fail:
38887 {
38888 if (temp2)
38889 delete arg2;
38890 }
38891 return NULL;
38892 }
38893
38894
38895 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38896 PyObject *resultobj = 0;
38897 wxWindow *arg1 = (wxWindow *) 0 ;
38898 wxString *arg2 = 0 ;
38899 int *arg3 = (int *) 0 ;
38900 int *arg4 = (int *) 0 ;
38901 int *arg5 = (int *) 0 ;
38902 int *arg6 = (int *) 0 ;
38903 wxFont *arg7 = (wxFont *) NULL ;
38904 void *argp1 = 0 ;
38905 int res1 = 0 ;
38906 bool temp2 = false ;
38907 int temp3 ;
38908 int res3 = SWIG_TMPOBJ ;
38909 int temp4 ;
38910 int res4 = SWIG_TMPOBJ ;
38911 int temp5 ;
38912 int res5 = SWIG_TMPOBJ ;
38913 int temp6 ;
38914 int res6 = SWIG_TMPOBJ ;
38915 void *argp7 = 0 ;
38916 int res7 = 0 ;
38917 PyObject * obj0 = 0 ;
38918 PyObject * obj1 = 0 ;
38919 PyObject * obj2 = 0 ;
38920 char * kwnames[] = {
38921 (char *) "self",(char *) "string",(char *) "font", NULL
38922 };
38923
38924 arg3 = &temp3;
38925 arg4 = &temp4;
38926 arg5 = &temp5;
38927 arg6 = &temp6;
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38932 }
38933 arg1 = reinterpret_cast< wxWindow * >(argp1);
38934 {
38935 arg2 = wxString_in_helper(obj1);
38936 if (arg2 == NULL) SWIG_fail;
38937 temp2 = true;
38938 }
38939 if (obj2) {
38940 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38941 if (!SWIG_IsOK(res7)) {
38942 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38943 }
38944 arg7 = reinterpret_cast< wxFont * >(argp7);
38945 }
38946 {
38947 PyThreadState* __tstate = wxPyBeginAllowThreads();
38948 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38949 wxPyEndAllowThreads(__tstate);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 }
38952 resultobj = SWIG_Py_Void();
38953 if (SWIG_IsTmpObj(res3)) {
38954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38955 } else {
38956 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38958 }
38959 if (SWIG_IsTmpObj(res4)) {
38960 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38961 } else {
38962 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38964 }
38965 if (SWIG_IsTmpObj(res5)) {
38966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38967 } else {
38968 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38970 }
38971 if (SWIG_IsTmpObj(res6)) {
38972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38973 } else {
38974 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38976 }
38977 {
38978 if (temp2)
38979 delete arg2;
38980 }
38981 return resultobj;
38982 fail:
38983 {
38984 if (temp2)
38985 delete arg2;
38986 }
38987 return NULL;
38988 }
38989
38990
38991 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38992 PyObject *resultobj = 0;
38993 wxWindow *arg1 = (wxWindow *) 0 ;
38994 int *arg2 = (int *) 0 ;
38995 int *arg3 = (int *) 0 ;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 int temp2 ;
38999 int res2 = 0 ;
39000 int temp3 ;
39001 int res3 = 0 ;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 PyObject * obj2 = 0 ;
39005 char * kwnames[] = {
39006 (char *) "self",(char *) "x",(char *) "y", NULL
39007 };
39008
39009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39011 if (!SWIG_IsOK(res1)) {
39012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39013 }
39014 arg1 = reinterpret_cast< wxWindow * >(argp1);
39015 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39016 int val;
39017 int ecode = SWIG_AsVal_int(obj1, &val);
39018 if (!SWIG_IsOK(ecode)) {
39019 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39020 }
39021 temp2 = static_cast< int >(val);
39022 arg2 = &temp2;
39023 res2 = SWIG_AddTmpMask(ecode);
39024 }
39025 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39026 int val;
39027 int ecode = SWIG_AsVal_int(obj2, &val);
39028 if (!SWIG_IsOK(ecode)) {
39029 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39030 }
39031 temp3 = static_cast< int >(val);
39032 arg3 = &temp3;
39033 res3 = SWIG_AddTmpMask(ecode);
39034 }
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 resultobj = SWIG_Py_Void();
39042 if (SWIG_IsTmpObj(res2)) {
39043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39044 } else {
39045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39047 }
39048 if (SWIG_IsTmpObj(res3)) {
39049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39050 } else {
39051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39053 }
39054 return resultobj;
39055 fail:
39056 return NULL;
39057 }
39058
39059
39060 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39061 PyObject *resultobj = 0;
39062 wxWindow *arg1 = (wxWindow *) 0 ;
39063 int *arg2 = (int *) 0 ;
39064 int *arg3 = (int *) 0 ;
39065 void *argp1 = 0 ;
39066 int res1 = 0 ;
39067 int temp2 ;
39068 int res2 = 0 ;
39069 int temp3 ;
39070 int res3 = 0 ;
39071 PyObject * obj0 = 0 ;
39072 PyObject * obj1 = 0 ;
39073 PyObject * obj2 = 0 ;
39074 char * kwnames[] = {
39075 (char *) "self",(char *) "x",(char *) "y", NULL
39076 };
39077
39078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39080 if (!SWIG_IsOK(res1)) {
39081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39082 }
39083 arg1 = reinterpret_cast< wxWindow * >(argp1);
39084 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39085 int val;
39086 int ecode = SWIG_AsVal_int(obj1, &val);
39087 if (!SWIG_IsOK(ecode)) {
39088 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39089 }
39090 temp2 = static_cast< int >(val);
39091 arg2 = &temp2;
39092 res2 = SWIG_AddTmpMask(ecode);
39093 }
39094 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39095 int val;
39096 int ecode = SWIG_AsVal_int(obj2, &val);
39097 if (!SWIG_IsOK(ecode)) {
39098 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39099 }
39100 temp3 = static_cast< int >(val);
39101 arg3 = &temp3;
39102 res3 = SWIG_AddTmpMask(ecode);
39103 }
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 resultobj = SWIG_Py_Void();
39111 if (SWIG_IsTmpObj(res2)) {
39112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39113 } else {
39114 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39116 }
39117 if (SWIG_IsTmpObj(res3)) {
39118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39119 } else {
39120 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39122 }
39123 return resultobj;
39124 fail:
39125 return NULL;
39126 }
39127
39128
39129 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39130 PyObject *resultobj = 0;
39131 wxWindow *arg1 = (wxWindow *) 0 ;
39132 wxPoint *arg2 = 0 ;
39133 wxPoint result;
39134 void *argp1 = 0 ;
39135 int res1 = 0 ;
39136 wxPoint temp2 ;
39137 PyObject * obj0 = 0 ;
39138 PyObject * obj1 = 0 ;
39139 char * kwnames[] = {
39140 (char *) "self",(char *) "pt", NULL
39141 };
39142
39143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39145 if (!SWIG_IsOK(res1)) {
39146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39147 }
39148 arg1 = reinterpret_cast< wxWindow * >(argp1);
39149 {
39150 arg2 = &temp2;
39151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39152 }
39153 {
39154 PyThreadState* __tstate = wxPyBeginAllowThreads();
39155 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39156 wxPyEndAllowThreads(__tstate);
39157 if (PyErr_Occurred()) SWIG_fail;
39158 }
39159 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39160 return resultobj;
39161 fail:
39162 return NULL;
39163 }
39164
39165
39166 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39167 PyObject *resultobj = 0;
39168 wxWindow *arg1 = (wxWindow *) 0 ;
39169 wxPoint *arg2 = 0 ;
39170 wxPoint result;
39171 void *argp1 = 0 ;
39172 int res1 = 0 ;
39173 wxPoint temp2 ;
39174 PyObject * obj0 = 0 ;
39175 PyObject * obj1 = 0 ;
39176 char * kwnames[] = {
39177 (char *) "self",(char *) "pt", NULL
39178 };
39179
39180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39182 if (!SWIG_IsOK(res1)) {
39183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39184 }
39185 arg1 = reinterpret_cast< wxWindow * >(argp1);
39186 {
39187 arg2 = &temp2;
39188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39189 }
39190 {
39191 PyThreadState* __tstate = wxPyBeginAllowThreads();
39192 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39193 wxPyEndAllowThreads(__tstate);
39194 if (PyErr_Occurred()) SWIG_fail;
39195 }
39196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39197 return resultobj;
39198 fail:
39199 return NULL;
39200 }
39201
39202
39203 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39204 PyObject *resultobj = 0;
39205 wxWindow *arg1 = (wxWindow *) 0 ;
39206 int arg2 ;
39207 int arg3 ;
39208 wxHitTest result;
39209 void *argp1 = 0 ;
39210 int res1 = 0 ;
39211 int val2 ;
39212 int ecode2 = 0 ;
39213 int val3 ;
39214 int ecode3 = 0 ;
39215 PyObject * obj0 = 0 ;
39216 PyObject * obj1 = 0 ;
39217 PyObject * obj2 = 0 ;
39218 char * kwnames[] = {
39219 (char *) "self",(char *) "x",(char *) "y", NULL
39220 };
39221
39222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39224 if (!SWIG_IsOK(res1)) {
39225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39226 }
39227 arg1 = reinterpret_cast< wxWindow * >(argp1);
39228 ecode2 = SWIG_AsVal_int(obj1, &val2);
39229 if (!SWIG_IsOK(ecode2)) {
39230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39231 }
39232 arg2 = static_cast< int >(val2);
39233 ecode3 = SWIG_AsVal_int(obj2, &val3);
39234 if (!SWIG_IsOK(ecode3)) {
39235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39236 }
39237 arg3 = static_cast< int >(val3);
39238 {
39239 PyThreadState* __tstate = wxPyBeginAllowThreads();
39240 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39241 wxPyEndAllowThreads(__tstate);
39242 if (PyErr_Occurred()) SWIG_fail;
39243 }
39244 resultobj = SWIG_From_int(static_cast< int >(result));
39245 return resultobj;
39246 fail:
39247 return NULL;
39248 }
39249
39250
39251 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39252 PyObject *resultobj = 0;
39253 wxWindow *arg1 = (wxWindow *) 0 ;
39254 wxPoint *arg2 = 0 ;
39255 wxHitTest result;
39256 void *argp1 = 0 ;
39257 int res1 = 0 ;
39258 wxPoint temp2 ;
39259 PyObject * obj0 = 0 ;
39260 PyObject * obj1 = 0 ;
39261 char * kwnames[] = {
39262 (char *) "self",(char *) "pt", NULL
39263 };
39264
39265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39267 if (!SWIG_IsOK(res1)) {
39268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39269 }
39270 arg1 = reinterpret_cast< wxWindow * >(argp1);
39271 {
39272 arg2 = &temp2;
39273 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39274 }
39275 {
39276 PyThreadState* __tstate = wxPyBeginAllowThreads();
39277 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39278 wxPyEndAllowThreads(__tstate);
39279 if (PyErr_Occurred()) SWIG_fail;
39280 }
39281 resultobj = SWIG_From_int(static_cast< int >(result));
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39289 PyObject *resultobj = 0;
39290 wxWindow *arg1 = (wxWindow *) 0 ;
39291 long arg2 ;
39292 wxBorder result;
39293 void *argp1 = 0 ;
39294 int res1 = 0 ;
39295 long val2 ;
39296 int ecode2 = 0 ;
39297
39298 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39300 if (!SWIG_IsOK(res1)) {
39301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39302 }
39303 arg1 = reinterpret_cast< wxWindow * >(argp1);
39304 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39305 if (!SWIG_IsOK(ecode2)) {
39306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39307 }
39308 arg2 = static_cast< long >(val2);
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 resultobj = SWIG_From_int(static_cast< int >(result));
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39323 PyObject *resultobj = 0;
39324 wxWindow *arg1 = (wxWindow *) 0 ;
39325 wxBorder result;
39326 void *argp1 = 0 ;
39327 int res1 = 0 ;
39328
39329 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39331 if (!SWIG_IsOK(res1)) {
39332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39333 }
39334 arg1 = reinterpret_cast< wxWindow * >(argp1);
39335 {
39336 PyThreadState* __tstate = wxPyBeginAllowThreads();
39337 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39338 wxPyEndAllowThreads(__tstate);
39339 if (PyErr_Occurred()) SWIG_fail;
39340 }
39341 resultobj = SWIG_From_int(static_cast< int >(result));
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39349 int argc;
39350 PyObject *argv[3];
39351
39352 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39353 --argc;
39354 if (argc == 1) {
39355 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39356 }
39357 if (argc == 2) {
39358 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39359 }
39360
39361 fail:
39362 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39363 return NULL;
39364 }
39365
39366
39367 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39368 PyObject *resultobj = 0;
39369 wxWindow *arg1 = (wxWindow *) 0 ;
39370 long arg2 = (long) wxUPDATE_UI_NONE ;
39371 void *argp1 = 0 ;
39372 int res1 = 0 ;
39373 long val2 ;
39374 int ecode2 = 0 ;
39375 PyObject * obj0 = 0 ;
39376 PyObject * obj1 = 0 ;
39377 char * kwnames[] = {
39378 (char *) "self",(char *) "flags", NULL
39379 };
39380
39381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39383 if (!SWIG_IsOK(res1)) {
39384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39385 }
39386 arg1 = reinterpret_cast< wxWindow * >(argp1);
39387 if (obj1) {
39388 ecode2 = SWIG_AsVal_long(obj1, &val2);
39389 if (!SWIG_IsOK(ecode2)) {
39390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39391 }
39392 arg2 = static_cast< long >(val2);
39393 }
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 (arg1)->UpdateWindowUI(arg2);
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 resultobj = SWIG_Py_Void();
39401 return resultobj;
39402 fail:
39403 return NULL;
39404 }
39405
39406
39407 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39408 PyObject *resultobj = 0;
39409 wxWindow *arg1 = (wxWindow *) 0 ;
39410 wxMenu *arg2 = (wxMenu *) 0 ;
39411 int arg3 = (int) -1 ;
39412 int arg4 = (int) -1 ;
39413 bool result;
39414 void *argp1 = 0 ;
39415 int res1 = 0 ;
39416 void *argp2 = 0 ;
39417 int res2 = 0 ;
39418 int val3 ;
39419 int ecode3 = 0 ;
39420 int val4 ;
39421 int ecode4 = 0 ;
39422 PyObject * obj0 = 0 ;
39423 PyObject * obj1 = 0 ;
39424 PyObject * obj2 = 0 ;
39425 PyObject * obj3 = 0 ;
39426 char * kwnames[] = {
39427 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39428 };
39429
39430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39432 if (!SWIG_IsOK(res1)) {
39433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39434 }
39435 arg1 = reinterpret_cast< wxWindow * >(argp1);
39436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39437 if (!SWIG_IsOK(res2)) {
39438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39439 }
39440 arg2 = reinterpret_cast< wxMenu * >(argp2);
39441 if (obj2) {
39442 ecode3 = SWIG_AsVal_int(obj2, &val3);
39443 if (!SWIG_IsOK(ecode3)) {
39444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39445 }
39446 arg3 = static_cast< int >(val3);
39447 }
39448 if (obj3) {
39449 ecode4 = SWIG_AsVal_int(obj3, &val4);
39450 if (!SWIG_IsOK(ecode4)) {
39451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39452 }
39453 arg4 = static_cast< int >(val4);
39454 }
39455 {
39456 PyThreadState* __tstate = wxPyBeginAllowThreads();
39457 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39458 wxPyEndAllowThreads(__tstate);
39459 if (PyErr_Occurred()) SWIG_fail;
39460 }
39461 {
39462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39463 }
39464 return resultobj;
39465 fail:
39466 return NULL;
39467 }
39468
39469
39470 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39471 PyObject *resultobj = 0;
39472 wxWindow *arg1 = (wxWindow *) 0 ;
39473 wxMenu *arg2 = (wxMenu *) 0 ;
39474 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39475 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39476 bool result;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 void *argp2 = 0 ;
39480 int res2 = 0 ;
39481 wxPoint temp3 ;
39482 PyObject * obj0 = 0 ;
39483 PyObject * obj1 = 0 ;
39484 PyObject * obj2 = 0 ;
39485 char * kwnames[] = {
39486 (char *) "self",(char *) "menu",(char *) "pos", NULL
39487 };
39488
39489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39491 if (!SWIG_IsOK(res1)) {
39492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39493 }
39494 arg1 = reinterpret_cast< wxWindow * >(argp1);
39495 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39496 if (!SWIG_IsOK(res2)) {
39497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39498 }
39499 arg2 = reinterpret_cast< wxMenu * >(argp2);
39500 if (obj2) {
39501 {
39502 arg3 = &temp3;
39503 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39504 }
39505 }
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 {
39513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39514 }
39515 return resultobj;
39516 fail:
39517 return NULL;
39518 }
39519
39520
39521 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39522 PyObject *resultobj = 0;
39523 wxWindow *arg1 = (wxWindow *) 0 ;
39524 bool result;
39525 void *argp1 = 0 ;
39526 int res1 = 0 ;
39527 PyObject *swig_obj[1] ;
39528
39529 if (!args) SWIG_fail;
39530 swig_obj[0] = args;
39531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39532 if (!SWIG_IsOK(res1)) {
39533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39534 }
39535 arg1 = reinterpret_cast< wxWindow * >(argp1);
39536 {
39537 PyThreadState* __tstate = wxPyBeginAllowThreads();
39538 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39539 wxPyEndAllowThreads(__tstate);
39540 if (PyErr_Occurred()) SWIG_fail;
39541 }
39542 {
39543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39544 }
39545 return resultobj;
39546 fail:
39547 return NULL;
39548 }
39549
39550
39551 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39552 PyObject *resultobj = 0;
39553 wxWindow *arg1 = (wxWindow *) 0 ;
39554 long result;
39555 void *argp1 = 0 ;
39556 int res1 = 0 ;
39557 PyObject *swig_obj[1] ;
39558
39559 if (!args) SWIG_fail;
39560 swig_obj[0] = args;
39561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39562 if (!SWIG_IsOK(res1)) {
39563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39564 }
39565 arg1 = reinterpret_cast< wxWindow * >(argp1);
39566 {
39567 PyThreadState* __tstate = wxPyBeginAllowThreads();
39568 result = (long)wxWindow_GetHandle(arg1);
39569 wxPyEndAllowThreads(__tstate);
39570 if (PyErr_Occurred()) SWIG_fail;
39571 }
39572 resultobj = SWIG_From_long(static_cast< long >(result));
39573 return resultobj;
39574 fail:
39575 return NULL;
39576 }
39577
39578
39579 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39580 PyObject *resultobj = 0;
39581 wxWindow *arg1 = (wxWindow *) 0 ;
39582 long arg2 ;
39583 void *argp1 = 0 ;
39584 int res1 = 0 ;
39585 long val2 ;
39586 int ecode2 = 0 ;
39587 PyObject * obj0 = 0 ;
39588 PyObject * obj1 = 0 ;
39589 char * kwnames[] = {
39590 (char *) "self",(char *) "handle", NULL
39591 };
39592
39593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39595 if (!SWIG_IsOK(res1)) {
39596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39597 }
39598 arg1 = reinterpret_cast< wxWindow * >(argp1);
39599 ecode2 = SWIG_AsVal_long(obj1, &val2);
39600 if (!SWIG_IsOK(ecode2)) {
39601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39602 }
39603 arg2 = static_cast< long >(val2);
39604 {
39605 PyThreadState* __tstate = wxPyBeginAllowThreads();
39606 wxWindow_AssociateHandle(arg1,arg2);
39607 wxPyEndAllowThreads(__tstate);
39608 if (PyErr_Occurred()) SWIG_fail;
39609 }
39610 resultobj = SWIG_Py_Void();
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39618 PyObject *resultobj = 0;
39619 wxWindow *arg1 = (wxWindow *) 0 ;
39620 void *argp1 = 0 ;
39621 int res1 = 0 ;
39622 PyObject *swig_obj[1] ;
39623
39624 if (!args) SWIG_fail;
39625 swig_obj[0] = args;
39626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39627 if (!SWIG_IsOK(res1)) {
39628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39629 }
39630 arg1 = reinterpret_cast< wxWindow * >(argp1);
39631 {
39632 PyThreadState* __tstate = wxPyBeginAllowThreads();
39633 (arg1)->DissociateHandle();
39634 wxPyEndAllowThreads(__tstate);
39635 if (PyErr_Occurred()) SWIG_fail;
39636 }
39637 resultobj = SWIG_Py_Void();
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39645 PyObject *resultobj = 0;
39646 wxWindow *arg1 = (wxWindow *) 0 ;
39647 wxPaintEvent *arg2 = 0 ;
39648 void *argp1 = 0 ;
39649 int res1 = 0 ;
39650 void *argp2 = 0 ;
39651 int res2 = 0 ;
39652 PyObject * obj0 = 0 ;
39653 PyObject * obj1 = 0 ;
39654 char * kwnames[] = {
39655 (char *) "self",(char *) "event", NULL
39656 };
39657
39658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39660 if (!SWIG_IsOK(res1)) {
39661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39662 }
39663 arg1 = reinterpret_cast< wxWindow * >(argp1);
39664 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39665 if (!SWIG_IsOK(res2)) {
39666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39667 }
39668 if (!argp2) {
39669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39670 }
39671 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39672 {
39673 PyThreadState* __tstate = wxPyBeginAllowThreads();
39674 (arg1)->OnPaint(*arg2);
39675 wxPyEndAllowThreads(__tstate);
39676 if (PyErr_Occurred()) SWIG_fail;
39677 }
39678 resultobj = SWIG_Py_Void();
39679 return resultobj;
39680 fail:
39681 return NULL;
39682 }
39683
39684
39685 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj = 0;
39687 wxWindow *arg1 = (wxWindow *) 0 ;
39688 int arg2 ;
39689 bool result;
39690 void *argp1 = 0 ;
39691 int res1 = 0 ;
39692 int val2 ;
39693 int ecode2 = 0 ;
39694 PyObject * obj0 = 0 ;
39695 PyObject * obj1 = 0 ;
39696 char * kwnames[] = {
39697 (char *) "self",(char *) "orient", NULL
39698 };
39699
39700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39702 if (!SWIG_IsOK(res1)) {
39703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39704 }
39705 arg1 = reinterpret_cast< wxWindow * >(argp1);
39706 ecode2 = SWIG_AsVal_int(obj1, &val2);
39707 if (!SWIG_IsOK(ecode2)) {
39708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39709 }
39710 arg2 = static_cast< int >(val2);
39711 {
39712 PyThreadState* __tstate = wxPyBeginAllowThreads();
39713 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 {
39718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39719 }
39720 return resultobj;
39721 fail:
39722 return NULL;
39723 }
39724
39725
39726 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39727 PyObject *resultobj = 0;
39728 wxWindow *arg1 = (wxWindow *) 0 ;
39729 int arg2 ;
39730 int arg3 ;
39731 int arg4 ;
39732 int arg5 ;
39733 bool arg6 = (bool) true ;
39734 void *argp1 = 0 ;
39735 int res1 = 0 ;
39736 int val2 ;
39737 int ecode2 = 0 ;
39738 int val3 ;
39739 int ecode3 = 0 ;
39740 int val4 ;
39741 int ecode4 = 0 ;
39742 int val5 ;
39743 int ecode5 = 0 ;
39744 bool val6 ;
39745 int ecode6 = 0 ;
39746 PyObject * obj0 = 0 ;
39747 PyObject * obj1 = 0 ;
39748 PyObject * obj2 = 0 ;
39749 PyObject * obj3 = 0 ;
39750 PyObject * obj4 = 0 ;
39751 PyObject * obj5 = 0 ;
39752 char * kwnames[] = {
39753 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39754 };
39755
39756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39758 if (!SWIG_IsOK(res1)) {
39759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39760 }
39761 arg1 = reinterpret_cast< wxWindow * >(argp1);
39762 ecode2 = SWIG_AsVal_int(obj1, &val2);
39763 if (!SWIG_IsOK(ecode2)) {
39764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39765 }
39766 arg2 = static_cast< int >(val2);
39767 ecode3 = SWIG_AsVal_int(obj2, &val3);
39768 if (!SWIG_IsOK(ecode3)) {
39769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39770 }
39771 arg3 = static_cast< int >(val3);
39772 ecode4 = SWIG_AsVal_int(obj3, &val4);
39773 if (!SWIG_IsOK(ecode4)) {
39774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39775 }
39776 arg4 = static_cast< int >(val4);
39777 ecode5 = SWIG_AsVal_int(obj4, &val5);
39778 if (!SWIG_IsOK(ecode5)) {
39779 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39780 }
39781 arg5 = static_cast< int >(val5);
39782 if (obj5) {
39783 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39784 if (!SWIG_IsOK(ecode6)) {
39785 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39786 }
39787 arg6 = static_cast< bool >(val6);
39788 }
39789 {
39790 PyThreadState* __tstate = wxPyBeginAllowThreads();
39791 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39792 wxPyEndAllowThreads(__tstate);
39793 if (PyErr_Occurred()) SWIG_fail;
39794 }
39795 resultobj = SWIG_Py_Void();
39796 return resultobj;
39797 fail:
39798 return NULL;
39799 }
39800
39801
39802 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39803 PyObject *resultobj = 0;
39804 wxWindow *arg1 = (wxWindow *) 0 ;
39805 int arg2 ;
39806 int arg3 ;
39807 bool arg4 = (bool) true ;
39808 void *argp1 = 0 ;
39809 int res1 = 0 ;
39810 int val2 ;
39811 int ecode2 = 0 ;
39812 int val3 ;
39813 int ecode3 = 0 ;
39814 bool val4 ;
39815 int ecode4 = 0 ;
39816 PyObject * obj0 = 0 ;
39817 PyObject * obj1 = 0 ;
39818 PyObject * obj2 = 0 ;
39819 PyObject * obj3 = 0 ;
39820 char * kwnames[] = {
39821 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39822 };
39823
39824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39826 if (!SWIG_IsOK(res1)) {
39827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39828 }
39829 arg1 = reinterpret_cast< wxWindow * >(argp1);
39830 ecode2 = SWIG_AsVal_int(obj1, &val2);
39831 if (!SWIG_IsOK(ecode2)) {
39832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39833 }
39834 arg2 = static_cast< int >(val2);
39835 ecode3 = SWIG_AsVal_int(obj2, &val3);
39836 if (!SWIG_IsOK(ecode3)) {
39837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39838 }
39839 arg3 = static_cast< int >(val3);
39840 if (obj3) {
39841 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39842 if (!SWIG_IsOK(ecode4)) {
39843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39844 }
39845 arg4 = static_cast< bool >(val4);
39846 }
39847 {
39848 PyThreadState* __tstate = wxPyBeginAllowThreads();
39849 (arg1)->SetScrollPos(arg2,arg3,arg4);
39850 wxPyEndAllowThreads(__tstate);
39851 if (PyErr_Occurred()) SWIG_fail;
39852 }
39853 resultobj = SWIG_Py_Void();
39854 return resultobj;
39855 fail:
39856 return NULL;
39857 }
39858
39859
39860 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39861 PyObject *resultobj = 0;
39862 wxWindow *arg1 = (wxWindow *) 0 ;
39863 int arg2 ;
39864 int result;
39865 void *argp1 = 0 ;
39866 int res1 = 0 ;
39867 int val2 ;
39868 int ecode2 = 0 ;
39869 PyObject * obj0 = 0 ;
39870 PyObject * obj1 = 0 ;
39871 char * kwnames[] = {
39872 (char *) "self",(char *) "orientation", NULL
39873 };
39874
39875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39877 if (!SWIG_IsOK(res1)) {
39878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39879 }
39880 arg1 = reinterpret_cast< wxWindow * >(argp1);
39881 ecode2 = SWIG_AsVal_int(obj1, &val2);
39882 if (!SWIG_IsOK(ecode2)) {
39883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39884 }
39885 arg2 = static_cast< int >(val2);
39886 {
39887 PyThreadState* __tstate = wxPyBeginAllowThreads();
39888 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39889 wxPyEndAllowThreads(__tstate);
39890 if (PyErr_Occurred()) SWIG_fail;
39891 }
39892 resultobj = SWIG_From_int(static_cast< int >(result));
39893 return resultobj;
39894 fail:
39895 return NULL;
39896 }
39897
39898
39899 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39900 PyObject *resultobj = 0;
39901 wxWindow *arg1 = (wxWindow *) 0 ;
39902 int arg2 ;
39903 int result;
39904 void *argp1 = 0 ;
39905 int res1 = 0 ;
39906 int val2 ;
39907 int ecode2 = 0 ;
39908 PyObject * obj0 = 0 ;
39909 PyObject * obj1 = 0 ;
39910 char * kwnames[] = {
39911 (char *) "self",(char *) "orientation", NULL
39912 };
39913
39914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39916 if (!SWIG_IsOK(res1)) {
39917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39918 }
39919 arg1 = reinterpret_cast< wxWindow * >(argp1);
39920 ecode2 = SWIG_AsVal_int(obj1, &val2);
39921 if (!SWIG_IsOK(ecode2)) {
39922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39923 }
39924 arg2 = static_cast< int >(val2);
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 resultobj = SWIG_From_int(static_cast< int >(result));
39932 return resultobj;
39933 fail:
39934 return NULL;
39935 }
39936
39937
39938 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39939 PyObject *resultobj = 0;
39940 wxWindow *arg1 = (wxWindow *) 0 ;
39941 int arg2 ;
39942 int result;
39943 void *argp1 = 0 ;
39944 int res1 = 0 ;
39945 int val2 ;
39946 int ecode2 = 0 ;
39947 PyObject * obj0 = 0 ;
39948 PyObject * obj1 = 0 ;
39949 char * kwnames[] = {
39950 (char *) "self",(char *) "orientation", NULL
39951 };
39952
39953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39955 if (!SWIG_IsOK(res1)) {
39956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39957 }
39958 arg1 = reinterpret_cast< wxWindow * >(argp1);
39959 ecode2 = SWIG_AsVal_int(obj1, &val2);
39960 if (!SWIG_IsOK(ecode2)) {
39961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39962 }
39963 arg2 = static_cast< int >(val2);
39964 {
39965 PyThreadState* __tstate = wxPyBeginAllowThreads();
39966 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39967 wxPyEndAllowThreads(__tstate);
39968 if (PyErr_Occurred()) SWIG_fail;
39969 }
39970 resultobj = SWIG_From_int(static_cast< int >(result));
39971 return resultobj;
39972 fail:
39973 return NULL;
39974 }
39975
39976
39977 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39978 PyObject *resultobj = 0;
39979 wxWindow *arg1 = (wxWindow *) 0 ;
39980 int arg2 ;
39981 int arg3 ;
39982 wxRect *arg4 = (wxRect *) NULL ;
39983 void *argp1 = 0 ;
39984 int res1 = 0 ;
39985 int val2 ;
39986 int ecode2 = 0 ;
39987 int val3 ;
39988 int ecode3 = 0 ;
39989 void *argp4 = 0 ;
39990 int res4 = 0 ;
39991 PyObject * obj0 = 0 ;
39992 PyObject * obj1 = 0 ;
39993 PyObject * obj2 = 0 ;
39994 PyObject * obj3 = 0 ;
39995 char * kwnames[] = {
39996 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39997 };
39998
39999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40001 if (!SWIG_IsOK(res1)) {
40002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40003 }
40004 arg1 = reinterpret_cast< wxWindow * >(argp1);
40005 ecode2 = SWIG_AsVal_int(obj1, &val2);
40006 if (!SWIG_IsOK(ecode2)) {
40007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40008 }
40009 arg2 = static_cast< int >(val2);
40010 ecode3 = SWIG_AsVal_int(obj2, &val3);
40011 if (!SWIG_IsOK(ecode3)) {
40012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40013 }
40014 arg3 = static_cast< int >(val3);
40015 if (obj3) {
40016 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40017 if (!SWIG_IsOK(res4)) {
40018 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40019 }
40020 arg4 = reinterpret_cast< wxRect * >(argp4);
40021 }
40022 {
40023 PyThreadState* __tstate = wxPyBeginAllowThreads();
40024 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40025 wxPyEndAllowThreads(__tstate);
40026 if (PyErr_Occurred()) SWIG_fail;
40027 }
40028 resultobj = SWIG_Py_Void();
40029 return resultobj;
40030 fail:
40031 return NULL;
40032 }
40033
40034
40035 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40036 PyObject *resultobj = 0;
40037 wxWindow *arg1 = (wxWindow *) 0 ;
40038 int arg2 ;
40039 bool result;
40040 void *argp1 = 0 ;
40041 int res1 = 0 ;
40042 int val2 ;
40043 int ecode2 = 0 ;
40044 PyObject * obj0 = 0 ;
40045 PyObject * obj1 = 0 ;
40046 char * kwnames[] = {
40047 (char *) "self",(char *) "lines", NULL
40048 };
40049
40050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40052 if (!SWIG_IsOK(res1)) {
40053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40054 }
40055 arg1 = reinterpret_cast< wxWindow * >(argp1);
40056 ecode2 = SWIG_AsVal_int(obj1, &val2);
40057 if (!SWIG_IsOK(ecode2)) {
40058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40059 }
40060 arg2 = static_cast< int >(val2);
40061 {
40062 PyThreadState* __tstate = wxPyBeginAllowThreads();
40063 result = (bool)(arg1)->ScrollLines(arg2);
40064 wxPyEndAllowThreads(__tstate);
40065 if (PyErr_Occurred()) SWIG_fail;
40066 }
40067 {
40068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40069 }
40070 return resultobj;
40071 fail:
40072 return NULL;
40073 }
40074
40075
40076 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40077 PyObject *resultobj = 0;
40078 wxWindow *arg1 = (wxWindow *) 0 ;
40079 int arg2 ;
40080 bool result;
40081 void *argp1 = 0 ;
40082 int res1 = 0 ;
40083 int val2 ;
40084 int ecode2 = 0 ;
40085 PyObject * obj0 = 0 ;
40086 PyObject * obj1 = 0 ;
40087 char * kwnames[] = {
40088 (char *) "self",(char *) "pages", NULL
40089 };
40090
40091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40093 if (!SWIG_IsOK(res1)) {
40094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40095 }
40096 arg1 = reinterpret_cast< wxWindow * >(argp1);
40097 ecode2 = SWIG_AsVal_int(obj1, &val2);
40098 if (!SWIG_IsOK(ecode2)) {
40099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40100 }
40101 arg2 = static_cast< int >(val2);
40102 {
40103 PyThreadState* __tstate = wxPyBeginAllowThreads();
40104 result = (bool)(arg1)->ScrollPages(arg2);
40105 wxPyEndAllowThreads(__tstate);
40106 if (PyErr_Occurred()) SWIG_fail;
40107 }
40108 {
40109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40110 }
40111 return resultobj;
40112 fail:
40113 return NULL;
40114 }
40115
40116
40117 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40118 PyObject *resultobj = 0;
40119 wxWindow *arg1 = (wxWindow *) 0 ;
40120 bool result;
40121 void *argp1 = 0 ;
40122 int res1 = 0 ;
40123 PyObject *swig_obj[1] ;
40124
40125 if (!args) SWIG_fail;
40126 swig_obj[0] = args;
40127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40130 }
40131 arg1 = reinterpret_cast< wxWindow * >(argp1);
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 result = (bool)(arg1)->LineUp();
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 {
40139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40140 }
40141 return resultobj;
40142 fail:
40143 return NULL;
40144 }
40145
40146
40147 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40148 PyObject *resultobj = 0;
40149 wxWindow *arg1 = (wxWindow *) 0 ;
40150 bool result;
40151 void *argp1 = 0 ;
40152 int res1 = 0 ;
40153 PyObject *swig_obj[1] ;
40154
40155 if (!args) SWIG_fail;
40156 swig_obj[0] = args;
40157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40160 }
40161 arg1 = reinterpret_cast< wxWindow * >(argp1);
40162 {
40163 PyThreadState* __tstate = wxPyBeginAllowThreads();
40164 result = (bool)(arg1)->LineDown();
40165 wxPyEndAllowThreads(__tstate);
40166 if (PyErr_Occurred()) SWIG_fail;
40167 }
40168 {
40169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40170 }
40171 return resultobj;
40172 fail:
40173 return NULL;
40174 }
40175
40176
40177 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40178 PyObject *resultobj = 0;
40179 wxWindow *arg1 = (wxWindow *) 0 ;
40180 bool result;
40181 void *argp1 = 0 ;
40182 int res1 = 0 ;
40183 PyObject *swig_obj[1] ;
40184
40185 if (!args) SWIG_fail;
40186 swig_obj[0] = args;
40187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40190 }
40191 arg1 = reinterpret_cast< wxWindow * >(argp1);
40192 {
40193 PyThreadState* __tstate = wxPyBeginAllowThreads();
40194 result = (bool)(arg1)->PageUp();
40195 wxPyEndAllowThreads(__tstate);
40196 if (PyErr_Occurred()) SWIG_fail;
40197 }
40198 {
40199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40200 }
40201 return resultobj;
40202 fail:
40203 return NULL;
40204 }
40205
40206
40207 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40208 PyObject *resultobj = 0;
40209 wxWindow *arg1 = (wxWindow *) 0 ;
40210 bool result;
40211 void *argp1 = 0 ;
40212 int res1 = 0 ;
40213 PyObject *swig_obj[1] ;
40214
40215 if (!args) SWIG_fail;
40216 swig_obj[0] = args;
40217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40218 if (!SWIG_IsOK(res1)) {
40219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40220 }
40221 arg1 = reinterpret_cast< wxWindow * >(argp1);
40222 {
40223 PyThreadState* __tstate = wxPyBeginAllowThreads();
40224 result = (bool)(arg1)->PageDown();
40225 wxPyEndAllowThreads(__tstate);
40226 if (PyErr_Occurred()) SWIG_fail;
40227 }
40228 {
40229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40230 }
40231 return resultobj;
40232 fail:
40233 return NULL;
40234 }
40235
40236
40237 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40238 PyObject *resultobj = 0;
40239 wxWindow *arg1 = (wxWindow *) 0 ;
40240 wxString *arg2 = 0 ;
40241 void *argp1 = 0 ;
40242 int res1 = 0 ;
40243 bool temp2 = false ;
40244 PyObject * obj0 = 0 ;
40245 PyObject * obj1 = 0 ;
40246 char * kwnames[] = {
40247 (char *) "self",(char *) "text", NULL
40248 };
40249
40250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40252 if (!SWIG_IsOK(res1)) {
40253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40254 }
40255 arg1 = reinterpret_cast< wxWindow * >(argp1);
40256 {
40257 arg2 = wxString_in_helper(obj1);
40258 if (arg2 == NULL) SWIG_fail;
40259 temp2 = true;
40260 }
40261 {
40262 PyThreadState* __tstate = wxPyBeginAllowThreads();
40263 (arg1)->SetHelpText((wxString const &)*arg2);
40264 wxPyEndAllowThreads(__tstate);
40265 if (PyErr_Occurred()) SWIG_fail;
40266 }
40267 resultobj = SWIG_Py_Void();
40268 {
40269 if (temp2)
40270 delete arg2;
40271 }
40272 return resultobj;
40273 fail:
40274 {
40275 if (temp2)
40276 delete arg2;
40277 }
40278 return NULL;
40279 }
40280
40281
40282 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40283 PyObject *resultobj = 0;
40284 wxWindow *arg1 = (wxWindow *) 0 ;
40285 wxString *arg2 = 0 ;
40286 void *argp1 = 0 ;
40287 int res1 = 0 ;
40288 bool temp2 = false ;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char * kwnames[] = {
40292 (char *) "self",(char *) "text", NULL
40293 };
40294
40295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40297 if (!SWIG_IsOK(res1)) {
40298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40299 }
40300 arg1 = reinterpret_cast< wxWindow * >(argp1);
40301 {
40302 arg2 = wxString_in_helper(obj1);
40303 if (arg2 == NULL) SWIG_fail;
40304 temp2 = true;
40305 }
40306 {
40307 PyThreadState* __tstate = wxPyBeginAllowThreads();
40308 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40309 wxPyEndAllowThreads(__tstate);
40310 if (PyErr_Occurred()) SWIG_fail;
40311 }
40312 resultobj = SWIG_Py_Void();
40313 {
40314 if (temp2)
40315 delete arg2;
40316 }
40317 return resultobj;
40318 fail:
40319 {
40320 if (temp2)
40321 delete arg2;
40322 }
40323 return NULL;
40324 }
40325
40326
40327 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40328 PyObject *resultobj = 0;
40329 wxWindow *arg1 = (wxWindow *) 0 ;
40330 wxPoint *arg2 = 0 ;
40331 wxHelpEvent::Origin arg3 ;
40332 wxString result;
40333 void *argp1 = 0 ;
40334 int res1 = 0 ;
40335 wxPoint temp2 ;
40336 void *argp3 ;
40337 int res3 = 0 ;
40338 PyObject * obj0 = 0 ;
40339 PyObject * obj1 = 0 ;
40340 PyObject * obj2 = 0 ;
40341 char * kwnames[] = {
40342 (char *) "self",(char *) "pt",(char *) "origin", NULL
40343 };
40344
40345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40347 if (!SWIG_IsOK(res1)) {
40348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40349 }
40350 arg1 = reinterpret_cast< wxWindow * >(argp1);
40351 {
40352 arg2 = &temp2;
40353 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40354 }
40355 {
40356 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40357 if (!SWIG_IsOK(res3)) {
40358 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40359 }
40360 if (!argp3) {
40361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40362 } else {
40363 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40364 arg3 = *temp;
40365 if (SWIG_IsNewObj(res3)) delete temp;
40366 }
40367 }
40368 {
40369 PyThreadState* __tstate = wxPyBeginAllowThreads();
40370 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40371 wxPyEndAllowThreads(__tstate);
40372 if (PyErr_Occurred()) SWIG_fail;
40373 }
40374 {
40375 #if wxUSE_UNICODE
40376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40377 #else
40378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40379 #endif
40380 }
40381 return resultobj;
40382 fail:
40383 return NULL;
40384 }
40385
40386
40387 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40388 PyObject *resultobj = 0;
40389 wxWindow *arg1 = (wxWindow *) 0 ;
40390 wxString result;
40391 void *argp1 = 0 ;
40392 int res1 = 0 ;
40393 PyObject *swig_obj[1] ;
40394
40395 if (!args) SWIG_fail;
40396 swig_obj[0] = args;
40397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40398 if (!SWIG_IsOK(res1)) {
40399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40400 }
40401 arg1 = reinterpret_cast< wxWindow * >(argp1);
40402 {
40403 PyThreadState* __tstate = wxPyBeginAllowThreads();
40404 result = ((wxWindow const *)arg1)->GetHelpText();
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 {
40409 #if wxUSE_UNICODE
40410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40411 #else
40412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40413 #endif
40414 }
40415 return resultobj;
40416 fail:
40417 return NULL;
40418 }
40419
40420
40421 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40422 PyObject *resultobj = 0;
40423 wxWindow *arg1 = (wxWindow *) 0 ;
40424 wxString *arg2 = 0 ;
40425 void *argp1 = 0 ;
40426 int res1 = 0 ;
40427 bool temp2 = false ;
40428 PyObject * obj0 = 0 ;
40429 PyObject * obj1 = 0 ;
40430 char * kwnames[] = {
40431 (char *) "self",(char *) "tip", NULL
40432 };
40433
40434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40436 if (!SWIG_IsOK(res1)) {
40437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40438 }
40439 arg1 = reinterpret_cast< wxWindow * >(argp1);
40440 {
40441 arg2 = wxString_in_helper(obj1);
40442 if (arg2 == NULL) SWIG_fail;
40443 temp2 = true;
40444 }
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 (arg1)->SetToolTip((wxString const &)*arg2);
40448 wxPyEndAllowThreads(__tstate);
40449 if (PyErr_Occurred()) SWIG_fail;
40450 }
40451 resultobj = SWIG_Py_Void();
40452 {
40453 if (temp2)
40454 delete arg2;
40455 }
40456 return resultobj;
40457 fail:
40458 {
40459 if (temp2)
40460 delete arg2;
40461 }
40462 return NULL;
40463 }
40464
40465
40466 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj = 0;
40468 wxWindow *arg1 = (wxWindow *) 0 ;
40469 wxToolTip *arg2 = (wxToolTip *) 0 ;
40470 void *argp1 = 0 ;
40471 int res1 = 0 ;
40472 int res2 = 0 ;
40473 PyObject * obj0 = 0 ;
40474 PyObject * obj1 = 0 ;
40475 char * kwnames[] = {
40476 (char *) "self",(char *) "tip", NULL
40477 };
40478
40479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40481 if (!SWIG_IsOK(res1)) {
40482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40483 }
40484 arg1 = reinterpret_cast< wxWindow * >(argp1);
40485 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40486 if (!SWIG_IsOK(res2)) {
40487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40488 }
40489 {
40490 PyThreadState* __tstate = wxPyBeginAllowThreads();
40491 (arg1)->SetToolTip(arg2);
40492 wxPyEndAllowThreads(__tstate);
40493 if (PyErr_Occurred()) SWIG_fail;
40494 }
40495 resultobj = SWIG_Py_Void();
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40503 PyObject *resultobj = 0;
40504 wxWindow *arg1 = (wxWindow *) 0 ;
40505 wxToolTip *result = 0 ;
40506 void *argp1 = 0 ;
40507 int res1 = 0 ;
40508 PyObject *swig_obj[1] ;
40509
40510 if (!args) SWIG_fail;
40511 swig_obj[0] = args;
40512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40515 }
40516 arg1 = reinterpret_cast< wxWindow * >(argp1);
40517 {
40518 PyThreadState* __tstate = wxPyBeginAllowThreads();
40519 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40520 wxPyEndAllowThreads(__tstate);
40521 if (PyErr_Occurred()) SWIG_fail;
40522 }
40523 {
40524 resultobj = wxPyMake_wxObject(result, (bool)0);
40525 }
40526 return resultobj;
40527 fail:
40528 return NULL;
40529 }
40530
40531
40532 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40533 PyObject *resultobj = 0;
40534 wxWindow *arg1 = (wxWindow *) 0 ;
40535 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40536 void *argp1 = 0 ;
40537 int res1 = 0 ;
40538 int res2 = 0 ;
40539 PyObject * obj0 = 0 ;
40540 PyObject * obj1 = 0 ;
40541 char * kwnames[] = {
40542 (char *) "self",(char *) "dropTarget", NULL
40543 };
40544
40545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40547 if (!SWIG_IsOK(res1)) {
40548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40549 }
40550 arg1 = reinterpret_cast< wxWindow * >(argp1);
40551 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40552 if (!SWIG_IsOK(res2)) {
40553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40554 }
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 (arg1)->SetDropTarget(arg2);
40558 wxPyEndAllowThreads(__tstate);
40559 if (PyErr_Occurred()) SWIG_fail;
40560 }
40561 resultobj = SWIG_Py_Void();
40562 return resultobj;
40563 fail:
40564 return NULL;
40565 }
40566
40567
40568 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40569 PyObject *resultobj = 0;
40570 wxWindow *arg1 = (wxWindow *) 0 ;
40571 wxPyDropTarget *result = 0 ;
40572 void *argp1 = 0 ;
40573 int res1 = 0 ;
40574 PyObject *swig_obj[1] ;
40575
40576 if (!args) SWIG_fail;
40577 swig_obj[0] = args;
40578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40579 if (!SWIG_IsOK(res1)) {
40580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40581 }
40582 arg1 = reinterpret_cast< wxWindow * >(argp1);
40583 {
40584 PyThreadState* __tstate = wxPyBeginAllowThreads();
40585 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40586 wxPyEndAllowThreads(__tstate);
40587 if (PyErr_Occurred()) SWIG_fail;
40588 }
40589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40590 return resultobj;
40591 fail:
40592 return NULL;
40593 }
40594
40595
40596 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40597 PyObject *resultobj = 0;
40598 wxWindow *arg1 = (wxWindow *) 0 ;
40599 bool arg2 ;
40600 void *argp1 = 0 ;
40601 int res1 = 0 ;
40602 bool val2 ;
40603 int ecode2 = 0 ;
40604 PyObject * obj0 = 0 ;
40605 PyObject * obj1 = 0 ;
40606 char * kwnames[] = {
40607 (char *) "self",(char *) "accept", NULL
40608 };
40609
40610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40612 if (!SWIG_IsOK(res1)) {
40613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40614 }
40615 arg1 = reinterpret_cast< wxWindow * >(argp1);
40616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40617 if (!SWIG_IsOK(ecode2)) {
40618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40619 }
40620 arg2 = static_cast< bool >(val2);
40621 {
40622 PyThreadState* __tstate = wxPyBeginAllowThreads();
40623 (arg1)->DragAcceptFiles(arg2);
40624 wxPyEndAllowThreads(__tstate);
40625 if (PyErr_Occurred()) SWIG_fail;
40626 }
40627 resultobj = SWIG_Py_Void();
40628 return resultobj;
40629 fail:
40630 return NULL;
40631 }
40632
40633
40634 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40635 PyObject *resultobj = 0;
40636 wxWindow *arg1 = (wxWindow *) 0 ;
40637 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40638 void *argp1 = 0 ;
40639 int res1 = 0 ;
40640 int res2 = 0 ;
40641 PyObject * obj0 = 0 ;
40642 PyObject * obj1 = 0 ;
40643 char * kwnames[] = {
40644 (char *) "self",(char *) "constraints", NULL
40645 };
40646
40647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40649 if (!SWIG_IsOK(res1)) {
40650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40651 }
40652 arg1 = reinterpret_cast< wxWindow * >(argp1);
40653 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40654 if (!SWIG_IsOK(res2)) {
40655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40656 }
40657 {
40658 PyThreadState* __tstate = wxPyBeginAllowThreads();
40659 (arg1)->SetConstraints(arg2);
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 resultobj = SWIG_Py_Void();
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40671 PyObject *resultobj = 0;
40672 wxWindow *arg1 = (wxWindow *) 0 ;
40673 wxLayoutConstraints *result = 0 ;
40674 void *argp1 = 0 ;
40675 int res1 = 0 ;
40676 PyObject *swig_obj[1] ;
40677
40678 if (!args) SWIG_fail;
40679 swig_obj[0] = args;
40680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40681 if (!SWIG_IsOK(res1)) {
40682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40683 }
40684 arg1 = reinterpret_cast< wxWindow * >(argp1);
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40692 return resultobj;
40693 fail:
40694 return NULL;
40695 }
40696
40697
40698 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40699 PyObject *resultobj = 0;
40700 wxWindow *arg1 = (wxWindow *) 0 ;
40701 bool arg2 ;
40702 void *argp1 = 0 ;
40703 int res1 = 0 ;
40704 bool val2 ;
40705 int ecode2 = 0 ;
40706 PyObject * obj0 = 0 ;
40707 PyObject * obj1 = 0 ;
40708 char * kwnames[] = {
40709 (char *) "self",(char *) "autoLayout", NULL
40710 };
40711
40712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40714 if (!SWIG_IsOK(res1)) {
40715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40716 }
40717 arg1 = reinterpret_cast< wxWindow * >(argp1);
40718 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40719 if (!SWIG_IsOK(ecode2)) {
40720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40721 }
40722 arg2 = static_cast< bool >(val2);
40723 {
40724 PyThreadState* __tstate = wxPyBeginAllowThreads();
40725 (arg1)->SetAutoLayout(arg2);
40726 wxPyEndAllowThreads(__tstate);
40727 if (PyErr_Occurred()) SWIG_fail;
40728 }
40729 resultobj = SWIG_Py_Void();
40730 return resultobj;
40731 fail:
40732 return NULL;
40733 }
40734
40735
40736 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40737 PyObject *resultobj = 0;
40738 wxWindow *arg1 = (wxWindow *) 0 ;
40739 bool result;
40740 void *argp1 = 0 ;
40741 int res1 = 0 ;
40742 PyObject *swig_obj[1] ;
40743
40744 if (!args) SWIG_fail;
40745 swig_obj[0] = args;
40746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40747 if (!SWIG_IsOK(res1)) {
40748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40749 }
40750 arg1 = reinterpret_cast< wxWindow * >(argp1);
40751 {
40752 PyThreadState* __tstate = wxPyBeginAllowThreads();
40753 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40754 wxPyEndAllowThreads(__tstate);
40755 if (PyErr_Occurred()) SWIG_fail;
40756 }
40757 {
40758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40759 }
40760 return resultobj;
40761 fail:
40762 return NULL;
40763 }
40764
40765
40766 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40767 PyObject *resultobj = 0;
40768 wxWindow *arg1 = (wxWindow *) 0 ;
40769 bool result;
40770 void *argp1 = 0 ;
40771 int res1 = 0 ;
40772 PyObject *swig_obj[1] ;
40773
40774 if (!args) SWIG_fail;
40775 swig_obj[0] = args;
40776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40777 if (!SWIG_IsOK(res1)) {
40778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40779 }
40780 arg1 = reinterpret_cast< wxWindow * >(argp1);
40781 {
40782 PyThreadState* __tstate = wxPyBeginAllowThreads();
40783 result = (bool)(arg1)->Layout();
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 {
40788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40789 }
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40797 PyObject *resultobj = 0;
40798 wxWindow *arg1 = (wxWindow *) 0 ;
40799 wxSizer *arg2 = (wxSizer *) 0 ;
40800 bool arg3 = (bool) true ;
40801 void *argp1 = 0 ;
40802 int res1 = 0 ;
40803 int res2 = 0 ;
40804 bool val3 ;
40805 int ecode3 = 0 ;
40806 PyObject * obj0 = 0 ;
40807 PyObject * obj1 = 0 ;
40808 PyObject * obj2 = 0 ;
40809 char * kwnames[] = {
40810 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40811 };
40812
40813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40817 }
40818 arg1 = reinterpret_cast< wxWindow * >(argp1);
40819 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40820 if (!SWIG_IsOK(res2)) {
40821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40822 }
40823 if (obj2) {
40824 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40825 if (!SWIG_IsOK(ecode3)) {
40826 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40827 }
40828 arg3 = static_cast< bool >(val3);
40829 }
40830 {
40831 PyThreadState* __tstate = wxPyBeginAllowThreads();
40832 (arg1)->SetSizer(arg2,arg3);
40833 wxPyEndAllowThreads(__tstate);
40834 if (PyErr_Occurred()) SWIG_fail;
40835 }
40836 resultobj = SWIG_Py_Void();
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40844 PyObject *resultobj = 0;
40845 wxWindow *arg1 = (wxWindow *) 0 ;
40846 wxSizer *arg2 = (wxSizer *) 0 ;
40847 bool arg3 = (bool) true ;
40848 void *argp1 = 0 ;
40849 int res1 = 0 ;
40850 int res2 = 0 ;
40851 bool val3 ;
40852 int ecode3 = 0 ;
40853 PyObject * obj0 = 0 ;
40854 PyObject * obj1 = 0 ;
40855 PyObject * obj2 = 0 ;
40856 char * kwnames[] = {
40857 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40858 };
40859
40860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40862 if (!SWIG_IsOK(res1)) {
40863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40864 }
40865 arg1 = reinterpret_cast< wxWindow * >(argp1);
40866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40867 if (!SWIG_IsOK(res2)) {
40868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40869 }
40870 if (obj2) {
40871 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40872 if (!SWIG_IsOK(ecode3)) {
40873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40874 }
40875 arg3 = static_cast< bool >(val3);
40876 }
40877 {
40878 PyThreadState* __tstate = wxPyBeginAllowThreads();
40879 (arg1)->SetSizerAndFit(arg2,arg3);
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 resultobj = SWIG_Py_Void();
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40891 PyObject *resultobj = 0;
40892 wxWindow *arg1 = (wxWindow *) 0 ;
40893 wxSizer *result = 0 ;
40894 void *argp1 = 0 ;
40895 int res1 = 0 ;
40896 PyObject *swig_obj[1] ;
40897
40898 if (!args) SWIG_fail;
40899 swig_obj[0] = args;
40900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40901 if (!SWIG_IsOK(res1)) {
40902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40903 }
40904 arg1 = reinterpret_cast< wxWindow * >(argp1);
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 {
40912 resultobj = wxPyMake_wxObject(result, (bool)0);
40913 }
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj = 0;
40922 wxWindow *arg1 = (wxWindow *) 0 ;
40923 wxSizer *arg2 = (wxSizer *) 0 ;
40924 void *argp1 = 0 ;
40925 int res1 = 0 ;
40926 void *argp2 = 0 ;
40927 int res2 = 0 ;
40928 PyObject * obj0 = 0 ;
40929 PyObject * obj1 = 0 ;
40930 char * kwnames[] = {
40931 (char *) "self",(char *) "sizer", NULL
40932 };
40933
40934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",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_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40938 }
40939 arg1 = reinterpret_cast< wxWindow * >(argp1);
40940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40941 if (!SWIG_IsOK(res2)) {
40942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40943 }
40944 arg2 = reinterpret_cast< wxSizer * >(argp2);
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 (arg1)->SetContainingSizer(arg2);
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 resultobj = SWIG_Py_Void();
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40959 PyObject *resultobj = 0;
40960 wxWindow *arg1 = (wxWindow *) 0 ;
40961 wxSizer *result = 0 ;
40962 void *argp1 = 0 ;
40963 int res1 = 0 ;
40964 PyObject *swig_obj[1] ;
40965
40966 if (!args) SWIG_fail;
40967 swig_obj[0] = args;
40968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40969 if (!SWIG_IsOK(res1)) {
40970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40971 }
40972 arg1 = reinterpret_cast< wxWindow * >(argp1);
40973 {
40974 PyThreadState* __tstate = wxPyBeginAllowThreads();
40975 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40976 wxPyEndAllowThreads(__tstate);
40977 if (PyErr_Occurred()) SWIG_fail;
40978 }
40979 {
40980 resultobj = wxPyMake_wxObject(result, (bool)0);
40981 }
40982 return resultobj;
40983 fail:
40984 return NULL;
40985 }
40986
40987
40988 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40989 PyObject *resultobj = 0;
40990 wxWindow *arg1 = (wxWindow *) 0 ;
40991 void *argp1 = 0 ;
40992 int res1 = 0 ;
40993 PyObject *swig_obj[1] ;
40994
40995 if (!args) SWIG_fail;
40996 swig_obj[0] = args;
40997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41000 }
41001 arg1 = reinterpret_cast< wxWindow * >(argp1);
41002 {
41003 PyThreadState* __tstate = wxPyBeginAllowThreads();
41004 (arg1)->InheritAttributes();
41005 wxPyEndAllowThreads(__tstate);
41006 if (PyErr_Occurred()) SWIG_fail;
41007 }
41008 resultobj = SWIG_Py_Void();
41009 return resultobj;
41010 fail:
41011 return NULL;
41012 }
41013
41014
41015 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41016 PyObject *resultobj = 0;
41017 wxWindow *arg1 = (wxWindow *) 0 ;
41018 bool result;
41019 void *argp1 = 0 ;
41020 int res1 = 0 ;
41021 PyObject *swig_obj[1] ;
41022
41023 if (!args) SWIG_fail;
41024 swig_obj[0] = args;
41025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41026 if (!SWIG_IsOK(res1)) {
41027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41028 }
41029 arg1 = reinterpret_cast< wxWindow * >(argp1);
41030 {
41031 PyThreadState* __tstate = wxPyBeginAllowThreads();
41032 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41033 wxPyEndAllowThreads(__tstate);
41034 if (PyErr_Occurred()) SWIG_fail;
41035 }
41036 {
41037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41038 }
41039 return resultobj;
41040 fail:
41041 return NULL;
41042 }
41043
41044
41045 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41046 PyObject *resultobj = 0;
41047 wxWindow *arg1 = (wxWindow *) 0 ;
41048 bool result;
41049 void *argp1 = 0 ;
41050 int res1 = 0 ;
41051 PyObject *swig_obj[1] ;
41052
41053 if (!args) SWIG_fail;
41054 swig_obj[0] = args;
41055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41056 if (!SWIG_IsOK(res1)) {
41057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41058 }
41059 arg1 = reinterpret_cast< wxWindow * >(argp1);
41060 {
41061 PyThreadState* __tstate = wxPyBeginAllowThreads();
41062 result = (bool)(arg1)->CanSetTransparent();
41063 wxPyEndAllowThreads(__tstate);
41064 if (PyErr_Occurred()) SWIG_fail;
41065 }
41066 {
41067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41068 }
41069 return resultobj;
41070 fail:
41071 return NULL;
41072 }
41073
41074
41075 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41076 PyObject *resultobj = 0;
41077 wxWindow *arg1 = (wxWindow *) 0 ;
41078 byte arg2 ;
41079 bool result;
41080 void *argp1 = 0 ;
41081 int res1 = 0 ;
41082 unsigned char val2 ;
41083 int ecode2 = 0 ;
41084 PyObject * obj0 = 0 ;
41085 PyObject * obj1 = 0 ;
41086 char * kwnames[] = {
41087 (char *) "self",(char *) "alpha", NULL
41088 };
41089
41090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41092 if (!SWIG_IsOK(res1)) {
41093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41094 }
41095 arg1 = reinterpret_cast< wxWindow * >(argp1);
41096 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41097 if (!SWIG_IsOK(ecode2)) {
41098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41099 }
41100 arg2 = static_cast< byte >(val2);
41101 {
41102 PyThreadState* __tstate = wxPyBeginAllowThreads();
41103 result = (bool)(arg1)->SetTransparent(arg2);
41104 wxPyEndAllowThreads(__tstate);
41105 if (PyErr_Occurred()) SWIG_fail;
41106 }
41107 {
41108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41109 }
41110 return resultobj;
41111 fail:
41112 return NULL;
41113 }
41114
41115
41116 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41117 PyObject *obj;
41118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41119 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41120 return SWIG_Py_Void();
41121 }
41122
41123 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41124 return SWIG_Python_InitShadowInstance(args);
41125 }
41126
41127 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41128 PyObject *resultobj = 0;
41129 long arg1 ;
41130 wxWindow *arg2 = (wxWindow *) NULL ;
41131 wxWindow *result = 0 ;
41132 long val1 ;
41133 int ecode1 = 0 ;
41134 void *argp2 = 0 ;
41135 int res2 = 0 ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 char * kwnames[] = {
41139 (char *) "id",(char *) "parent", NULL
41140 };
41141
41142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41143 ecode1 = SWIG_AsVal_long(obj0, &val1);
41144 if (!SWIG_IsOK(ecode1)) {
41145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41146 }
41147 arg1 = static_cast< long >(val1);
41148 if (obj1) {
41149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41150 if (!SWIG_IsOK(res2)) {
41151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41152 }
41153 arg2 = reinterpret_cast< wxWindow * >(argp2);
41154 }
41155 {
41156 if (!wxPyCheckForApp()) SWIG_fail;
41157 PyThreadState* __tstate = wxPyBeginAllowThreads();
41158 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41159 wxPyEndAllowThreads(__tstate);
41160 if (PyErr_Occurred()) SWIG_fail;
41161 }
41162 {
41163 resultobj = wxPyMake_wxObject(result, 0);
41164 }
41165 return resultobj;
41166 fail:
41167 return NULL;
41168 }
41169
41170
41171 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41172 PyObject *resultobj = 0;
41173 wxString *arg1 = 0 ;
41174 wxWindow *arg2 = (wxWindow *) NULL ;
41175 wxWindow *result = 0 ;
41176 bool temp1 = false ;
41177 void *argp2 = 0 ;
41178 int res2 = 0 ;
41179 PyObject * obj0 = 0 ;
41180 PyObject * obj1 = 0 ;
41181 char * kwnames[] = {
41182 (char *) "name",(char *) "parent", NULL
41183 };
41184
41185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41186 {
41187 arg1 = wxString_in_helper(obj0);
41188 if (arg1 == NULL) SWIG_fail;
41189 temp1 = true;
41190 }
41191 if (obj1) {
41192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41193 if (!SWIG_IsOK(res2)) {
41194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41195 }
41196 arg2 = reinterpret_cast< wxWindow * >(argp2);
41197 }
41198 {
41199 if (!wxPyCheckForApp()) SWIG_fail;
41200 PyThreadState* __tstate = wxPyBeginAllowThreads();
41201 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41202 wxPyEndAllowThreads(__tstate);
41203 if (PyErr_Occurred()) SWIG_fail;
41204 }
41205 {
41206 resultobj = wxPyMake_wxObject(result, 0);
41207 }
41208 {
41209 if (temp1)
41210 delete arg1;
41211 }
41212 return resultobj;
41213 fail:
41214 {
41215 if (temp1)
41216 delete arg1;
41217 }
41218 return NULL;
41219 }
41220
41221
41222 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41223 PyObject *resultobj = 0;
41224 wxString *arg1 = 0 ;
41225 wxWindow *arg2 = (wxWindow *) NULL ;
41226 wxWindow *result = 0 ;
41227 bool temp1 = false ;
41228 void *argp2 = 0 ;
41229 int res2 = 0 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char * kwnames[] = {
41233 (char *) "label",(char *) "parent", NULL
41234 };
41235
41236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41237 {
41238 arg1 = wxString_in_helper(obj0);
41239 if (arg1 == NULL) SWIG_fail;
41240 temp1 = true;
41241 }
41242 if (obj1) {
41243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41244 if (!SWIG_IsOK(res2)) {
41245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41246 }
41247 arg2 = reinterpret_cast< wxWindow * >(argp2);
41248 }
41249 {
41250 if (!wxPyCheckForApp()) SWIG_fail;
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41253 wxPyEndAllowThreads(__tstate);
41254 if (PyErr_Occurred()) SWIG_fail;
41255 }
41256 {
41257 resultobj = wxPyMake_wxObject(result, 0);
41258 }
41259 {
41260 if (temp1)
41261 delete arg1;
41262 }
41263 return resultobj;
41264 fail:
41265 {
41266 if (temp1)
41267 delete arg1;
41268 }
41269 return NULL;
41270 }
41271
41272
41273 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41274 PyObject *resultobj = 0;
41275 wxWindow *arg1 = (wxWindow *) 0 ;
41276 unsigned long arg2 ;
41277 wxWindow *result = 0 ;
41278 void *argp1 = 0 ;
41279 int res1 = 0 ;
41280 unsigned long val2 ;
41281 int ecode2 = 0 ;
41282 PyObject * obj0 = 0 ;
41283 PyObject * obj1 = 0 ;
41284 char * kwnames[] = {
41285 (char *) "parent",(char *) "_hWnd", NULL
41286 };
41287
41288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41290 if (!SWIG_IsOK(res1)) {
41291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41292 }
41293 arg1 = reinterpret_cast< wxWindow * >(argp1);
41294 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41295 if (!SWIG_IsOK(ecode2)) {
41296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41297 }
41298 arg2 = static_cast< unsigned long >(val2);
41299 {
41300 if (!wxPyCheckForApp()) SWIG_fail;
41301 PyThreadState* __tstate = wxPyBeginAllowThreads();
41302 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41303 wxPyEndAllowThreads(__tstate);
41304 if (PyErr_Occurred()) SWIG_fail;
41305 }
41306 {
41307 resultobj = wxPyMake_wxObject(result, 0);
41308 }
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41316 PyObject *resultobj = 0;
41317 PyObject *result = 0 ;
41318
41319 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41320 {
41321 PyThreadState* __tstate = wxPyBeginAllowThreads();
41322 result = (PyObject *)GetTopLevelWindows();
41323 wxPyEndAllowThreads(__tstate);
41324 if (PyErr_Occurred()) SWIG_fail;
41325 }
41326 resultobj = result;
41327 return resultobj;
41328 fail:
41329 return NULL;
41330 }
41331
41332
41333 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41334 PyObject *resultobj = 0;
41335 wxValidator *result = 0 ;
41336
41337 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41338 {
41339 PyThreadState* __tstate = wxPyBeginAllowThreads();
41340 result = (wxValidator *)new wxValidator();
41341 wxPyEndAllowThreads(__tstate);
41342 if (PyErr_Occurred()) SWIG_fail;
41343 }
41344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41345 return resultobj;
41346 fail:
41347 return NULL;
41348 }
41349
41350
41351 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41352 PyObject *resultobj = 0;
41353 wxValidator *arg1 = (wxValidator *) 0 ;
41354 wxValidator *result = 0 ;
41355 void *argp1 = 0 ;
41356 int res1 = 0 ;
41357 PyObject *swig_obj[1] ;
41358
41359 if (!args) SWIG_fail;
41360 swig_obj[0] = args;
41361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41362 if (!SWIG_IsOK(res1)) {
41363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41364 }
41365 arg1 = reinterpret_cast< wxValidator * >(argp1);
41366 {
41367 PyThreadState* __tstate = wxPyBeginAllowThreads();
41368 result = (wxValidator *)(arg1)->Clone();
41369 wxPyEndAllowThreads(__tstate);
41370 if (PyErr_Occurred()) SWIG_fail;
41371 }
41372 {
41373 resultobj = wxPyMake_wxObject(result, 0);
41374 }
41375 return resultobj;
41376 fail:
41377 return NULL;
41378 }
41379
41380
41381 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41382 PyObject *resultobj = 0;
41383 wxValidator *arg1 = (wxValidator *) 0 ;
41384 wxWindow *arg2 = (wxWindow *) 0 ;
41385 bool result;
41386 void *argp1 = 0 ;
41387 int res1 = 0 ;
41388 void *argp2 = 0 ;
41389 int res2 = 0 ;
41390 PyObject * obj0 = 0 ;
41391 PyObject * obj1 = 0 ;
41392 char * kwnames[] = {
41393 (char *) "self",(char *) "parent", NULL
41394 };
41395
41396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41398 if (!SWIG_IsOK(res1)) {
41399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41400 }
41401 arg1 = reinterpret_cast< wxValidator * >(argp1);
41402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41403 if (!SWIG_IsOK(res2)) {
41404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41405 }
41406 arg2 = reinterpret_cast< wxWindow * >(argp2);
41407 {
41408 PyThreadState* __tstate = wxPyBeginAllowThreads();
41409 result = (bool)(arg1)->Validate(arg2);
41410 wxPyEndAllowThreads(__tstate);
41411 if (PyErr_Occurred()) SWIG_fail;
41412 }
41413 {
41414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41415 }
41416 return resultobj;
41417 fail:
41418 return NULL;
41419 }
41420
41421
41422 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41423 PyObject *resultobj = 0;
41424 wxValidator *arg1 = (wxValidator *) 0 ;
41425 bool result;
41426 void *argp1 = 0 ;
41427 int res1 = 0 ;
41428 PyObject *swig_obj[1] ;
41429
41430 if (!args) SWIG_fail;
41431 swig_obj[0] = args;
41432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41433 if (!SWIG_IsOK(res1)) {
41434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41435 }
41436 arg1 = reinterpret_cast< wxValidator * >(argp1);
41437 {
41438 PyThreadState* __tstate = wxPyBeginAllowThreads();
41439 result = (bool)(arg1)->TransferToWindow();
41440 wxPyEndAllowThreads(__tstate);
41441 if (PyErr_Occurred()) SWIG_fail;
41442 }
41443 {
41444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41445 }
41446 return resultobj;
41447 fail:
41448 return NULL;
41449 }
41450
41451
41452 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41453 PyObject *resultobj = 0;
41454 wxValidator *arg1 = (wxValidator *) 0 ;
41455 bool result;
41456 void *argp1 = 0 ;
41457 int res1 = 0 ;
41458 PyObject *swig_obj[1] ;
41459
41460 if (!args) SWIG_fail;
41461 swig_obj[0] = args;
41462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41463 if (!SWIG_IsOK(res1)) {
41464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41465 }
41466 arg1 = reinterpret_cast< wxValidator * >(argp1);
41467 {
41468 PyThreadState* __tstate = wxPyBeginAllowThreads();
41469 result = (bool)(arg1)->TransferFromWindow();
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 {
41474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41475 }
41476 return resultobj;
41477 fail:
41478 return NULL;
41479 }
41480
41481
41482 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41483 PyObject *resultobj = 0;
41484 wxValidator *arg1 = (wxValidator *) 0 ;
41485 wxWindow *result = 0 ;
41486 void *argp1 = 0 ;
41487 int res1 = 0 ;
41488 PyObject *swig_obj[1] ;
41489
41490 if (!args) SWIG_fail;
41491 swig_obj[0] = args;
41492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41493 if (!SWIG_IsOK(res1)) {
41494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41495 }
41496 arg1 = reinterpret_cast< wxValidator * >(argp1);
41497 {
41498 PyThreadState* __tstate = wxPyBeginAllowThreads();
41499 result = (wxWindow *)(arg1)->GetWindow();
41500 wxPyEndAllowThreads(__tstate);
41501 if (PyErr_Occurred()) SWIG_fail;
41502 }
41503 {
41504 resultobj = wxPyMake_wxObject(result, 0);
41505 }
41506 return resultobj;
41507 fail:
41508 return NULL;
41509 }
41510
41511
41512 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41513 PyObject *resultobj = 0;
41514 wxValidator *arg1 = (wxValidator *) 0 ;
41515 wxWindow *arg2 = (wxWindow *) 0 ;
41516 void *argp1 = 0 ;
41517 int res1 = 0 ;
41518 void *argp2 = 0 ;
41519 int res2 = 0 ;
41520 PyObject * obj0 = 0 ;
41521 PyObject * obj1 = 0 ;
41522 char * kwnames[] = {
41523 (char *) "self",(char *) "window", NULL
41524 };
41525
41526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41528 if (!SWIG_IsOK(res1)) {
41529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41530 }
41531 arg1 = reinterpret_cast< wxValidator * >(argp1);
41532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41533 if (!SWIG_IsOK(res2)) {
41534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41535 }
41536 arg2 = reinterpret_cast< wxWindow * >(argp2);
41537 {
41538 PyThreadState* __tstate = wxPyBeginAllowThreads();
41539 (arg1)->SetWindow(arg2);
41540 wxPyEndAllowThreads(__tstate);
41541 if (PyErr_Occurred()) SWIG_fail;
41542 }
41543 resultobj = SWIG_Py_Void();
41544 return resultobj;
41545 fail:
41546 return NULL;
41547 }
41548
41549
41550 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41551 PyObject *resultobj = 0;
41552 bool result;
41553
41554 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41555 {
41556 PyThreadState* __tstate = wxPyBeginAllowThreads();
41557 result = (bool)wxValidator::IsSilent();
41558 wxPyEndAllowThreads(__tstate);
41559 if (PyErr_Occurred()) SWIG_fail;
41560 }
41561 {
41562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41563 }
41564 return resultobj;
41565 fail:
41566 return NULL;
41567 }
41568
41569
41570 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41571 PyObject *resultobj = 0;
41572 int arg1 = (int) true ;
41573 int val1 ;
41574 int ecode1 = 0 ;
41575 PyObject * obj0 = 0 ;
41576 char * kwnames[] = {
41577 (char *) "doIt", NULL
41578 };
41579
41580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41581 if (obj0) {
41582 ecode1 = SWIG_AsVal_int(obj0, &val1);
41583 if (!SWIG_IsOK(ecode1)) {
41584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41585 }
41586 arg1 = static_cast< int >(val1);
41587 }
41588 {
41589 PyThreadState* __tstate = wxPyBeginAllowThreads();
41590 wxValidator::SetBellOnError(arg1);
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 resultobj = SWIG_Py_Void();
41595 return resultobj;
41596 fail:
41597 return NULL;
41598 }
41599
41600
41601 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41602 PyObject *obj;
41603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41604 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41605 return SWIG_Py_Void();
41606 }
41607
41608 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41609 return SWIG_Python_InitShadowInstance(args);
41610 }
41611
41612 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41613 PyObject *resultobj = 0;
41614 wxPyValidator *result = 0 ;
41615
41616 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41617 {
41618 PyThreadState* __tstate = wxPyBeginAllowThreads();
41619 result = (wxPyValidator *)new wxPyValidator();
41620 wxPyEndAllowThreads(__tstate);
41621 if (PyErr_Occurred()) SWIG_fail;
41622 }
41623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41624 return resultobj;
41625 fail:
41626 return NULL;
41627 }
41628
41629
41630 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41631 PyObject *resultobj = 0;
41632 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41633 PyObject *arg2 = (PyObject *) 0 ;
41634 PyObject *arg3 = (PyObject *) 0 ;
41635 int arg4 = (int) 1 ;
41636 void *argp1 = 0 ;
41637 int res1 = 0 ;
41638 int val4 ;
41639 int ecode4 = 0 ;
41640 PyObject * obj0 = 0 ;
41641 PyObject * obj1 = 0 ;
41642 PyObject * obj2 = 0 ;
41643 PyObject * obj3 = 0 ;
41644 char * kwnames[] = {
41645 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41646 };
41647
41648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41650 if (!SWIG_IsOK(res1)) {
41651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41652 }
41653 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41654 arg2 = obj1;
41655 arg3 = obj2;
41656 if (obj3) {
41657 ecode4 = SWIG_AsVal_int(obj3, &val4);
41658 if (!SWIG_IsOK(ecode4)) {
41659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41660 }
41661 arg4 = static_cast< int >(val4);
41662 }
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 resultobj = SWIG_Py_Void();
41670 return resultobj;
41671 fail:
41672 return NULL;
41673 }
41674
41675
41676 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41677 PyObject *obj;
41678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41679 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41680 return SWIG_Py_Void();
41681 }
41682
41683 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41684 return SWIG_Python_InitShadowInstance(args);
41685 }
41686
41687 SWIGINTERN int DefaultValidator_set(PyObject *) {
41688 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41689 return 1;
41690 }
41691
41692
41693 SWIGINTERN PyObject *DefaultValidator_get(void) {
41694 PyObject *pyobj = 0;
41695
41696 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41697 return pyobj;
41698 }
41699
41700
41701 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj = 0;
41703 wxString const &arg1_defvalue = wxPyEmptyString ;
41704 wxString *arg1 = (wxString *) &arg1_defvalue ;
41705 long arg2 = (long) 0 ;
41706 wxMenu *result = 0 ;
41707 bool temp1 = false ;
41708 long val2 ;
41709 int ecode2 = 0 ;
41710 PyObject * obj0 = 0 ;
41711 PyObject * obj1 = 0 ;
41712 char * kwnames[] = {
41713 (char *) "title",(char *) "style", NULL
41714 };
41715
41716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41717 if (obj0) {
41718 {
41719 arg1 = wxString_in_helper(obj0);
41720 if (arg1 == NULL) SWIG_fail;
41721 temp1 = true;
41722 }
41723 }
41724 if (obj1) {
41725 ecode2 = SWIG_AsVal_long(obj1, &val2);
41726 if (!SWIG_IsOK(ecode2)) {
41727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41728 }
41729 arg2 = static_cast< long >(val2);
41730 }
41731 {
41732 if (!wxPyCheckForApp()) SWIG_fail;
41733 PyThreadState* __tstate = wxPyBeginAllowThreads();
41734 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41735 wxPyEndAllowThreads(__tstate);
41736 if (PyErr_Occurred()) SWIG_fail;
41737 }
41738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41739 {
41740 if (temp1)
41741 delete arg1;
41742 }
41743 return resultobj;
41744 fail:
41745 {
41746 if (temp1)
41747 delete arg1;
41748 }
41749 return NULL;
41750 }
41751
41752
41753 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41754 PyObject *resultobj = 0;
41755 wxMenu *arg1 = (wxMenu *) 0 ;
41756 int arg2 ;
41757 wxString const &arg3_defvalue = wxPyEmptyString ;
41758 wxString *arg3 = (wxString *) &arg3_defvalue ;
41759 wxString const &arg4_defvalue = wxPyEmptyString ;
41760 wxString *arg4 = (wxString *) &arg4_defvalue ;
41761 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41762 wxMenuItem *result = 0 ;
41763 void *argp1 = 0 ;
41764 int res1 = 0 ;
41765 int val2 ;
41766 int ecode2 = 0 ;
41767 bool temp3 = false ;
41768 bool temp4 = false ;
41769 int val5 ;
41770 int ecode5 = 0 ;
41771 PyObject * obj0 = 0 ;
41772 PyObject * obj1 = 0 ;
41773 PyObject * obj2 = 0 ;
41774 PyObject * obj3 = 0 ;
41775 PyObject * obj4 = 0 ;
41776 char * kwnames[] = {
41777 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41778 };
41779
41780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41782 if (!SWIG_IsOK(res1)) {
41783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41784 }
41785 arg1 = reinterpret_cast< wxMenu * >(argp1);
41786 ecode2 = SWIG_AsVal_int(obj1, &val2);
41787 if (!SWIG_IsOK(ecode2)) {
41788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41789 }
41790 arg2 = static_cast< int >(val2);
41791 if (obj2) {
41792 {
41793 arg3 = wxString_in_helper(obj2);
41794 if (arg3 == NULL) SWIG_fail;
41795 temp3 = true;
41796 }
41797 }
41798 if (obj3) {
41799 {
41800 arg4 = wxString_in_helper(obj3);
41801 if (arg4 == NULL) SWIG_fail;
41802 temp4 = true;
41803 }
41804 }
41805 if (obj4) {
41806 ecode5 = SWIG_AsVal_int(obj4, &val5);
41807 if (!SWIG_IsOK(ecode5)) {
41808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41809 }
41810 arg5 = static_cast< wxItemKind >(val5);
41811 }
41812 {
41813 PyThreadState* __tstate = wxPyBeginAllowThreads();
41814 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 {
41819 resultobj = wxPyMake_wxObject(result, (bool)0);
41820 }
41821 {
41822 if (temp3)
41823 delete arg3;
41824 }
41825 {
41826 if (temp4)
41827 delete arg4;
41828 }
41829 return resultobj;
41830 fail:
41831 {
41832 if (temp3)
41833 delete arg3;
41834 }
41835 {
41836 if (temp4)
41837 delete arg4;
41838 }
41839 return NULL;
41840 }
41841
41842
41843 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41844 PyObject *resultobj = 0;
41845 wxMenu *arg1 = (wxMenu *) 0 ;
41846 wxMenuItem *result = 0 ;
41847 void *argp1 = 0 ;
41848 int res1 = 0 ;
41849 PyObject *swig_obj[1] ;
41850
41851 if (!args) SWIG_fail;
41852 swig_obj[0] = args;
41853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41854 if (!SWIG_IsOK(res1)) {
41855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41856 }
41857 arg1 = reinterpret_cast< wxMenu * >(argp1);
41858 {
41859 PyThreadState* __tstate = wxPyBeginAllowThreads();
41860 result = (wxMenuItem *)(arg1)->AppendSeparator();
41861 wxPyEndAllowThreads(__tstate);
41862 if (PyErr_Occurred()) SWIG_fail;
41863 }
41864 {
41865 resultobj = wxPyMake_wxObject(result, (bool)0);
41866 }
41867 return resultobj;
41868 fail:
41869 return NULL;
41870 }
41871
41872
41873 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41874 PyObject *resultobj = 0;
41875 wxMenu *arg1 = (wxMenu *) 0 ;
41876 int arg2 ;
41877 wxString *arg3 = 0 ;
41878 wxString const &arg4_defvalue = wxPyEmptyString ;
41879 wxString *arg4 = (wxString *) &arg4_defvalue ;
41880 wxMenuItem *result = 0 ;
41881 void *argp1 = 0 ;
41882 int res1 = 0 ;
41883 int val2 ;
41884 int ecode2 = 0 ;
41885 bool temp3 = false ;
41886 bool temp4 = false ;
41887 PyObject * obj0 = 0 ;
41888 PyObject * obj1 = 0 ;
41889 PyObject * obj2 = 0 ;
41890 PyObject * obj3 = 0 ;
41891 char * kwnames[] = {
41892 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41893 };
41894
41895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41897 if (!SWIG_IsOK(res1)) {
41898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41899 }
41900 arg1 = reinterpret_cast< wxMenu * >(argp1);
41901 ecode2 = SWIG_AsVal_int(obj1, &val2);
41902 if (!SWIG_IsOK(ecode2)) {
41903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41904 }
41905 arg2 = static_cast< int >(val2);
41906 {
41907 arg3 = wxString_in_helper(obj2);
41908 if (arg3 == NULL) SWIG_fail;
41909 temp3 = true;
41910 }
41911 if (obj3) {
41912 {
41913 arg4 = wxString_in_helper(obj3);
41914 if (arg4 == NULL) SWIG_fail;
41915 temp4 = true;
41916 }
41917 }
41918 {
41919 PyThreadState* __tstate = wxPyBeginAllowThreads();
41920 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 {
41925 resultobj = wxPyMake_wxObject(result, (bool)0);
41926 }
41927 {
41928 if (temp3)
41929 delete arg3;
41930 }
41931 {
41932 if (temp4)
41933 delete arg4;
41934 }
41935 return resultobj;
41936 fail:
41937 {
41938 if (temp3)
41939 delete arg3;
41940 }
41941 {
41942 if (temp4)
41943 delete arg4;
41944 }
41945 return NULL;
41946 }
41947
41948
41949 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41950 PyObject *resultobj = 0;
41951 wxMenu *arg1 = (wxMenu *) 0 ;
41952 int arg2 ;
41953 wxString *arg3 = 0 ;
41954 wxString const &arg4_defvalue = wxPyEmptyString ;
41955 wxString *arg4 = (wxString *) &arg4_defvalue ;
41956 wxMenuItem *result = 0 ;
41957 void *argp1 = 0 ;
41958 int res1 = 0 ;
41959 int val2 ;
41960 int ecode2 = 0 ;
41961 bool temp3 = false ;
41962 bool temp4 = false ;
41963 PyObject * obj0 = 0 ;
41964 PyObject * obj1 = 0 ;
41965 PyObject * obj2 = 0 ;
41966 PyObject * obj3 = 0 ;
41967 char * kwnames[] = {
41968 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41969 };
41970
41971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41973 if (!SWIG_IsOK(res1)) {
41974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41975 }
41976 arg1 = reinterpret_cast< wxMenu * >(argp1);
41977 ecode2 = SWIG_AsVal_int(obj1, &val2);
41978 if (!SWIG_IsOK(ecode2)) {
41979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41980 }
41981 arg2 = static_cast< int >(val2);
41982 {
41983 arg3 = wxString_in_helper(obj2);
41984 if (arg3 == NULL) SWIG_fail;
41985 temp3 = true;
41986 }
41987 if (obj3) {
41988 {
41989 arg4 = wxString_in_helper(obj3);
41990 if (arg4 == NULL) SWIG_fail;
41991 temp4 = true;
41992 }
41993 }
41994 {
41995 PyThreadState* __tstate = wxPyBeginAllowThreads();
41996 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41997 wxPyEndAllowThreads(__tstate);
41998 if (PyErr_Occurred()) SWIG_fail;
41999 }
42000 {
42001 resultobj = wxPyMake_wxObject(result, (bool)0);
42002 }
42003 {
42004 if (temp3)
42005 delete arg3;
42006 }
42007 {
42008 if (temp4)
42009 delete arg4;
42010 }
42011 return resultobj;
42012 fail:
42013 {
42014 if (temp3)
42015 delete arg3;
42016 }
42017 {
42018 if (temp4)
42019 delete arg4;
42020 }
42021 return NULL;
42022 }
42023
42024
42025 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42026 PyObject *resultobj = 0;
42027 wxMenu *arg1 = (wxMenu *) 0 ;
42028 int arg2 ;
42029 wxString *arg3 = 0 ;
42030 wxMenu *arg4 = (wxMenu *) 0 ;
42031 wxString const &arg5_defvalue = wxPyEmptyString ;
42032 wxString *arg5 = (wxString *) &arg5_defvalue ;
42033 wxMenuItem *result = 0 ;
42034 void *argp1 = 0 ;
42035 int res1 = 0 ;
42036 int val2 ;
42037 int ecode2 = 0 ;
42038 bool temp3 = false ;
42039 void *argp4 = 0 ;
42040 int res4 = 0 ;
42041 bool temp5 = false ;
42042 PyObject * obj0 = 0 ;
42043 PyObject * obj1 = 0 ;
42044 PyObject * obj2 = 0 ;
42045 PyObject * obj3 = 0 ;
42046 PyObject * obj4 = 0 ;
42047 char * kwnames[] = {
42048 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42049 };
42050
42051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42053 if (!SWIG_IsOK(res1)) {
42054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42055 }
42056 arg1 = reinterpret_cast< wxMenu * >(argp1);
42057 ecode2 = SWIG_AsVal_int(obj1, &val2);
42058 if (!SWIG_IsOK(ecode2)) {
42059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42060 }
42061 arg2 = static_cast< int >(val2);
42062 {
42063 arg3 = wxString_in_helper(obj2);
42064 if (arg3 == NULL) SWIG_fail;
42065 temp3 = true;
42066 }
42067 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42068 if (!SWIG_IsOK(res4)) {
42069 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42070 }
42071 arg4 = reinterpret_cast< wxMenu * >(argp4);
42072 if (obj4) {
42073 {
42074 arg5 = wxString_in_helper(obj4);
42075 if (arg5 == NULL) SWIG_fail;
42076 temp5 = true;
42077 }
42078 }
42079 {
42080 PyThreadState* __tstate = wxPyBeginAllowThreads();
42081 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42082 wxPyEndAllowThreads(__tstate);
42083 if (PyErr_Occurred()) SWIG_fail;
42084 }
42085 {
42086 resultobj = wxPyMake_wxObject(result, (bool)0);
42087 }
42088 {
42089 if (temp3)
42090 delete arg3;
42091 }
42092 {
42093 if (temp5)
42094 delete arg5;
42095 }
42096 return resultobj;
42097 fail:
42098 {
42099 if (temp3)
42100 delete arg3;
42101 }
42102 {
42103 if (temp5)
42104 delete arg5;
42105 }
42106 return NULL;
42107 }
42108
42109
42110 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42111 PyObject *resultobj = 0;
42112 wxMenu *arg1 = (wxMenu *) 0 ;
42113 wxMenu *arg2 = (wxMenu *) 0 ;
42114 wxString *arg3 = 0 ;
42115 wxString const &arg4_defvalue = wxPyEmptyString ;
42116 wxString *arg4 = (wxString *) &arg4_defvalue ;
42117 wxMenuItem *result = 0 ;
42118 void *argp1 = 0 ;
42119 int res1 = 0 ;
42120 void *argp2 = 0 ;
42121 int res2 = 0 ;
42122 bool temp3 = false ;
42123 bool temp4 = false ;
42124 PyObject * obj0 = 0 ;
42125 PyObject * obj1 = 0 ;
42126 PyObject * obj2 = 0 ;
42127 PyObject * obj3 = 0 ;
42128 char * kwnames[] = {
42129 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42130 };
42131
42132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42134 if (!SWIG_IsOK(res1)) {
42135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42136 }
42137 arg1 = reinterpret_cast< wxMenu * >(argp1);
42138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42139 if (!SWIG_IsOK(res2)) {
42140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42141 }
42142 arg2 = reinterpret_cast< wxMenu * >(argp2);
42143 {
42144 arg3 = wxString_in_helper(obj2);
42145 if (arg3 == NULL) SWIG_fail;
42146 temp3 = true;
42147 }
42148 if (obj3) {
42149 {
42150 arg4 = wxString_in_helper(obj3);
42151 if (arg4 == NULL) SWIG_fail;
42152 temp4 = true;
42153 }
42154 }
42155 {
42156 PyThreadState* __tstate = wxPyBeginAllowThreads();
42157 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42158 wxPyEndAllowThreads(__tstate);
42159 if (PyErr_Occurred()) SWIG_fail;
42160 }
42161 {
42162 resultobj = wxPyMake_wxObject(result, (bool)0);
42163 }
42164 {
42165 if (temp3)
42166 delete arg3;
42167 }
42168 {
42169 if (temp4)
42170 delete arg4;
42171 }
42172 return resultobj;
42173 fail:
42174 {
42175 if (temp3)
42176 delete arg3;
42177 }
42178 {
42179 if (temp4)
42180 delete arg4;
42181 }
42182 return NULL;
42183 }
42184
42185
42186 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42187 PyObject *resultobj = 0;
42188 wxMenu *arg1 = (wxMenu *) 0 ;
42189 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42190 wxMenuItem *result = 0 ;
42191 void *argp1 = 0 ;
42192 int res1 = 0 ;
42193 int res2 = 0 ;
42194 PyObject * obj0 = 0 ;
42195 PyObject * obj1 = 0 ;
42196 char * kwnames[] = {
42197 (char *) "self",(char *) "item", NULL
42198 };
42199
42200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42202 if (!SWIG_IsOK(res1)) {
42203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42204 }
42205 arg1 = reinterpret_cast< wxMenu * >(argp1);
42206 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42207 if (!SWIG_IsOK(res2)) {
42208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42209 }
42210 {
42211 PyThreadState* __tstate = wxPyBeginAllowThreads();
42212 result = (wxMenuItem *)(arg1)->Append(arg2);
42213 wxPyEndAllowThreads(__tstate);
42214 if (PyErr_Occurred()) SWIG_fail;
42215 }
42216 {
42217 resultobj = wxPyMake_wxObject(result, (bool)0);
42218 }
42219 return resultobj;
42220 fail:
42221 return NULL;
42222 }
42223
42224
42225 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42226 PyObject *resultobj = 0;
42227 wxMenu *arg1 = (wxMenu *) 0 ;
42228 size_t arg2 ;
42229 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42230 wxMenuItem *result = 0 ;
42231 void *argp1 = 0 ;
42232 int res1 = 0 ;
42233 size_t val2 ;
42234 int ecode2 = 0 ;
42235 int res3 = 0 ;
42236 PyObject * obj0 = 0 ;
42237 PyObject * obj1 = 0 ;
42238 PyObject * obj2 = 0 ;
42239 char * kwnames[] = {
42240 (char *) "self",(char *) "pos",(char *) "item", NULL
42241 };
42242
42243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42245 if (!SWIG_IsOK(res1)) {
42246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42247 }
42248 arg1 = reinterpret_cast< wxMenu * >(argp1);
42249 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42250 if (!SWIG_IsOK(ecode2)) {
42251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42252 }
42253 arg2 = static_cast< size_t >(val2);
42254 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42255 if (!SWIG_IsOK(res3)) {
42256 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42257 }
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42261 wxPyEndAllowThreads(__tstate);
42262 if (PyErr_Occurred()) SWIG_fail;
42263 }
42264 {
42265 resultobj = wxPyMake_wxObject(result, (bool)0);
42266 }
42267 return resultobj;
42268 fail:
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42274 PyObject *resultobj = 0;
42275 wxMenu *arg1 = (wxMenu *) 0 ;
42276 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42277 wxMenuItem *result = 0 ;
42278 void *argp1 = 0 ;
42279 int res1 = 0 ;
42280 int res2 = 0 ;
42281 PyObject * obj0 = 0 ;
42282 PyObject * obj1 = 0 ;
42283 char * kwnames[] = {
42284 (char *) "self",(char *) "item", NULL
42285 };
42286
42287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42289 if (!SWIG_IsOK(res1)) {
42290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42291 }
42292 arg1 = reinterpret_cast< wxMenu * >(argp1);
42293 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42294 if (!SWIG_IsOK(res2)) {
42295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42296 }
42297 {
42298 PyThreadState* __tstate = wxPyBeginAllowThreads();
42299 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42300 wxPyEndAllowThreads(__tstate);
42301 if (PyErr_Occurred()) SWIG_fail;
42302 }
42303 {
42304 resultobj = wxPyMake_wxObject(result, (bool)0);
42305 }
42306 return resultobj;
42307 fail:
42308 return NULL;
42309 }
42310
42311
42312 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42313 PyObject *resultobj = 0;
42314 wxMenu *arg1 = (wxMenu *) 0 ;
42315 void *argp1 = 0 ;
42316 int res1 = 0 ;
42317 PyObject *swig_obj[1] ;
42318
42319 if (!args) SWIG_fail;
42320 swig_obj[0] = args;
42321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42322 if (!SWIG_IsOK(res1)) {
42323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42324 }
42325 arg1 = reinterpret_cast< wxMenu * >(argp1);
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 (arg1)->Break();
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 resultobj = SWIG_Py_Void();
42333 return resultobj;
42334 fail:
42335 return NULL;
42336 }
42337
42338
42339 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42340 PyObject *resultobj = 0;
42341 wxMenu *arg1 = (wxMenu *) 0 ;
42342 size_t arg2 ;
42343 int arg3 ;
42344 wxString const &arg4_defvalue = wxPyEmptyString ;
42345 wxString *arg4 = (wxString *) &arg4_defvalue ;
42346 wxString const &arg5_defvalue = wxPyEmptyString ;
42347 wxString *arg5 = (wxString *) &arg5_defvalue ;
42348 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42349 wxMenuItem *result = 0 ;
42350 void *argp1 = 0 ;
42351 int res1 = 0 ;
42352 size_t val2 ;
42353 int ecode2 = 0 ;
42354 int val3 ;
42355 int ecode3 = 0 ;
42356 bool temp4 = false ;
42357 bool temp5 = false ;
42358 int val6 ;
42359 int ecode6 = 0 ;
42360 PyObject * obj0 = 0 ;
42361 PyObject * obj1 = 0 ;
42362 PyObject * obj2 = 0 ;
42363 PyObject * obj3 = 0 ;
42364 PyObject * obj4 = 0 ;
42365 PyObject * obj5 = 0 ;
42366 char * kwnames[] = {
42367 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42368 };
42369
42370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42372 if (!SWIG_IsOK(res1)) {
42373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42374 }
42375 arg1 = reinterpret_cast< wxMenu * >(argp1);
42376 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42377 if (!SWIG_IsOK(ecode2)) {
42378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42379 }
42380 arg2 = static_cast< size_t >(val2);
42381 ecode3 = SWIG_AsVal_int(obj2, &val3);
42382 if (!SWIG_IsOK(ecode3)) {
42383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42384 }
42385 arg3 = static_cast< int >(val3);
42386 if (obj3) {
42387 {
42388 arg4 = wxString_in_helper(obj3);
42389 if (arg4 == NULL) SWIG_fail;
42390 temp4 = true;
42391 }
42392 }
42393 if (obj4) {
42394 {
42395 arg5 = wxString_in_helper(obj4);
42396 if (arg5 == NULL) SWIG_fail;
42397 temp5 = true;
42398 }
42399 }
42400 if (obj5) {
42401 ecode6 = SWIG_AsVal_int(obj5, &val6);
42402 if (!SWIG_IsOK(ecode6)) {
42403 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42404 }
42405 arg6 = static_cast< wxItemKind >(val6);
42406 }
42407 {
42408 PyThreadState* __tstate = wxPyBeginAllowThreads();
42409 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42410 wxPyEndAllowThreads(__tstate);
42411 if (PyErr_Occurred()) SWIG_fail;
42412 }
42413 {
42414 resultobj = wxPyMake_wxObject(result, (bool)0);
42415 }
42416 {
42417 if (temp4)
42418 delete arg4;
42419 }
42420 {
42421 if (temp5)
42422 delete arg5;
42423 }
42424 return resultobj;
42425 fail:
42426 {
42427 if (temp4)
42428 delete arg4;
42429 }
42430 {
42431 if (temp5)
42432 delete arg5;
42433 }
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxMenu *arg1 = (wxMenu *) 0 ;
42441 size_t arg2 ;
42442 wxMenuItem *result = 0 ;
42443 void *argp1 = 0 ;
42444 int res1 = 0 ;
42445 size_t val2 ;
42446 int ecode2 = 0 ;
42447 PyObject * obj0 = 0 ;
42448 PyObject * obj1 = 0 ;
42449 char * kwnames[] = {
42450 (char *) "self",(char *) "pos", NULL
42451 };
42452
42453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42455 if (!SWIG_IsOK(res1)) {
42456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42457 }
42458 arg1 = reinterpret_cast< wxMenu * >(argp1);
42459 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42460 if (!SWIG_IsOK(ecode2)) {
42461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42462 }
42463 arg2 = static_cast< size_t >(val2);
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42467 wxPyEndAllowThreads(__tstate);
42468 if (PyErr_Occurred()) SWIG_fail;
42469 }
42470 {
42471 resultobj = wxPyMake_wxObject(result, (bool)0);
42472 }
42473 return resultobj;
42474 fail:
42475 return NULL;
42476 }
42477
42478
42479 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42480 PyObject *resultobj = 0;
42481 wxMenu *arg1 = (wxMenu *) 0 ;
42482 size_t arg2 ;
42483 int arg3 ;
42484 wxString *arg4 = 0 ;
42485 wxString const &arg5_defvalue = wxPyEmptyString ;
42486 wxString *arg5 = (wxString *) &arg5_defvalue ;
42487 wxMenuItem *result = 0 ;
42488 void *argp1 = 0 ;
42489 int res1 = 0 ;
42490 size_t val2 ;
42491 int ecode2 = 0 ;
42492 int val3 ;
42493 int ecode3 = 0 ;
42494 bool temp4 = false ;
42495 bool temp5 = false ;
42496 PyObject * obj0 = 0 ;
42497 PyObject * obj1 = 0 ;
42498 PyObject * obj2 = 0 ;
42499 PyObject * obj3 = 0 ;
42500 PyObject * obj4 = 0 ;
42501 char * kwnames[] = {
42502 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42503 };
42504
42505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42507 if (!SWIG_IsOK(res1)) {
42508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42509 }
42510 arg1 = reinterpret_cast< wxMenu * >(argp1);
42511 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42512 if (!SWIG_IsOK(ecode2)) {
42513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42514 }
42515 arg2 = static_cast< size_t >(val2);
42516 ecode3 = SWIG_AsVal_int(obj2, &val3);
42517 if (!SWIG_IsOK(ecode3)) {
42518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42519 }
42520 arg3 = static_cast< int >(val3);
42521 {
42522 arg4 = wxString_in_helper(obj3);
42523 if (arg4 == NULL) SWIG_fail;
42524 temp4 = true;
42525 }
42526 if (obj4) {
42527 {
42528 arg5 = wxString_in_helper(obj4);
42529 if (arg5 == NULL) SWIG_fail;
42530 temp5 = true;
42531 }
42532 }
42533 {
42534 PyThreadState* __tstate = wxPyBeginAllowThreads();
42535 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42536 wxPyEndAllowThreads(__tstate);
42537 if (PyErr_Occurred()) SWIG_fail;
42538 }
42539 {
42540 resultobj = wxPyMake_wxObject(result, (bool)0);
42541 }
42542 {
42543 if (temp4)
42544 delete arg4;
42545 }
42546 {
42547 if (temp5)
42548 delete arg5;
42549 }
42550 return resultobj;
42551 fail:
42552 {
42553 if (temp4)
42554 delete arg4;
42555 }
42556 {
42557 if (temp5)
42558 delete arg5;
42559 }
42560 return NULL;
42561 }
42562
42563
42564 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42565 PyObject *resultobj = 0;
42566 wxMenu *arg1 = (wxMenu *) 0 ;
42567 size_t arg2 ;
42568 int arg3 ;
42569 wxString *arg4 = 0 ;
42570 wxString const &arg5_defvalue = wxPyEmptyString ;
42571 wxString *arg5 = (wxString *) &arg5_defvalue ;
42572 wxMenuItem *result = 0 ;
42573 void *argp1 = 0 ;
42574 int res1 = 0 ;
42575 size_t val2 ;
42576 int ecode2 = 0 ;
42577 int val3 ;
42578 int ecode3 = 0 ;
42579 bool temp4 = false ;
42580 bool temp5 = false ;
42581 PyObject * obj0 = 0 ;
42582 PyObject * obj1 = 0 ;
42583 PyObject * obj2 = 0 ;
42584 PyObject * obj3 = 0 ;
42585 PyObject * obj4 = 0 ;
42586 char * kwnames[] = {
42587 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42588 };
42589
42590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42592 if (!SWIG_IsOK(res1)) {
42593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42594 }
42595 arg1 = reinterpret_cast< wxMenu * >(argp1);
42596 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42597 if (!SWIG_IsOK(ecode2)) {
42598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42599 }
42600 arg2 = static_cast< size_t >(val2);
42601 ecode3 = SWIG_AsVal_int(obj2, &val3);
42602 if (!SWIG_IsOK(ecode3)) {
42603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42604 }
42605 arg3 = static_cast< int >(val3);
42606 {
42607 arg4 = wxString_in_helper(obj3);
42608 if (arg4 == NULL) SWIG_fail;
42609 temp4 = true;
42610 }
42611 if (obj4) {
42612 {
42613 arg5 = wxString_in_helper(obj4);
42614 if (arg5 == NULL) SWIG_fail;
42615 temp5 = true;
42616 }
42617 }
42618 {
42619 PyThreadState* __tstate = wxPyBeginAllowThreads();
42620 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42621 wxPyEndAllowThreads(__tstate);
42622 if (PyErr_Occurred()) SWIG_fail;
42623 }
42624 {
42625 resultobj = wxPyMake_wxObject(result, (bool)0);
42626 }
42627 {
42628 if (temp4)
42629 delete arg4;
42630 }
42631 {
42632 if (temp5)
42633 delete arg5;
42634 }
42635 return resultobj;
42636 fail:
42637 {
42638 if (temp4)
42639 delete arg4;
42640 }
42641 {
42642 if (temp5)
42643 delete arg5;
42644 }
42645 return NULL;
42646 }
42647
42648
42649 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42650 PyObject *resultobj = 0;
42651 wxMenu *arg1 = (wxMenu *) 0 ;
42652 size_t arg2 ;
42653 int arg3 ;
42654 wxString *arg4 = 0 ;
42655 wxMenu *arg5 = (wxMenu *) 0 ;
42656 wxString const &arg6_defvalue = wxPyEmptyString ;
42657 wxString *arg6 = (wxString *) &arg6_defvalue ;
42658 wxMenuItem *result = 0 ;
42659 void *argp1 = 0 ;
42660 int res1 = 0 ;
42661 size_t val2 ;
42662 int ecode2 = 0 ;
42663 int val3 ;
42664 int ecode3 = 0 ;
42665 bool temp4 = false ;
42666 void *argp5 = 0 ;
42667 int res5 = 0 ;
42668 bool temp6 = false ;
42669 PyObject * obj0 = 0 ;
42670 PyObject * obj1 = 0 ;
42671 PyObject * obj2 = 0 ;
42672 PyObject * obj3 = 0 ;
42673 PyObject * obj4 = 0 ;
42674 PyObject * obj5 = 0 ;
42675 char * kwnames[] = {
42676 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42677 };
42678
42679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42681 if (!SWIG_IsOK(res1)) {
42682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42683 }
42684 arg1 = reinterpret_cast< wxMenu * >(argp1);
42685 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42686 if (!SWIG_IsOK(ecode2)) {
42687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42688 }
42689 arg2 = static_cast< size_t >(val2);
42690 ecode3 = SWIG_AsVal_int(obj2, &val3);
42691 if (!SWIG_IsOK(ecode3)) {
42692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42693 }
42694 arg3 = static_cast< int >(val3);
42695 {
42696 arg4 = wxString_in_helper(obj3);
42697 if (arg4 == NULL) SWIG_fail;
42698 temp4 = true;
42699 }
42700 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42701 if (!SWIG_IsOK(res5)) {
42702 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42703 }
42704 arg5 = reinterpret_cast< wxMenu * >(argp5);
42705 if (obj5) {
42706 {
42707 arg6 = wxString_in_helper(obj5);
42708 if (arg6 == NULL) SWIG_fail;
42709 temp6 = true;
42710 }
42711 }
42712 {
42713 PyThreadState* __tstate = wxPyBeginAllowThreads();
42714 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 {
42719 resultobj = wxPyMake_wxObject(result, (bool)0);
42720 }
42721 {
42722 if (temp4)
42723 delete arg4;
42724 }
42725 {
42726 if (temp6)
42727 delete arg6;
42728 }
42729 return resultobj;
42730 fail:
42731 {
42732 if (temp4)
42733 delete arg4;
42734 }
42735 {
42736 if (temp6)
42737 delete arg6;
42738 }
42739 return NULL;
42740 }
42741
42742
42743 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42744 PyObject *resultobj = 0;
42745 wxMenu *arg1 = (wxMenu *) 0 ;
42746 int arg2 ;
42747 wxString const &arg3_defvalue = wxPyEmptyString ;
42748 wxString *arg3 = (wxString *) &arg3_defvalue ;
42749 wxString const &arg4_defvalue = wxPyEmptyString ;
42750 wxString *arg4 = (wxString *) &arg4_defvalue ;
42751 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42752 wxMenuItem *result = 0 ;
42753 void *argp1 = 0 ;
42754 int res1 = 0 ;
42755 int val2 ;
42756 int ecode2 = 0 ;
42757 bool temp3 = false ;
42758 bool temp4 = false ;
42759 int val5 ;
42760 int ecode5 = 0 ;
42761 PyObject * obj0 = 0 ;
42762 PyObject * obj1 = 0 ;
42763 PyObject * obj2 = 0 ;
42764 PyObject * obj3 = 0 ;
42765 PyObject * obj4 = 0 ;
42766 char * kwnames[] = {
42767 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42768 };
42769
42770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42772 if (!SWIG_IsOK(res1)) {
42773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42774 }
42775 arg1 = reinterpret_cast< wxMenu * >(argp1);
42776 ecode2 = SWIG_AsVal_int(obj1, &val2);
42777 if (!SWIG_IsOK(ecode2)) {
42778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42779 }
42780 arg2 = static_cast< int >(val2);
42781 if (obj2) {
42782 {
42783 arg3 = wxString_in_helper(obj2);
42784 if (arg3 == NULL) SWIG_fail;
42785 temp3 = true;
42786 }
42787 }
42788 if (obj3) {
42789 {
42790 arg4 = wxString_in_helper(obj3);
42791 if (arg4 == NULL) SWIG_fail;
42792 temp4 = true;
42793 }
42794 }
42795 if (obj4) {
42796 ecode5 = SWIG_AsVal_int(obj4, &val5);
42797 if (!SWIG_IsOK(ecode5)) {
42798 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42799 }
42800 arg5 = static_cast< wxItemKind >(val5);
42801 }
42802 {
42803 PyThreadState* __tstate = wxPyBeginAllowThreads();
42804 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42805 wxPyEndAllowThreads(__tstate);
42806 if (PyErr_Occurred()) SWIG_fail;
42807 }
42808 {
42809 resultobj = wxPyMake_wxObject(result, (bool)0);
42810 }
42811 {
42812 if (temp3)
42813 delete arg3;
42814 }
42815 {
42816 if (temp4)
42817 delete arg4;
42818 }
42819 return resultobj;
42820 fail:
42821 {
42822 if (temp3)
42823 delete arg3;
42824 }
42825 {
42826 if (temp4)
42827 delete arg4;
42828 }
42829 return NULL;
42830 }
42831
42832
42833 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42834 PyObject *resultobj = 0;
42835 wxMenu *arg1 = (wxMenu *) 0 ;
42836 wxMenuItem *result = 0 ;
42837 void *argp1 = 0 ;
42838 int res1 = 0 ;
42839 PyObject *swig_obj[1] ;
42840
42841 if (!args) SWIG_fail;
42842 swig_obj[0] = args;
42843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42844 if (!SWIG_IsOK(res1)) {
42845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42846 }
42847 arg1 = reinterpret_cast< wxMenu * >(argp1);
42848 {
42849 PyThreadState* __tstate = wxPyBeginAllowThreads();
42850 result = (wxMenuItem *)(arg1)->PrependSeparator();
42851 wxPyEndAllowThreads(__tstate);
42852 if (PyErr_Occurred()) SWIG_fail;
42853 }
42854 {
42855 resultobj = wxPyMake_wxObject(result, (bool)0);
42856 }
42857 return resultobj;
42858 fail:
42859 return NULL;
42860 }
42861
42862
42863 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42864 PyObject *resultobj = 0;
42865 wxMenu *arg1 = (wxMenu *) 0 ;
42866 int arg2 ;
42867 wxString *arg3 = 0 ;
42868 wxString const &arg4_defvalue = wxPyEmptyString ;
42869 wxString *arg4 = (wxString *) &arg4_defvalue ;
42870 wxMenuItem *result = 0 ;
42871 void *argp1 = 0 ;
42872 int res1 = 0 ;
42873 int val2 ;
42874 int ecode2 = 0 ;
42875 bool temp3 = false ;
42876 bool temp4 = false ;
42877 PyObject * obj0 = 0 ;
42878 PyObject * obj1 = 0 ;
42879 PyObject * obj2 = 0 ;
42880 PyObject * obj3 = 0 ;
42881 char * kwnames[] = {
42882 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42883 };
42884
42885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42887 if (!SWIG_IsOK(res1)) {
42888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42889 }
42890 arg1 = reinterpret_cast< wxMenu * >(argp1);
42891 ecode2 = SWIG_AsVal_int(obj1, &val2);
42892 if (!SWIG_IsOK(ecode2)) {
42893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42894 }
42895 arg2 = static_cast< int >(val2);
42896 {
42897 arg3 = wxString_in_helper(obj2);
42898 if (arg3 == NULL) SWIG_fail;
42899 temp3 = true;
42900 }
42901 if (obj3) {
42902 {
42903 arg4 = wxString_in_helper(obj3);
42904 if (arg4 == NULL) SWIG_fail;
42905 temp4 = true;
42906 }
42907 }
42908 {
42909 PyThreadState* __tstate = wxPyBeginAllowThreads();
42910 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42911 wxPyEndAllowThreads(__tstate);
42912 if (PyErr_Occurred()) SWIG_fail;
42913 }
42914 {
42915 resultobj = wxPyMake_wxObject(result, (bool)0);
42916 }
42917 {
42918 if (temp3)
42919 delete arg3;
42920 }
42921 {
42922 if (temp4)
42923 delete arg4;
42924 }
42925 return resultobj;
42926 fail:
42927 {
42928 if (temp3)
42929 delete arg3;
42930 }
42931 {
42932 if (temp4)
42933 delete arg4;
42934 }
42935 return NULL;
42936 }
42937
42938
42939 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42940 PyObject *resultobj = 0;
42941 wxMenu *arg1 = (wxMenu *) 0 ;
42942 int arg2 ;
42943 wxString *arg3 = 0 ;
42944 wxString const &arg4_defvalue = wxPyEmptyString ;
42945 wxString *arg4 = (wxString *) &arg4_defvalue ;
42946 wxMenuItem *result = 0 ;
42947 void *argp1 = 0 ;
42948 int res1 = 0 ;
42949 int val2 ;
42950 int ecode2 = 0 ;
42951 bool temp3 = false ;
42952 bool temp4 = false ;
42953 PyObject * obj0 = 0 ;
42954 PyObject * obj1 = 0 ;
42955 PyObject * obj2 = 0 ;
42956 PyObject * obj3 = 0 ;
42957 char * kwnames[] = {
42958 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42959 };
42960
42961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42963 if (!SWIG_IsOK(res1)) {
42964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42965 }
42966 arg1 = reinterpret_cast< wxMenu * >(argp1);
42967 ecode2 = SWIG_AsVal_int(obj1, &val2);
42968 if (!SWIG_IsOK(ecode2)) {
42969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42970 }
42971 arg2 = static_cast< int >(val2);
42972 {
42973 arg3 = wxString_in_helper(obj2);
42974 if (arg3 == NULL) SWIG_fail;
42975 temp3 = true;
42976 }
42977 if (obj3) {
42978 {
42979 arg4 = wxString_in_helper(obj3);
42980 if (arg4 == NULL) SWIG_fail;
42981 temp4 = true;
42982 }
42983 }
42984 {
42985 PyThreadState* __tstate = wxPyBeginAllowThreads();
42986 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42987 wxPyEndAllowThreads(__tstate);
42988 if (PyErr_Occurred()) SWIG_fail;
42989 }
42990 {
42991 resultobj = wxPyMake_wxObject(result, (bool)0);
42992 }
42993 {
42994 if (temp3)
42995 delete arg3;
42996 }
42997 {
42998 if (temp4)
42999 delete arg4;
43000 }
43001 return resultobj;
43002 fail:
43003 {
43004 if (temp3)
43005 delete arg3;
43006 }
43007 {
43008 if (temp4)
43009 delete arg4;
43010 }
43011 return NULL;
43012 }
43013
43014
43015 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43016 PyObject *resultobj = 0;
43017 wxMenu *arg1 = (wxMenu *) 0 ;
43018 int arg2 ;
43019 wxString *arg3 = 0 ;
43020 wxMenu *arg4 = (wxMenu *) 0 ;
43021 wxString const &arg5_defvalue = wxPyEmptyString ;
43022 wxString *arg5 = (wxString *) &arg5_defvalue ;
43023 wxMenuItem *result = 0 ;
43024 void *argp1 = 0 ;
43025 int res1 = 0 ;
43026 int val2 ;
43027 int ecode2 = 0 ;
43028 bool temp3 = false ;
43029 void *argp4 = 0 ;
43030 int res4 = 0 ;
43031 bool temp5 = false ;
43032 PyObject * obj0 = 0 ;
43033 PyObject * obj1 = 0 ;
43034 PyObject * obj2 = 0 ;
43035 PyObject * obj3 = 0 ;
43036 PyObject * obj4 = 0 ;
43037 char * kwnames[] = {
43038 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43039 };
43040
43041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43043 if (!SWIG_IsOK(res1)) {
43044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43045 }
43046 arg1 = reinterpret_cast< wxMenu * >(argp1);
43047 ecode2 = SWIG_AsVal_int(obj1, &val2);
43048 if (!SWIG_IsOK(ecode2)) {
43049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43050 }
43051 arg2 = static_cast< int >(val2);
43052 {
43053 arg3 = wxString_in_helper(obj2);
43054 if (arg3 == NULL) SWIG_fail;
43055 temp3 = true;
43056 }
43057 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43058 if (!SWIG_IsOK(res4)) {
43059 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43060 }
43061 arg4 = reinterpret_cast< wxMenu * >(argp4);
43062 if (obj4) {
43063 {
43064 arg5 = wxString_in_helper(obj4);
43065 if (arg5 == NULL) SWIG_fail;
43066 temp5 = true;
43067 }
43068 }
43069 {
43070 PyThreadState* __tstate = wxPyBeginAllowThreads();
43071 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 {
43076 resultobj = wxPyMake_wxObject(result, (bool)0);
43077 }
43078 {
43079 if (temp3)
43080 delete arg3;
43081 }
43082 {
43083 if (temp5)
43084 delete arg5;
43085 }
43086 return resultobj;
43087 fail:
43088 {
43089 if (temp3)
43090 delete arg3;
43091 }
43092 {
43093 if (temp5)
43094 delete arg5;
43095 }
43096 return NULL;
43097 }
43098
43099
43100 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43101 PyObject *resultobj = 0;
43102 wxMenu *arg1 = (wxMenu *) 0 ;
43103 int arg2 ;
43104 wxMenuItem *result = 0 ;
43105 void *argp1 = 0 ;
43106 int res1 = 0 ;
43107 int val2 ;
43108 int ecode2 = 0 ;
43109 PyObject * obj0 = 0 ;
43110 PyObject * obj1 = 0 ;
43111 char * kwnames[] = {
43112 (char *) "self",(char *) "id", NULL
43113 };
43114
43115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43117 if (!SWIG_IsOK(res1)) {
43118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43119 }
43120 arg1 = reinterpret_cast< wxMenu * >(argp1);
43121 ecode2 = SWIG_AsVal_int(obj1, &val2);
43122 if (!SWIG_IsOK(ecode2)) {
43123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43124 }
43125 arg2 = static_cast< int >(val2);
43126 {
43127 PyThreadState* __tstate = wxPyBeginAllowThreads();
43128 result = (wxMenuItem *)(arg1)->Remove(arg2);
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 {
43133 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43134 }
43135 return resultobj;
43136 fail:
43137 return NULL;
43138 }
43139
43140
43141 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43142 PyObject *resultobj = 0;
43143 wxMenu *arg1 = (wxMenu *) 0 ;
43144 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43145 wxMenuItem *result = 0 ;
43146 void *argp1 = 0 ;
43147 int res1 = 0 ;
43148 void *argp2 = 0 ;
43149 int res2 = 0 ;
43150 PyObject * obj0 = 0 ;
43151 PyObject * obj1 = 0 ;
43152 char * kwnames[] = {
43153 (char *) "self",(char *) "item", NULL
43154 };
43155
43156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43158 if (!SWIG_IsOK(res1)) {
43159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43160 }
43161 arg1 = reinterpret_cast< wxMenu * >(argp1);
43162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43163 if (!SWIG_IsOK(res2)) {
43164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43165 }
43166 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43167 {
43168 PyThreadState* __tstate = wxPyBeginAllowThreads();
43169 result = (wxMenuItem *)(arg1)->Remove(arg2);
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 {
43174 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43175 }
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43183 PyObject *resultobj = 0;
43184 wxMenu *arg1 = (wxMenu *) 0 ;
43185 int arg2 ;
43186 bool result;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 int val2 ;
43190 int ecode2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "id", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenu * >(argp1);
43203 ecode2 = SWIG_AsVal_int(obj1, &val2);
43204 if (!SWIG_IsOK(ecode2)) {
43205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43206 }
43207 arg2 = static_cast< int >(val2);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = (bool)(arg1)->Delete(arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 {
43215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43216 }
43217 return resultobj;
43218 fail:
43219 return NULL;
43220 }
43221
43222
43223 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43224 PyObject *resultobj = 0;
43225 wxMenu *arg1 = (wxMenu *) 0 ;
43226 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43227 bool result;
43228 void *argp1 = 0 ;
43229 int res1 = 0 ;
43230 void *argp2 = 0 ;
43231 int res2 = 0 ;
43232 PyObject * obj0 = 0 ;
43233 PyObject * obj1 = 0 ;
43234 char * kwnames[] = {
43235 (char *) "self",(char *) "item", NULL
43236 };
43237
43238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43240 if (!SWIG_IsOK(res1)) {
43241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43242 }
43243 arg1 = reinterpret_cast< wxMenu * >(argp1);
43244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43245 if (!SWIG_IsOK(res2)) {
43246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43247 }
43248 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43249 {
43250 PyThreadState* __tstate = wxPyBeginAllowThreads();
43251 result = (bool)(arg1)->Delete(arg2);
43252 wxPyEndAllowThreads(__tstate);
43253 if (PyErr_Occurred()) SWIG_fail;
43254 }
43255 {
43256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43257 }
43258 return resultobj;
43259 fail:
43260 return NULL;
43261 }
43262
43263
43264 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43265 PyObject *resultobj = 0;
43266 wxMenu *arg1 = (wxMenu *) 0 ;
43267 void *argp1 = 0 ;
43268 int res1 = 0 ;
43269 PyObject *swig_obj[1] ;
43270
43271 if (!args) SWIG_fail;
43272 swig_obj[0] = args;
43273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43274 if (!SWIG_IsOK(res1)) {
43275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43276 }
43277 arg1 = reinterpret_cast< wxMenu * >(argp1);
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 wxMenu_Destroy(arg1);
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 resultobj = SWIG_Py_Void();
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43292 PyObject *resultobj = 0;
43293 wxMenu *arg1 = (wxMenu *) 0 ;
43294 int arg2 ;
43295 bool result;
43296 void *argp1 = 0 ;
43297 int res1 = 0 ;
43298 int val2 ;
43299 int ecode2 = 0 ;
43300 PyObject * obj0 = 0 ;
43301 PyObject * obj1 = 0 ;
43302 char * kwnames[] = {
43303 (char *) "self",(char *) "id", NULL
43304 };
43305
43306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43308 if (!SWIG_IsOK(res1)) {
43309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43310 }
43311 arg1 = reinterpret_cast< wxMenu * >(argp1);
43312 ecode2 = SWIG_AsVal_int(obj1, &val2);
43313 if (!SWIG_IsOK(ecode2)) {
43314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43315 }
43316 arg2 = static_cast< int >(val2);
43317 {
43318 PyThreadState* __tstate = wxPyBeginAllowThreads();
43319 result = (bool)(arg1)->Destroy(arg2);
43320 wxPyEndAllowThreads(__tstate);
43321 if (PyErr_Occurred()) SWIG_fail;
43322 }
43323 {
43324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43325 }
43326 return resultobj;
43327 fail:
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj = 0;
43334 wxMenu *arg1 = (wxMenu *) 0 ;
43335 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43336 bool result;
43337 void *argp1 = 0 ;
43338 int res1 = 0 ;
43339 void *argp2 = 0 ;
43340 int res2 = 0 ;
43341 PyObject * obj0 = 0 ;
43342 PyObject * obj1 = 0 ;
43343 char * kwnames[] = {
43344 (char *) "self",(char *) "item", NULL
43345 };
43346
43347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43349 if (!SWIG_IsOK(res1)) {
43350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43351 }
43352 arg1 = reinterpret_cast< wxMenu * >(argp1);
43353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43354 if (!SWIG_IsOK(res2)) {
43355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43356 }
43357 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43358 {
43359 PyThreadState* __tstate = wxPyBeginAllowThreads();
43360 result = (bool)(arg1)->Destroy(arg2);
43361 wxPyEndAllowThreads(__tstate);
43362 if (PyErr_Occurred()) SWIG_fail;
43363 }
43364 {
43365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43366 }
43367 return resultobj;
43368 fail:
43369 return NULL;
43370 }
43371
43372
43373 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43374 PyObject *resultobj = 0;
43375 wxMenu *arg1 = (wxMenu *) 0 ;
43376 size_t result;
43377 void *argp1 = 0 ;
43378 int res1 = 0 ;
43379 PyObject *swig_obj[1] ;
43380
43381 if (!args) SWIG_fail;
43382 swig_obj[0] = args;
43383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43384 if (!SWIG_IsOK(res1)) {
43385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43386 }
43387 arg1 = reinterpret_cast< wxMenu * >(argp1);
43388 {
43389 PyThreadState* __tstate = wxPyBeginAllowThreads();
43390 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43391 wxPyEndAllowThreads(__tstate);
43392 if (PyErr_Occurred()) SWIG_fail;
43393 }
43394 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43395 return resultobj;
43396 fail:
43397 return NULL;
43398 }
43399
43400
43401 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43402 PyObject *resultobj = 0;
43403 wxMenu *arg1 = (wxMenu *) 0 ;
43404 PyObject *result = 0 ;
43405 void *argp1 = 0 ;
43406 int res1 = 0 ;
43407 PyObject *swig_obj[1] ;
43408
43409 if (!args) SWIG_fail;
43410 swig_obj[0] = args;
43411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43412 if (!SWIG_IsOK(res1)) {
43413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43414 }
43415 arg1 = reinterpret_cast< wxMenu * >(argp1);
43416 {
43417 PyThreadState* __tstate = wxPyBeginAllowThreads();
43418 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43419 wxPyEndAllowThreads(__tstate);
43420 if (PyErr_Occurred()) SWIG_fail;
43421 }
43422 resultobj = result;
43423 return resultobj;
43424 fail:
43425 return NULL;
43426 }
43427
43428
43429 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43430 PyObject *resultobj = 0;
43431 wxMenu *arg1 = (wxMenu *) 0 ;
43432 wxString *arg2 = 0 ;
43433 int result;
43434 void *argp1 = 0 ;
43435 int res1 = 0 ;
43436 bool temp2 = false ;
43437 PyObject * obj0 = 0 ;
43438 PyObject * obj1 = 0 ;
43439 char * kwnames[] = {
43440 (char *) "self",(char *) "item", NULL
43441 };
43442
43443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43445 if (!SWIG_IsOK(res1)) {
43446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43447 }
43448 arg1 = reinterpret_cast< wxMenu * >(argp1);
43449 {
43450 arg2 = wxString_in_helper(obj1);
43451 if (arg2 == NULL) SWIG_fail;
43452 temp2 = true;
43453 }
43454 {
43455 PyThreadState* __tstate = wxPyBeginAllowThreads();
43456 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43457 wxPyEndAllowThreads(__tstate);
43458 if (PyErr_Occurred()) SWIG_fail;
43459 }
43460 resultobj = SWIG_From_int(static_cast< int >(result));
43461 {
43462 if (temp2)
43463 delete arg2;
43464 }
43465 return resultobj;
43466 fail:
43467 {
43468 if (temp2)
43469 delete arg2;
43470 }
43471 return NULL;
43472 }
43473
43474
43475 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43476 PyObject *resultobj = 0;
43477 wxMenu *arg1 = (wxMenu *) 0 ;
43478 int arg2 ;
43479 wxMenuItem *result = 0 ;
43480 void *argp1 = 0 ;
43481 int res1 = 0 ;
43482 int val2 ;
43483 int ecode2 = 0 ;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486 char * kwnames[] = {
43487 (char *) "self",(char *) "id", NULL
43488 };
43489
43490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43492 if (!SWIG_IsOK(res1)) {
43493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43494 }
43495 arg1 = reinterpret_cast< wxMenu * >(argp1);
43496 ecode2 = SWIG_AsVal_int(obj1, &val2);
43497 if (!SWIG_IsOK(ecode2)) {
43498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43499 }
43500 arg2 = static_cast< int >(val2);
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 {
43508 resultobj = wxPyMake_wxObject(result, (bool)0);
43509 }
43510 return resultobj;
43511 fail:
43512 return NULL;
43513 }
43514
43515
43516 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43517 PyObject *resultobj = 0;
43518 wxMenu *arg1 = (wxMenu *) 0 ;
43519 size_t arg2 ;
43520 wxMenuItem *result = 0 ;
43521 void *argp1 = 0 ;
43522 int res1 = 0 ;
43523 size_t val2 ;
43524 int ecode2 = 0 ;
43525 PyObject * obj0 = 0 ;
43526 PyObject * obj1 = 0 ;
43527 char * kwnames[] = {
43528 (char *) "self",(char *) "position", NULL
43529 };
43530
43531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43533 if (!SWIG_IsOK(res1)) {
43534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43535 }
43536 arg1 = reinterpret_cast< wxMenu * >(argp1);
43537 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43538 if (!SWIG_IsOK(ecode2)) {
43539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43540 }
43541 arg2 = static_cast< size_t >(val2);
43542 {
43543 PyThreadState* __tstate = wxPyBeginAllowThreads();
43544 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43545 wxPyEndAllowThreads(__tstate);
43546 if (PyErr_Occurred()) SWIG_fail;
43547 }
43548 {
43549 resultobj = wxPyMake_wxObject(result, (bool)0);
43550 }
43551 return resultobj;
43552 fail:
43553 return NULL;
43554 }
43555
43556
43557 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43558 PyObject *resultobj = 0;
43559 wxMenu *arg1 = (wxMenu *) 0 ;
43560 int arg2 ;
43561 bool arg3 ;
43562 void *argp1 = 0 ;
43563 int res1 = 0 ;
43564 int val2 ;
43565 int ecode2 = 0 ;
43566 bool val3 ;
43567 int ecode3 = 0 ;
43568 PyObject * obj0 = 0 ;
43569 PyObject * obj1 = 0 ;
43570 PyObject * obj2 = 0 ;
43571 char * kwnames[] = {
43572 (char *) "self",(char *) "id",(char *) "enable", NULL
43573 };
43574
43575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43577 if (!SWIG_IsOK(res1)) {
43578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43579 }
43580 arg1 = reinterpret_cast< wxMenu * >(argp1);
43581 ecode2 = SWIG_AsVal_int(obj1, &val2);
43582 if (!SWIG_IsOK(ecode2)) {
43583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43584 }
43585 arg2 = static_cast< int >(val2);
43586 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43587 if (!SWIG_IsOK(ecode3)) {
43588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43589 }
43590 arg3 = static_cast< bool >(val3);
43591 {
43592 PyThreadState* __tstate = wxPyBeginAllowThreads();
43593 (arg1)->Enable(arg2,arg3);
43594 wxPyEndAllowThreads(__tstate);
43595 if (PyErr_Occurred()) SWIG_fail;
43596 }
43597 resultobj = SWIG_Py_Void();
43598 return resultobj;
43599 fail:
43600 return NULL;
43601 }
43602
43603
43604 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43605 PyObject *resultobj = 0;
43606 wxMenu *arg1 = (wxMenu *) 0 ;
43607 int arg2 ;
43608 bool result;
43609 void *argp1 = 0 ;
43610 int res1 = 0 ;
43611 int val2 ;
43612 int ecode2 = 0 ;
43613 PyObject * obj0 = 0 ;
43614 PyObject * obj1 = 0 ;
43615 char * kwnames[] = {
43616 (char *) "self",(char *) "id", NULL
43617 };
43618
43619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43621 if (!SWIG_IsOK(res1)) {
43622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43623 }
43624 arg1 = reinterpret_cast< wxMenu * >(argp1);
43625 ecode2 = SWIG_AsVal_int(obj1, &val2);
43626 if (!SWIG_IsOK(ecode2)) {
43627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43628 }
43629 arg2 = static_cast< int >(val2);
43630 {
43631 PyThreadState* __tstate = wxPyBeginAllowThreads();
43632 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 {
43637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43638 }
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43646 PyObject *resultobj = 0;
43647 wxMenu *arg1 = (wxMenu *) 0 ;
43648 int arg2 ;
43649 bool arg3 ;
43650 void *argp1 = 0 ;
43651 int res1 = 0 ;
43652 int val2 ;
43653 int ecode2 = 0 ;
43654 bool val3 ;
43655 int ecode3 = 0 ;
43656 PyObject * obj0 = 0 ;
43657 PyObject * obj1 = 0 ;
43658 PyObject * obj2 = 0 ;
43659 char * kwnames[] = {
43660 (char *) "self",(char *) "id",(char *) "check", NULL
43661 };
43662
43663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43665 if (!SWIG_IsOK(res1)) {
43666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43667 }
43668 arg1 = reinterpret_cast< wxMenu * >(argp1);
43669 ecode2 = SWIG_AsVal_int(obj1, &val2);
43670 if (!SWIG_IsOK(ecode2)) {
43671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43672 }
43673 arg2 = static_cast< int >(val2);
43674 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43675 if (!SWIG_IsOK(ecode3)) {
43676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43677 }
43678 arg3 = static_cast< bool >(val3);
43679 {
43680 PyThreadState* __tstate = wxPyBeginAllowThreads();
43681 (arg1)->Check(arg2,arg3);
43682 wxPyEndAllowThreads(__tstate);
43683 if (PyErr_Occurred()) SWIG_fail;
43684 }
43685 resultobj = SWIG_Py_Void();
43686 return resultobj;
43687 fail:
43688 return NULL;
43689 }
43690
43691
43692 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43693 PyObject *resultobj = 0;
43694 wxMenu *arg1 = (wxMenu *) 0 ;
43695 int arg2 ;
43696 bool result;
43697 void *argp1 = 0 ;
43698 int res1 = 0 ;
43699 int val2 ;
43700 int ecode2 = 0 ;
43701 PyObject * obj0 = 0 ;
43702 PyObject * obj1 = 0 ;
43703 char * kwnames[] = {
43704 (char *) "self",(char *) "id", NULL
43705 };
43706
43707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43709 if (!SWIG_IsOK(res1)) {
43710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43711 }
43712 arg1 = reinterpret_cast< wxMenu * >(argp1);
43713 ecode2 = SWIG_AsVal_int(obj1, &val2);
43714 if (!SWIG_IsOK(ecode2)) {
43715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43716 }
43717 arg2 = static_cast< int >(val2);
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43721 wxPyEndAllowThreads(__tstate);
43722 if (PyErr_Occurred()) SWIG_fail;
43723 }
43724 {
43725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43726 }
43727 return resultobj;
43728 fail:
43729 return NULL;
43730 }
43731
43732
43733 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43734 PyObject *resultobj = 0;
43735 wxMenu *arg1 = (wxMenu *) 0 ;
43736 int arg2 ;
43737 wxString *arg3 = 0 ;
43738 void *argp1 = 0 ;
43739 int res1 = 0 ;
43740 int val2 ;
43741 int ecode2 = 0 ;
43742 bool temp3 = false ;
43743 PyObject * obj0 = 0 ;
43744 PyObject * obj1 = 0 ;
43745 PyObject * obj2 = 0 ;
43746 char * kwnames[] = {
43747 (char *) "self",(char *) "id",(char *) "label", NULL
43748 };
43749
43750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43752 if (!SWIG_IsOK(res1)) {
43753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43754 }
43755 arg1 = reinterpret_cast< wxMenu * >(argp1);
43756 ecode2 = SWIG_AsVal_int(obj1, &val2);
43757 if (!SWIG_IsOK(ecode2)) {
43758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43759 }
43760 arg2 = static_cast< int >(val2);
43761 {
43762 arg3 = wxString_in_helper(obj2);
43763 if (arg3 == NULL) SWIG_fail;
43764 temp3 = true;
43765 }
43766 {
43767 PyThreadState* __tstate = wxPyBeginAllowThreads();
43768 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43769 wxPyEndAllowThreads(__tstate);
43770 if (PyErr_Occurred()) SWIG_fail;
43771 }
43772 resultobj = SWIG_Py_Void();
43773 {
43774 if (temp3)
43775 delete arg3;
43776 }
43777 return resultobj;
43778 fail:
43779 {
43780 if (temp3)
43781 delete arg3;
43782 }
43783 return NULL;
43784 }
43785
43786
43787 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43788 PyObject *resultobj = 0;
43789 wxMenu *arg1 = (wxMenu *) 0 ;
43790 int arg2 ;
43791 wxString result;
43792 void *argp1 = 0 ;
43793 int res1 = 0 ;
43794 int val2 ;
43795 int ecode2 = 0 ;
43796 PyObject * obj0 = 0 ;
43797 PyObject * obj1 = 0 ;
43798 char * kwnames[] = {
43799 (char *) "self",(char *) "id", NULL
43800 };
43801
43802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43804 if (!SWIG_IsOK(res1)) {
43805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43806 }
43807 arg1 = reinterpret_cast< wxMenu * >(argp1);
43808 ecode2 = SWIG_AsVal_int(obj1, &val2);
43809 if (!SWIG_IsOK(ecode2)) {
43810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43811 }
43812 arg2 = static_cast< int >(val2);
43813 {
43814 PyThreadState* __tstate = wxPyBeginAllowThreads();
43815 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 {
43820 #if wxUSE_UNICODE
43821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43822 #else
43823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43824 #endif
43825 }
43826 return resultobj;
43827 fail:
43828 return NULL;
43829 }
43830
43831
43832 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43833 PyObject *resultobj = 0;
43834 wxMenu *arg1 = (wxMenu *) 0 ;
43835 int arg2 ;
43836 wxString *arg3 = 0 ;
43837 void *argp1 = 0 ;
43838 int res1 = 0 ;
43839 int val2 ;
43840 int ecode2 = 0 ;
43841 bool temp3 = false ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 PyObject * obj2 = 0 ;
43845 char * kwnames[] = {
43846 (char *) "self",(char *) "id",(char *) "helpString", NULL
43847 };
43848
43849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43851 if (!SWIG_IsOK(res1)) {
43852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43853 }
43854 arg1 = reinterpret_cast< wxMenu * >(argp1);
43855 ecode2 = SWIG_AsVal_int(obj1, &val2);
43856 if (!SWIG_IsOK(ecode2)) {
43857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43858 }
43859 arg2 = static_cast< int >(val2);
43860 {
43861 arg3 = wxString_in_helper(obj2);
43862 if (arg3 == NULL) SWIG_fail;
43863 temp3 = true;
43864 }
43865 {
43866 PyThreadState* __tstate = wxPyBeginAllowThreads();
43867 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43868 wxPyEndAllowThreads(__tstate);
43869 if (PyErr_Occurred()) SWIG_fail;
43870 }
43871 resultobj = SWIG_Py_Void();
43872 {
43873 if (temp3)
43874 delete arg3;
43875 }
43876 return resultobj;
43877 fail:
43878 {
43879 if (temp3)
43880 delete arg3;
43881 }
43882 return NULL;
43883 }
43884
43885
43886 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43887 PyObject *resultobj = 0;
43888 wxMenu *arg1 = (wxMenu *) 0 ;
43889 int arg2 ;
43890 wxString result;
43891 void *argp1 = 0 ;
43892 int res1 = 0 ;
43893 int val2 ;
43894 int ecode2 = 0 ;
43895 PyObject * obj0 = 0 ;
43896 PyObject * obj1 = 0 ;
43897 char * kwnames[] = {
43898 (char *) "self",(char *) "id", NULL
43899 };
43900
43901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43903 if (!SWIG_IsOK(res1)) {
43904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43905 }
43906 arg1 = reinterpret_cast< wxMenu * >(argp1);
43907 ecode2 = SWIG_AsVal_int(obj1, &val2);
43908 if (!SWIG_IsOK(ecode2)) {
43909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43910 }
43911 arg2 = static_cast< int >(val2);
43912 {
43913 PyThreadState* __tstate = wxPyBeginAllowThreads();
43914 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43915 wxPyEndAllowThreads(__tstate);
43916 if (PyErr_Occurred()) SWIG_fail;
43917 }
43918 {
43919 #if wxUSE_UNICODE
43920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43921 #else
43922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43923 #endif
43924 }
43925 return resultobj;
43926 fail:
43927 return NULL;
43928 }
43929
43930
43931 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43932 PyObject *resultobj = 0;
43933 wxMenu *arg1 = (wxMenu *) 0 ;
43934 wxString *arg2 = 0 ;
43935 void *argp1 = 0 ;
43936 int res1 = 0 ;
43937 bool temp2 = false ;
43938 PyObject * obj0 = 0 ;
43939 PyObject * obj1 = 0 ;
43940 char * kwnames[] = {
43941 (char *) "self",(char *) "title", NULL
43942 };
43943
43944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43946 if (!SWIG_IsOK(res1)) {
43947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43948 }
43949 arg1 = reinterpret_cast< wxMenu * >(argp1);
43950 {
43951 arg2 = wxString_in_helper(obj1);
43952 if (arg2 == NULL) SWIG_fail;
43953 temp2 = true;
43954 }
43955 {
43956 PyThreadState* __tstate = wxPyBeginAllowThreads();
43957 (arg1)->SetTitle((wxString const &)*arg2);
43958 wxPyEndAllowThreads(__tstate);
43959 if (PyErr_Occurred()) SWIG_fail;
43960 }
43961 resultobj = SWIG_Py_Void();
43962 {
43963 if (temp2)
43964 delete arg2;
43965 }
43966 return resultobj;
43967 fail:
43968 {
43969 if (temp2)
43970 delete arg2;
43971 }
43972 return NULL;
43973 }
43974
43975
43976 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43977 PyObject *resultobj = 0;
43978 wxMenu *arg1 = (wxMenu *) 0 ;
43979 wxString result;
43980 void *argp1 = 0 ;
43981 int res1 = 0 ;
43982 PyObject *swig_obj[1] ;
43983
43984 if (!args) SWIG_fail;
43985 swig_obj[0] = args;
43986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43987 if (!SWIG_IsOK(res1)) {
43988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43989 }
43990 arg1 = reinterpret_cast< wxMenu * >(argp1);
43991 {
43992 PyThreadState* __tstate = wxPyBeginAllowThreads();
43993 result = ((wxMenu const *)arg1)->GetTitle();
43994 wxPyEndAllowThreads(__tstate);
43995 if (PyErr_Occurred()) SWIG_fail;
43996 }
43997 {
43998 #if wxUSE_UNICODE
43999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44000 #else
44001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44002 #endif
44003 }
44004 return resultobj;
44005 fail:
44006 return NULL;
44007 }
44008
44009
44010 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44011 PyObject *resultobj = 0;
44012 wxMenu *arg1 = (wxMenu *) 0 ;
44013 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44014 void *argp1 = 0 ;
44015 int res1 = 0 ;
44016 void *argp2 = 0 ;
44017 int res2 = 0 ;
44018 PyObject * obj0 = 0 ;
44019 PyObject * obj1 = 0 ;
44020 char * kwnames[] = {
44021 (char *) "self",(char *) "handler", NULL
44022 };
44023
44024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44026 if (!SWIG_IsOK(res1)) {
44027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44028 }
44029 arg1 = reinterpret_cast< wxMenu * >(argp1);
44030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44031 if (!SWIG_IsOK(res2)) {
44032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44033 }
44034 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 (arg1)->SetEventHandler(arg2);
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 resultobj = SWIG_Py_Void();
44042 return resultobj;
44043 fail:
44044 return NULL;
44045 }
44046
44047
44048 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44049 PyObject *resultobj = 0;
44050 wxMenu *arg1 = (wxMenu *) 0 ;
44051 wxEvtHandler *result = 0 ;
44052 void *argp1 = 0 ;
44053 int res1 = 0 ;
44054 PyObject *swig_obj[1] ;
44055
44056 if (!args) SWIG_fail;
44057 swig_obj[0] = args;
44058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44059 if (!SWIG_IsOK(res1)) {
44060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44061 }
44062 arg1 = reinterpret_cast< wxMenu * >(argp1);
44063 {
44064 PyThreadState* __tstate = wxPyBeginAllowThreads();
44065 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44066 wxPyEndAllowThreads(__tstate);
44067 if (PyErr_Occurred()) SWIG_fail;
44068 }
44069 {
44070 resultobj = wxPyMake_wxObject(result, 0);
44071 }
44072 return resultobj;
44073 fail:
44074 return NULL;
44075 }
44076
44077
44078 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44079 PyObject *resultobj = 0;
44080 wxMenu *arg1 = (wxMenu *) 0 ;
44081 wxWindow *arg2 = (wxWindow *) 0 ;
44082 void *argp1 = 0 ;
44083 int res1 = 0 ;
44084 void *argp2 = 0 ;
44085 int res2 = 0 ;
44086 PyObject * obj0 = 0 ;
44087 PyObject * obj1 = 0 ;
44088 char * kwnames[] = {
44089 (char *) "self",(char *) "win", NULL
44090 };
44091
44092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44094 if (!SWIG_IsOK(res1)) {
44095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44096 }
44097 arg1 = reinterpret_cast< wxMenu * >(argp1);
44098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44099 if (!SWIG_IsOK(res2)) {
44100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44101 }
44102 arg2 = reinterpret_cast< wxWindow * >(argp2);
44103 {
44104 PyThreadState* __tstate = wxPyBeginAllowThreads();
44105 (arg1)->SetInvokingWindow(arg2);
44106 wxPyEndAllowThreads(__tstate);
44107 if (PyErr_Occurred()) SWIG_fail;
44108 }
44109 resultobj = SWIG_Py_Void();
44110 return resultobj;
44111 fail:
44112 return NULL;
44113 }
44114
44115
44116 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44117 PyObject *resultobj = 0;
44118 wxMenu *arg1 = (wxMenu *) 0 ;
44119 wxWindow *result = 0 ;
44120 void *argp1 = 0 ;
44121 int res1 = 0 ;
44122 PyObject *swig_obj[1] ;
44123
44124 if (!args) SWIG_fail;
44125 swig_obj[0] = args;
44126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44127 if (!SWIG_IsOK(res1)) {
44128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44129 }
44130 arg1 = reinterpret_cast< wxMenu * >(argp1);
44131 {
44132 PyThreadState* __tstate = wxPyBeginAllowThreads();
44133 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44134 wxPyEndAllowThreads(__tstate);
44135 if (PyErr_Occurred()) SWIG_fail;
44136 }
44137 {
44138 resultobj = wxPyMake_wxObject(result, 0);
44139 }
44140 return resultobj;
44141 fail:
44142 return NULL;
44143 }
44144
44145
44146 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44147 PyObject *resultobj = 0;
44148 wxMenu *arg1 = (wxMenu *) 0 ;
44149 long result;
44150 void *argp1 = 0 ;
44151 int res1 = 0 ;
44152 PyObject *swig_obj[1] ;
44153
44154 if (!args) SWIG_fail;
44155 swig_obj[0] = args;
44156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44157 if (!SWIG_IsOK(res1)) {
44158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44159 }
44160 arg1 = reinterpret_cast< wxMenu * >(argp1);
44161 {
44162 PyThreadState* __tstate = wxPyBeginAllowThreads();
44163 result = (long)((wxMenu const *)arg1)->GetStyle();
44164 wxPyEndAllowThreads(__tstate);
44165 if (PyErr_Occurred()) SWIG_fail;
44166 }
44167 resultobj = SWIG_From_long(static_cast< long >(result));
44168 return resultobj;
44169 fail:
44170 return NULL;
44171 }
44172
44173
44174 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44175 PyObject *resultobj = 0;
44176 wxMenu *arg1 = (wxMenu *) 0 ;
44177 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44178 void *argp1 = 0 ;
44179 int res1 = 0 ;
44180 void *argp2 = 0 ;
44181 int res2 = 0 ;
44182 PyObject * obj0 = 0 ;
44183 PyObject * obj1 = 0 ;
44184 char * kwnames[] = {
44185 (char *) "self",(char *) "source", NULL
44186 };
44187
44188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44190 if (!SWIG_IsOK(res1)) {
44191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44192 }
44193 arg1 = reinterpret_cast< wxMenu * >(argp1);
44194 if (obj1) {
44195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44196 if (!SWIG_IsOK(res2)) {
44197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44198 }
44199 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44200 }
44201 {
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 (arg1)->UpdateUI(arg2);
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 resultobj = SWIG_Py_Void();
44208 return resultobj;
44209 fail:
44210 return NULL;
44211 }
44212
44213
44214 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44215 PyObject *resultobj = 0;
44216 wxMenu *arg1 = (wxMenu *) 0 ;
44217 wxMenuBar *result = 0 ;
44218 void *argp1 = 0 ;
44219 int res1 = 0 ;
44220 PyObject *swig_obj[1] ;
44221
44222 if (!args) SWIG_fail;
44223 swig_obj[0] = args;
44224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44225 if (!SWIG_IsOK(res1)) {
44226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44227 }
44228 arg1 = reinterpret_cast< wxMenu * >(argp1);
44229 {
44230 PyThreadState* __tstate = wxPyBeginAllowThreads();
44231 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44232 wxPyEndAllowThreads(__tstate);
44233 if (PyErr_Occurred()) SWIG_fail;
44234 }
44235 {
44236 resultobj = wxPyMake_wxObject(result, (bool)0);
44237 }
44238 return resultobj;
44239 fail:
44240 return NULL;
44241 }
44242
44243
44244 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44245 PyObject *resultobj = 0;
44246 wxMenu *arg1 = (wxMenu *) 0 ;
44247 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44248 void *argp1 = 0 ;
44249 int res1 = 0 ;
44250 void *argp2 = 0 ;
44251 int res2 = 0 ;
44252 PyObject * obj0 = 0 ;
44253 PyObject * obj1 = 0 ;
44254 char * kwnames[] = {
44255 (char *) "self",(char *) "menubar", NULL
44256 };
44257
44258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44260 if (!SWIG_IsOK(res1)) {
44261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44262 }
44263 arg1 = reinterpret_cast< wxMenu * >(argp1);
44264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44265 if (!SWIG_IsOK(res2)) {
44266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44267 }
44268 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44269 {
44270 PyThreadState* __tstate = wxPyBeginAllowThreads();
44271 (arg1)->Attach(arg2);
44272 wxPyEndAllowThreads(__tstate);
44273 if (PyErr_Occurred()) SWIG_fail;
44274 }
44275 resultobj = SWIG_Py_Void();
44276 return resultobj;
44277 fail:
44278 return NULL;
44279 }
44280
44281
44282 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44283 PyObject *resultobj = 0;
44284 wxMenu *arg1 = (wxMenu *) 0 ;
44285 void *argp1 = 0 ;
44286 int res1 = 0 ;
44287 PyObject *swig_obj[1] ;
44288
44289 if (!args) SWIG_fail;
44290 swig_obj[0] = args;
44291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44292 if (!SWIG_IsOK(res1)) {
44293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44294 }
44295 arg1 = reinterpret_cast< wxMenu * >(argp1);
44296 {
44297 PyThreadState* __tstate = wxPyBeginAllowThreads();
44298 (arg1)->Detach();
44299 wxPyEndAllowThreads(__tstate);
44300 if (PyErr_Occurred()) SWIG_fail;
44301 }
44302 resultobj = SWIG_Py_Void();
44303 return resultobj;
44304 fail:
44305 return NULL;
44306 }
44307
44308
44309 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44310 PyObject *resultobj = 0;
44311 wxMenu *arg1 = (wxMenu *) 0 ;
44312 bool result;
44313 void *argp1 = 0 ;
44314 int res1 = 0 ;
44315 PyObject *swig_obj[1] ;
44316
44317 if (!args) SWIG_fail;
44318 swig_obj[0] = args;
44319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44320 if (!SWIG_IsOK(res1)) {
44321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44322 }
44323 arg1 = reinterpret_cast< wxMenu * >(argp1);
44324 {
44325 PyThreadState* __tstate = wxPyBeginAllowThreads();
44326 result = (bool)((wxMenu const *)arg1)->IsAttached();
44327 wxPyEndAllowThreads(__tstate);
44328 if (PyErr_Occurred()) SWIG_fail;
44329 }
44330 {
44331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44332 }
44333 return resultobj;
44334 fail:
44335 return NULL;
44336 }
44337
44338
44339 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44340 PyObject *resultobj = 0;
44341 wxMenu *arg1 = (wxMenu *) 0 ;
44342 wxMenu *arg2 = (wxMenu *) 0 ;
44343 void *argp1 = 0 ;
44344 int res1 = 0 ;
44345 void *argp2 = 0 ;
44346 int res2 = 0 ;
44347 PyObject * obj0 = 0 ;
44348 PyObject * obj1 = 0 ;
44349 char * kwnames[] = {
44350 (char *) "self",(char *) "parent", NULL
44351 };
44352
44353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44355 if (!SWIG_IsOK(res1)) {
44356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44357 }
44358 arg1 = reinterpret_cast< wxMenu * >(argp1);
44359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44360 if (!SWIG_IsOK(res2)) {
44361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44362 }
44363 arg2 = reinterpret_cast< wxMenu * >(argp2);
44364 {
44365 PyThreadState* __tstate = wxPyBeginAllowThreads();
44366 (arg1)->SetParent(arg2);
44367 wxPyEndAllowThreads(__tstate);
44368 if (PyErr_Occurred()) SWIG_fail;
44369 }
44370 resultobj = SWIG_Py_Void();
44371 return resultobj;
44372 fail:
44373 return NULL;
44374 }
44375
44376
44377 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44378 PyObject *resultobj = 0;
44379 wxMenu *arg1 = (wxMenu *) 0 ;
44380 wxMenu *result = 0 ;
44381 void *argp1 = 0 ;
44382 int res1 = 0 ;
44383 PyObject *swig_obj[1] ;
44384
44385 if (!args) SWIG_fail;
44386 swig_obj[0] = args;
44387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44388 if (!SWIG_IsOK(res1)) {
44389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44390 }
44391 arg1 = reinterpret_cast< wxMenu * >(argp1);
44392 {
44393 PyThreadState* __tstate = wxPyBeginAllowThreads();
44394 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 {
44399 resultobj = wxPyMake_wxObject(result, 0);
44400 }
44401 return resultobj;
44402 fail:
44403 return NULL;
44404 }
44405
44406
44407 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44408 PyObject *obj;
44409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44410 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44411 return SWIG_Py_Void();
44412 }
44413
44414 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44415 return SWIG_Python_InitShadowInstance(args);
44416 }
44417
44418 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44419 PyObject *resultobj = 0;
44420 long arg1 = (long) 0 ;
44421 wxMenuBar *result = 0 ;
44422 long val1 ;
44423 int ecode1 = 0 ;
44424 PyObject * obj0 = 0 ;
44425 char * kwnames[] = {
44426 (char *) "style", NULL
44427 };
44428
44429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44430 if (obj0) {
44431 ecode1 = SWIG_AsVal_long(obj0, &val1);
44432 if (!SWIG_IsOK(ecode1)) {
44433 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44434 }
44435 arg1 = static_cast< long >(val1);
44436 }
44437 {
44438 if (!wxPyCheckForApp()) SWIG_fail;
44439 PyThreadState* __tstate = wxPyBeginAllowThreads();
44440 result = (wxMenuBar *)new wxMenuBar(arg1);
44441 wxPyEndAllowThreads(__tstate);
44442 if (PyErr_Occurred()) SWIG_fail;
44443 }
44444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44445 return resultobj;
44446 fail:
44447 return NULL;
44448 }
44449
44450
44451 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44452 PyObject *resultobj = 0;
44453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44454 wxMenu *arg2 = (wxMenu *) 0 ;
44455 wxString *arg3 = 0 ;
44456 bool result;
44457 void *argp1 = 0 ;
44458 int res1 = 0 ;
44459 void *argp2 = 0 ;
44460 int res2 = 0 ;
44461 bool temp3 = false ;
44462 PyObject * obj0 = 0 ;
44463 PyObject * obj1 = 0 ;
44464 PyObject * obj2 = 0 ;
44465 char * kwnames[] = {
44466 (char *) "self",(char *) "menu",(char *) "title", NULL
44467 };
44468
44469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44471 if (!SWIG_IsOK(res1)) {
44472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44473 }
44474 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44475 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44476 if (!SWIG_IsOK(res2)) {
44477 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44478 }
44479 arg2 = reinterpret_cast< wxMenu * >(argp2);
44480 {
44481 arg3 = wxString_in_helper(obj2);
44482 if (arg3 == NULL) SWIG_fail;
44483 temp3 = true;
44484 }
44485 {
44486 PyThreadState* __tstate = wxPyBeginAllowThreads();
44487 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44488 wxPyEndAllowThreads(__tstate);
44489 if (PyErr_Occurred()) SWIG_fail;
44490 }
44491 {
44492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44493 }
44494 {
44495 if (temp3)
44496 delete arg3;
44497 }
44498 return resultobj;
44499 fail:
44500 {
44501 if (temp3)
44502 delete arg3;
44503 }
44504 return NULL;
44505 }
44506
44507
44508 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44509 PyObject *resultobj = 0;
44510 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44511 size_t arg2 ;
44512 wxMenu *arg3 = (wxMenu *) 0 ;
44513 wxString *arg4 = 0 ;
44514 bool result;
44515 void *argp1 = 0 ;
44516 int res1 = 0 ;
44517 size_t val2 ;
44518 int ecode2 = 0 ;
44519 void *argp3 = 0 ;
44520 int res3 = 0 ;
44521 bool temp4 = false ;
44522 PyObject * obj0 = 0 ;
44523 PyObject * obj1 = 0 ;
44524 PyObject * obj2 = 0 ;
44525 PyObject * obj3 = 0 ;
44526 char * kwnames[] = {
44527 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44528 };
44529
44530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44532 if (!SWIG_IsOK(res1)) {
44533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44534 }
44535 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44536 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44537 if (!SWIG_IsOK(ecode2)) {
44538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44539 }
44540 arg2 = static_cast< size_t >(val2);
44541 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44542 if (!SWIG_IsOK(res3)) {
44543 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44544 }
44545 arg3 = reinterpret_cast< wxMenu * >(argp3);
44546 {
44547 arg4 = wxString_in_helper(obj3);
44548 if (arg4 == NULL) SWIG_fail;
44549 temp4 = true;
44550 }
44551 {
44552 PyThreadState* __tstate = wxPyBeginAllowThreads();
44553 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44554 wxPyEndAllowThreads(__tstate);
44555 if (PyErr_Occurred()) SWIG_fail;
44556 }
44557 {
44558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44559 }
44560 {
44561 if (temp4)
44562 delete arg4;
44563 }
44564 return resultobj;
44565 fail:
44566 {
44567 if (temp4)
44568 delete arg4;
44569 }
44570 return NULL;
44571 }
44572
44573
44574 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44575 PyObject *resultobj = 0;
44576 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44577 size_t result;
44578 void *argp1 = 0 ;
44579 int res1 = 0 ;
44580 PyObject *swig_obj[1] ;
44581
44582 if (!args) SWIG_fail;
44583 swig_obj[0] = args;
44584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44585 if (!SWIG_IsOK(res1)) {
44586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44587 }
44588 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44589 {
44590 PyThreadState* __tstate = wxPyBeginAllowThreads();
44591 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44592 wxPyEndAllowThreads(__tstate);
44593 if (PyErr_Occurred()) SWIG_fail;
44594 }
44595 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44596 return resultobj;
44597 fail:
44598 return NULL;
44599 }
44600
44601
44602 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44603 PyObject *resultobj = 0;
44604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44605 size_t arg2 ;
44606 wxMenu *result = 0 ;
44607 void *argp1 = 0 ;
44608 int res1 = 0 ;
44609 size_t val2 ;
44610 int ecode2 = 0 ;
44611 PyObject * obj0 = 0 ;
44612 PyObject * obj1 = 0 ;
44613 char * kwnames[] = {
44614 (char *) "self",(char *) "pos", NULL
44615 };
44616
44617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44619 if (!SWIG_IsOK(res1)) {
44620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44621 }
44622 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44623 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44624 if (!SWIG_IsOK(ecode2)) {
44625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44626 }
44627 arg2 = static_cast< size_t >(val2);
44628 {
44629 PyThreadState* __tstate = wxPyBeginAllowThreads();
44630 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44631 wxPyEndAllowThreads(__tstate);
44632 if (PyErr_Occurred()) SWIG_fail;
44633 }
44634 {
44635 resultobj = wxPyMake_wxObject(result, 0);
44636 }
44637 return resultobj;
44638 fail:
44639 return NULL;
44640 }
44641
44642
44643 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44644 PyObject *resultobj = 0;
44645 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44646 size_t arg2 ;
44647 wxMenu *arg3 = (wxMenu *) 0 ;
44648 wxString *arg4 = 0 ;
44649 wxMenu *result = 0 ;
44650 void *argp1 = 0 ;
44651 int res1 = 0 ;
44652 size_t val2 ;
44653 int ecode2 = 0 ;
44654 void *argp3 = 0 ;
44655 int res3 = 0 ;
44656 bool temp4 = false ;
44657 PyObject * obj0 = 0 ;
44658 PyObject * obj1 = 0 ;
44659 PyObject * obj2 = 0 ;
44660 PyObject * obj3 = 0 ;
44661 char * kwnames[] = {
44662 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44663 };
44664
44665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44667 if (!SWIG_IsOK(res1)) {
44668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44669 }
44670 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44671 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44672 if (!SWIG_IsOK(ecode2)) {
44673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44674 }
44675 arg2 = static_cast< size_t >(val2);
44676 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44677 if (!SWIG_IsOK(res3)) {
44678 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44679 }
44680 arg3 = reinterpret_cast< wxMenu * >(argp3);
44681 {
44682 arg4 = wxString_in_helper(obj3);
44683 if (arg4 == NULL) SWIG_fail;
44684 temp4 = true;
44685 }
44686 {
44687 PyThreadState* __tstate = wxPyBeginAllowThreads();
44688 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44689 wxPyEndAllowThreads(__tstate);
44690 if (PyErr_Occurred()) SWIG_fail;
44691 }
44692 {
44693 resultobj = wxPyMake_wxObject(result, 0);
44694 }
44695 {
44696 if (temp4)
44697 delete arg4;
44698 }
44699 return resultobj;
44700 fail:
44701 {
44702 if (temp4)
44703 delete arg4;
44704 }
44705 return NULL;
44706 }
44707
44708
44709 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44710 PyObject *resultobj = 0;
44711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44712 size_t arg2 ;
44713 wxMenu *result = 0 ;
44714 void *argp1 = 0 ;
44715 int res1 = 0 ;
44716 size_t val2 ;
44717 int ecode2 = 0 ;
44718 PyObject * obj0 = 0 ;
44719 PyObject * obj1 = 0 ;
44720 char * kwnames[] = {
44721 (char *) "self",(char *) "pos", NULL
44722 };
44723
44724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44726 if (!SWIG_IsOK(res1)) {
44727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44728 }
44729 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44730 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44731 if (!SWIG_IsOK(ecode2)) {
44732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44733 }
44734 arg2 = static_cast< size_t >(val2);
44735 {
44736 PyThreadState* __tstate = wxPyBeginAllowThreads();
44737 result = (wxMenu *)(arg1)->Remove(arg2);
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 {
44742 resultobj = wxPyMake_wxObject(result, 0);
44743 }
44744 return resultobj;
44745 fail:
44746 return NULL;
44747 }
44748
44749
44750 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44751 PyObject *resultobj = 0;
44752 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44753 size_t arg2 ;
44754 bool arg3 ;
44755 void *argp1 = 0 ;
44756 int res1 = 0 ;
44757 size_t val2 ;
44758 int ecode2 = 0 ;
44759 bool val3 ;
44760 int ecode3 = 0 ;
44761 PyObject * obj0 = 0 ;
44762 PyObject * obj1 = 0 ;
44763 PyObject * obj2 = 0 ;
44764 char * kwnames[] = {
44765 (char *) "self",(char *) "pos",(char *) "enable", NULL
44766 };
44767
44768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44770 if (!SWIG_IsOK(res1)) {
44771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44772 }
44773 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44774 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44775 if (!SWIG_IsOK(ecode2)) {
44776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44777 }
44778 arg2 = static_cast< size_t >(val2);
44779 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44780 if (!SWIG_IsOK(ecode3)) {
44781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44782 }
44783 arg3 = static_cast< bool >(val3);
44784 {
44785 PyThreadState* __tstate = wxPyBeginAllowThreads();
44786 (arg1)->EnableTop(arg2,arg3);
44787 wxPyEndAllowThreads(__tstate);
44788 if (PyErr_Occurred()) SWIG_fail;
44789 }
44790 resultobj = SWIG_Py_Void();
44791 return resultobj;
44792 fail:
44793 return NULL;
44794 }
44795
44796
44797 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44798 PyObject *resultobj = 0;
44799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44800 size_t arg2 ;
44801 bool result;
44802 void *argp1 = 0 ;
44803 int res1 = 0 ;
44804 size_t val2 ;
44805 int ecode2 = 0 ;
44806 PyObject * obj0 = 0 ;
44807 PyObject * obj1 = 0 ;
44808 char * kwnames[] = {
44809 (char *) "self",(char *) "pos", NULL
44810 };
44811
44812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44814 if (!SWIG_IsOK(res1)) {
44815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44816 }
44817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44818 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44819 if (!SWIG_IsOK(ecode2)) {
44820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44821 }
44822 arg2 = static_cast< size_t >(val2);
44823 {
44824 PyThreadState* __tstate = wxPyBeginAllowThreads();
44825 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44826 wxPyEndAllowThreads(__tstate);
44827 if (PyErr_Occurred()) SWIG_fail;
44828 }
44829 {
44830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44831 }
44832 return resultobj;
44833 fail:
44834 return NULL;
44835 }
44836
44837
44838 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44839 PyObject *resultobj = 0;
44840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44841 size_t arg2 ;
44842 wxString *arg3 = 0 ;
44843 void *argp1 = 0 ;
44844 int res1 = 0 ;
44845 size_t val2 ;
44846 int ecode2 = 0 ;
44847 bool temp3 = false ;
44848 PyObject * obj0 = 0 ;
44849 PyObject * obj1 = 0 ;
44850 PyObject * obj2 = 0 ;
44851 char * kwnames[] = {
44852 (char *) "self",(char *) "pos",(char *) "label", NULL
44853 };
44854
44855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44857 if (!SWIG_IsOK(res1)) {
44858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44859 }
44860 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44861 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44862 if (!SWIG_IsOK(ecode2)) {
44863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44864 }
44865 arg2 = static_cast< size_t >(val2);
44866 {
44867 arg3 = wxString_in_helper(obj2);
44868 if (arg3 == NULL) SWIG_fail;
44869 temp3 = true;
44870 }
44871 {
44872 PyThreadState* __tstate = wxPyBeginAllowThreads();
44873 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44874 wxPyEndAllowThreads(__tstate);
44875 if (PyErr_Occurred()) SWIG_fail;
44876 }
44877 resultobj = SWIG_Py_Void();
44878 {
44879 if (temp3)
44880 delete arg3;
44881 }
44882 return resultobj;
44883 fail:
44884 {
44885 if (temp3)
44886 delete arg3;
44887 }
44888 return NULL;
44889 }
44890
44891
44892 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44893 PyObject *resultobj = 0;
44894 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44895 size_t arg2 ;
44896 wxString result;
44897 void *argp1 = 0 ;
44898 int res1 = 0 ;
44899 size_t val2 ;
44900 int ecode2 = 0 ;
44901 PyObject * obj0 = 0 ;
44902 PyObject * obj1 = 0 ;
44903 char * kwnames[] = {
44904 (char *) "self",(char *) "pos", NULL
44905 };
44906
44907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44909 if (!SWIG_IsOK(res1)) {
44910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44911 }
44912 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44913 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44914 if (!SWIG_IsOK(ecode2)) {
44915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44916 }
44917 arg2 = static_cast< size_t >(val2);
44918 {
44919 PyThreadState* __tstate = wxPyBeginAllowThreads();
44920 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44921 wxPyEndAllowThreads(__tstate);
44922 if (PyErr_Occurred()) SWIG_fail;
44923 }
44924 {
44925 #if wxUSE_UNICODE
44926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44927 #else
44928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44929 #endif
44930 }
44931 return resultobj;
44932 fail:
44933 return NULL;
44934 }
44935
44936
44937 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44938 PyObject *resultobj = 0;
44939 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44940 wxString *arg2 = 0 ;
44941 wxString *arg3 = 0 ;
44942 int result;
44943 void *argp1 = 0 ;
44944 int res1 = 0 ;
44945 bool temp2 = false ;
44946 bool temp3 = false ;
44947 PyObject * obj0 = 0 ;
44948 PyObject * obj1 = 0 ;
44949 PyObject * obj2 = 0 ;
44950 char * kwnames[] = {
44951 (char *) "self",(char *) "menu",(char *) "item", NULL
44952 };
44953
44954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44956 if (!SWIG_IsOK(res1)) {
44957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44958 }
44959 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44960 {
44961 arg2 = wxString_in_helper(obj1);
44962 if (arg2 == NULL) SWIG_fail;
44963 temp2 = true;
44964 }
44965 {
44966 arg3 = wxString_in_helper(obj2);
44967 if (arg3 == NULL) SWIG_fail;
44968 temp3 = true;
44969 }
44970 {
44971 PyThreadState* __tstate = wxPyBeginAllowThreads();
44972 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44973 wxPyEndAllowThreads(__tstate);
44974 if (PyErr_Occurred()) SWIG_fail;
44975 }
44976 resultobj = SWIG_From_int(static_cast< int >(result));
44977 {
44978 if (temp2)
44979 delete arg2;
44980 }
44981 {
44982 if (temp3)
44983 delete arg3;
44984 }
44985 return resultobj;
44986 fail:
44987 {
44988 if (temp2)
44989 delete arg2;
44990 }
44991 {
44992 if (temp3)
44993 delete arg3;
44994 }
44995 return NULL;
44996 }
44997
44998
44999 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45000 PyObject *resultobj = 0;
45001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45002 int arg2 ;
45003 wxMenuItem *result = 0 ;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 int val2 ;
45007 int ecode2 = 0 ;
45008 PyObject * obj0 = 0 ;
45009 PyObject * obj1 = 0 ;
45010 char * kwnames[] = {
45011 (char *) "self",(char *) "id", NULL
45012 };
45013
45014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45016 if (!SWIG_IsOK(res1)) {
45017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45018 }
45019 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45020 ecode2 = SWIG_AsVal_int(obj1, &val2);
45021 if (!SWIG_IsOK(ecode2)) {
45022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45023 }
45024 arg2 = static_cast< int >(val2);
45025 {
45026 PyThreadState* __tstate = wxPyBeginAllowThreads();
45027 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45028 wxPyEndAllowThreads(__tstate);
45029 if (PyErr_Occurred()) SWIG_fail;
45030 }
45031 {
45032 resultobj = wxPyMake_wxObject(result, (bool)0);
45033 }
45034 return resultobj;
45035 fail:
45036 return NULL;
45037 }
45038
45039
45040 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45041 PyObject *resultobj = 0;
45042 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45043 wxString *arg2 = 0 ;
45044 int result;
45045 void *argp1 = 0 ;
45046 int res1 = 0 ;
45047 bool temp2 = false ;
45048 PyObject * obj0 = 0 ;
45049 PyObject * obj1 = 0 ;
45050 char * kwnames[] = {
45051 (char *) "self",(char *) "title", NULL
45052 };
45053
45054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45056 if (!SWIG_IsOK(res1)) {
45057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45058 }
45059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45060 {
45061 arg2 = wxString_in_helper(obj1);
45062 if (arg2 == NULL) SWIG_fail;
45063 temp2 = true;
45064 }
45065 {
45066 PyThreadState* __tstate = wxPyBeginAllowThreads();
45067 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45068 wxPyEndAllowThreads(__tstate);
45069 if (PyErr_Occurred()) SWIG_fail;
45070 }
45071 resultobj = SWIG_From_int(static_cast< int >(result));
45072 {
45073 if (temp2)
45074 delete arg2;
45075 }
45076 return resultobj;
45077 fail:
45078 {
45079 if (temp2)
45080 delete arg2;
45081 }
45082 return NULL;
45083 }
45084
45085
45086 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45087 PyObject *resultobj = 0;
45088 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45089 int arg2 ;
45090 bool arg3 ;
45091 void *argp1 = 0 ;
45092 int res1 = 0 ;
45093 int val2 ;
45094 int ecode2 = 0 ;
45095 bool val3 ;
45096 int ecode3 = 0 ;
45097 PyObject * obj0 = 0 ;
45098 PyObject * obj1 = 0 ;
45099 PyObject * obj2 = 0 ;
45100 char * kwnames[] = {
45101 (char *) "self",(char *) "id",(char *) "enable", NULL
45102 };
45103
45104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45106 if (!SWIG_IsOK(res1)) {
45107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45108 }
45109 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45110 ecode2 = SWIG_AsVal_int(obj1, &val2);
45111 if (!SWIG_IsOK(ecode2)) {
45112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45113 }
45114 arg2 = static_cast< int >(val2);
45115 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45116 if (!SWIG_IsOK(ecode3)) {
45117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45118 }
45119 arg3 = static_cast< bool >(val3);
45120 {
45121 PyThreadState* __tstate = wxPyBeginAllowThreads();
45122 (arg1)->Enable(arg2,arg3);
45123 wxPyEndAllowThreads(__tstate);
45124 if (PyErr_Occurred()) SWIG_fail;
45125 }
45126 resultobj = SWIG_Py_Void();
45127 return resultobj;
45128 fail:
45129 return NULL;
45130 }
45131
45132
45133 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45134 PyObject *resultobj = 0;
45135 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45136 int arg2 ;
45137 bool arg3 ;
45138 void *argp1 = 0 ;
45139 int res1 = 0 ;
45140 int val2 ;
45141 int ecode2 = 0 ;
45142 bool val3 ;
45143 int ecode3 = 0 ;
45144 PyObject * obj0 = 0 ;
45145 PyObject * obj1 = 0 ;
45146 PyObject * obj2 = 0 ;
45147 char * kwnames[] = {
45148 (char *) "self",(char *) "id",(char *) "check", NULL
45149 };
45150
45151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45153 if (!SWIG_IsOK(res1)) {
45154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45155 }
45156 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45157 ecode2 = SWIG_AsVal_int(obj1, &val2);
45158 if (!SWIG_IsOK(ecode2)) {
45159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45160 }
45161 arg2 = static_cast< int >(val2);
45162 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45163 if (!SWIG_IsOK(ecode3)) {
45164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45165 }
45166 arg3 = static_cast< bool >(val3);
45167 {
45168 PyThreadState* __tstate = wxPyBeginAllowThreads();
45169 (arg1)->Check(arg2,arg3);
45170 wxPyEndAllowThreads(__tstate);
45171 if (PyErr_Occurred()) SWIG_fail;
45172 }
45173 resultobj = SWIG_Py_Void();
45174 return resultobj;
45175 fail:
45176 return NULL;
45177 }
45178
45179
45180 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45181 PyObject *resultobj = 0;
45182 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45183 int arg2 ;
45184 bool result;
45185 void *argp1 = 0 ;
45186 int res1 = 0 ;
45187 int val2 ;
45188 int ecode2 = 0 ;
45189 PyObject * obj0 = 0 ;
45190 PyObject * obj1 = 0 ;
45191 char * kwnames[] = {
45192 (char *) "self",(char *) "id", NULL
45193 };
45194
45195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45197 if (!SWIG_IsOK(res1)) {
45198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45199 }
45200 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45201 ecode2 = SWIG_AsVal_int(obj1, &val2);
45202 if (!SWIG_IsOK(ecode2)) {
45203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45204 }
45205 arg2 = static_cast< int >(val2);
45206 {
45207 PyThreadState* __tstate = wxPyBeginAllowThreads();
45208 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45209 wxPyEndAllowThreads(__tstate);
45210 if (PyErr_Occurred()) SWIG_fail;
45211 }
45212 {
45213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45214 }
45215 return resultobj;
45216 fail:
45217 return NULL;
45218 }
45219
45220
45221 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45222 PyObject *resultobj = 0;
45223 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45224 int arg2 ;
45225 bool result;
45226 void *argp1 = 0 ;
45227 int res1 = 0 ;
45228 int val2 ;
45229 int ecode2 = 0 ;
45230 PyObject * obj0 = 0 ;
45231 PyObject * obj1 = 0 ;
45232 char * kwnames[] = {
45233 (char *) "self",(char *) "id", NULL
45234 };
45235
45236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45238 if (!SWIG_IsOK(res1)) {
45239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45240 }
45241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45242 ecode2 = SWIG_AsVal_int(obj1, &val2);
45243 if (!SWIG_IsOK(ecode2)) {
45244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45245 }
45246 arg2 = static_cast< int >(val2);
45247 {
45248 PyThreadState* __tstate = wxPyBeginAllowThreads();
45249 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45250 wxPyEndAllowThreads(__tstate);
45251 if (PyErr_Occurred()) SWIG_fail;
45252 }
45253 {
45254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45255 }
45256 return resultobj;
45257 fail:
45258 return NULL;
45259 }
45260
45261
45262 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45263 PyObject *resultobj = 0;
45264 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45265 int arg2 ;
45266 wxString *arg3 = 0 ;
45267 void *argp1 = 0 ;
45268 int res1 = 0 ;
45269 int val2 ;
45270 int ecode2 = 0 ;
45271 bool temp3 = false ;
45272 PyObject * obj0 = 0 ;
45273 PyObject * obj1 = 0 ;
45274 PyObject * obj2 = 0 ;
45275 char * kwnames[] = {
45276 (char *) "self",(char *) "id",(char *) "label", NULL
45277 };
45278
45279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45281 if (!SWIG_IsOK(res1)) {
45282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45283 }
45284 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45285 ecode2 = SWIG_AsVal_int(obj1, &val2);
45286 if (!SWIG_IsOK(ecode2)) {
45287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45288 }
45289 arg2 = static_cast< int >(val2);
45290 {
45291 arg3 = wxString_in_helper(obj2);
45292 if (arg3 == NULL) SWIG_fail;
45293 temp3 = true;
45294 }
45295 {
45296 PyThreadState* __tstate = wxPyBeginAllowThreads();
45297 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45298 wxPyEndAllowThreads(__tstate);
45299 if (PyErr_Occurred()) SWIG_fail;
45300 }
45301 resultobj = SWIG_Py_Void();
45302 {
45303 if (temp3)
45304 delete arg3;
45305 }
45306 return resultobj;
45307 fail:
45308 {
45309 if (temp3)
45310 delete arg3;
45311 }
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj = 0;
45318 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45319 int arg2 ;
45320 wxString result;
45321 void *argp1 = 0 ;
45322 int res1 = 0 ;
45323 int val2 ;
45324 int ecode2 = 0 ;
45325 PyObject * obj0 = 0 ;
45326 PyObject * obj1 = 0 ;
45327 char * kwnames[] = {
45328 (char *) "self",(char *) "id", NULL
45329 };
45330
45331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45333 if (!SWIG_IsOK(res1)) {
45334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45335 }
45336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45337 ecode2 = SWIG_AsVal_int(obj1, &val2);
45338 if (!SWIG_IsOK(ecode2)) {
45339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45340 }
45341 arg2 = static_cast< int >(val2);
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45345 wxPyEndAllowThreads(__tstate);
45346 if (PyErr_Occurred()) SWIG_fail;
45347 }
45348 {
45349 #if wxUSE_UNICODE
45350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45351 #else
45352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45353 #endif
45354 }
45355 return resultobj;
45356 fail:
45357 return NULL;
45358 }
45359
45360
45361 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45362 PyObject *resultobj = 0;
45363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45364 int arg2 ;
45365 wxString *arg3 = 0 ;
45366 void *argp1 = 0 ;
45367 int res1 = 0 ;
45368 int val2 ;
45369 int ecode2 = 0 ;
45370 bool temp3 = false ;
45371 PyObject * obj0 = 0 ;
45372 PyObject * obj1 = 0 ;
45373 PyObject * obj2 = 0 ;
45374 char * kwnames[] = {
45375 (char *) "self",(char *) "id",(char *) "helpString", NULL
45376 };
45377
45378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45380 if (!SWIG_IsOK(res1)) {
45381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45382 }
45383 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45384 ecode2 = SWIG_AsVal_int(obj1, &val2);
45385 if (!SWIG_IsOK(ecode2)) {
45386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45387 }
45388 arg2 = static_cast< int >(val2);
45389 {
45390 arg3 = wxString_in_helper(obj2);
45391 if (arg3 == NULL) SWIG_fail;
45392 temp3 = true;
45393 }
45394 {
45395 PyThreadState* __tstate = wxPyBeginAllowThreads();
45396 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45397 wxPyEndAllowThreads(__tstate);
45398 if (PyErr_Occurred()) SWIG_fail;
45399 }
45400 resultobj = SWIG_Py_Void();
45401 {
45402 if (temp3)
45403 delete arg3;
45404 }
45405 return resultobj;
45406 fail:
45407 {
45408 if (temp3)
45409 delete arg3;
45410 }
45411 return NULL;
45412 }
45413
45414
45415 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45416 PyObject *resultobj = 0;
45417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45418 int arg2 ;
45419 wxString result;
45420 void *argp1 = 0 ;
45421 int res1 = 0 ;
45422 int val2 ;
45423 int ecode2 = 0 ;
45424 PyObject * obj0 = 0 ;
45425 PyObject * obj1 = 0 ;
45426 char * kwnames[] = {
45427 (char *) "self",(char *) "id", NULL
45428 };
45429
45430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45432 if (!SWIG_IsOK(res1)) {
45433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45434 }
45435 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45436 ecode2 = SWIG_AsVal_int(obj1, &val2);
45437 if (!SWIG_IsOK(ecode2)) {
45438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45439 }
45440 arg2 = static_cast< int >(val2);
45441 {
45442 PyThreadState* __tstate = wxPyBeginAllowThreads();
45443 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45444 wxPyEndAllowThreads(__tstate);
45445 if (PyErr_Occurred()) SWIG_fail;
45446 }
45447 {
45448 #if wxUSE_UNICODE
45449 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45450 #else
45451 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45452 #endif
45453 }
45454 return resultobj;
45455 fail:
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45461 PyObject *resultobj = 0;
45462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45463 wxFrame *result = 0 ;
45464 void *argp1 = 0 ;
45465 int res1 = 0 ;
45466 PyObject *swig_obj[1] ;
45467
45468 if (!args) SWIG_fail;
45469 swig_obj[0] = args;
45470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45471 if (!SWIG_IsOK(res1)) {
45472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45473 }
45474 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45475 {
45476 PyThreadState* __tstate = wxPyBeginAllowThreads();
45477 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45478 wxPyEndAllowThreads(__tstate);
45479 if (PyErr_Occurred()) SWIG_fail;
45480 }
45481 {
45482 resultobj = wxPyMake_wxObject(result, (bool)0);
45483 }
45484 return resultobj;
45485 fail:
45486 return NULL;
45487 }
45488
45489
45490 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45491 PyObject *resultobj = 0;
45492 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45493 bool result;
45494 void *argp1 = 0 ;
45495 int res1 = 0 ;
45496 PyObject *swig_obj[1] ;
45497
45498 if (!args) SWIG_fail;
45499 swig_obj[0] = args;
45500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45501 if (!SWIG_IsOK(res1)) {
45502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45503 }
45504 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45505 {
45506 PyThreadState* __tstate = wxPyBeginAllowThreads();
45507 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45508 wxPyEndAllowThreads(__tstate);
45509 if (PyErr_Occurred()) SWIG_fail;
45510 }
45511 {
45512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45513 }
45514 return resultobj;
45515 fail:
45516 return NULL;
45517 }
45518
45519
45520 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45521 PyObject *resultobj = 0;
45522 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45523 wxFrame *arg2 = (wxFrame *) 0 ;
45524 void *argp1 = 0 ;
45525 int res1 = 0 ;
45526 void *argp2 = 0 ;
45527 int res2 = 0 ;
45528 PyObject * obj0 = 0 ;
45529 PyObject * obj1 = 0 ;
45530 char * kwnames[] = {
45531 (char *) "self",(char *) "frame", NULL
45532 };
45533
45534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45536 if (!SWIG_IsOK(res1)) {
45537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45538 }
45539 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45540 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45541 if (!SWIG_IsOK(res2)) {
45542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45543 }
45544 arg2 = reinterpret_cast< wxFrame * >(argp2);
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 (arg1)->Attach(arg2);
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 resultobj = SWIG_Py_Void();
45552 return resultobj;
45553 fail:
45554 return NULL;
45555 }
45556
45557
45558 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45559 PyObject *resultobj = 0;
45560 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45561 void *argp1 = 0 ;
45562 int res1 = 0 ;
45563 PyObject *swig_obj[1] ;
45564
45565 if (!args) SWIG_fail;
45566 swig_obj[0] = args;
45567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45568 if (!SWIG_IsOK(res1)) {
45569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45570 }
45571 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45572 {
45573 PyThreadState* __tstate = wxPyBeginAllowThreads();
45574 (arg1)->Detach();
45575 wxPyEndAllowThreads(__tstate);
45576 if (PyErr_Occurred()) SWIG_fail;
45577 }
45578 resultobj = SWIG_Py_Void();
45579 return resultobj;
45580 fail:
45581 return NULL;
45582 }
45583
45584
45585 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45586 PyObject *resultobj = 0;
45587 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45588 void *argp1 = 0 ;
45589 int res1 = 0 ;
45590 PyObject *swig_obj[1] ;
45591
45592 if (!args) SWIG_fail;
45593 swig_obj[0] = args;
45594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45595 if (!SWIG_IsOK(res1)) {
45596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45597 }
45598 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45599 {
45600 PyThreadState* __tstate = wxPyBeginAllowThreads();
45601 (arg1)->UpdateMenus();
45602 wxPyEndAllowThreads(__tstate);
45603 if (PyErr_Occurred()) SWIG_fail;
45604 }
45605 resultobj = SWIG_Py_Void();
45606 return resultobj;
45607 fail:
45608 return NULL;
45609 }
45610
45611
45612 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45613 PyObject *resultobj = 0;
45614 bool arg1 ;
45615 bool val1 ;
45616 int ecode1 = 0 ;
45617 PyObject * obj0 = 0 ;
45618 char * kwnames[] = {
45619 (char *) "enable", NULL
45620 };
45621
45622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45623 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45624 if (!SWIG_IsOK(ecode1)) {
45625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45626 }
45627 arg1 = static_cast< bool >(val1);
45628 {
45629 PyThreadState* __tstate = wxPyBeginAllowThreads();
45630 wxMenuBar_SetAutoWindowMenu(arg1);
45631 wxPyEndAllowThreads(__tstate);
45632 if (PyErr_Occurred()) SWIG_fail;
45633 }
45634 resultobj = SWIG_Py_Void();
45635 return resultobj;
45636 fail:
45637 return NULL;
45638 }
45639
45640
45641 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45642 PyObject *resultobj = 0;
45643 bool result;
45644
45645 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45646 {
45647 PyThreadState* __tstate = wxPyBeginAllowThreads();
45648 result = (bool)wxMenuBar_GetAutoWindowMenu();
45649 wxPyEndAllowThreads(__tstate);
45650 if (PyErr_Occurred()) SWIG_fail;
45651 }
45652 {
45653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45654 }
45655 return resultobj;
45656 fail:
45657 return NULL;
45658 }
45659
45660
45661 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45662 PyObject *obj;
45663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45664 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45665 return SWIG_Py_Void();
45666 }
45667
45668 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45669 return SWIG_Python_InitShadowInstance(args);
45670 }
45671
45672 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45673 PyObject *resultobj = 0;
45674 wxMenu *arg1 = (wxMenu *) NULL ;
45675 int arg2 = (int) wxID_SEPARATOR ;
45676 wxString const &arg3_defvalue = wxPyEmptyString ;
45677 wxString *arg3 = (wxString *) &arg3_defvalue ;
45678 wxString const &arg4_defvalue = wxPyEmptyString ;
45679 wxString *arg4 = (wxString *) &arg4_defvalue ;
45680 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45681 wxMenu *arg6 = (wxMenu *) NULL ;
45682 wxMenuItem *result = 0 ;
45683 void *argp1 = 0 ;
45684 int res1 = 0 ;
45685 int val2 ;
45686 int ecode2 = 0 ;
45687 bool temp3 = false ;
45688 bool temp4 = false ;
45689 int val5 ;
45690 int ecode5 = 0 ;
45691 void *argp6 = 0 ;
45692 int res6 = 0 ;
45693 PyObject * obj0 = 0 ;
45694 PyObject * obj1 = 0 ;
45695 PyObject * obj2 = 0 ;
45696 PyObject * obj3 = 0 ;
45697 PyObject * obj4 = 0 ;
45698 PyObject * obj5 = 0 ;
45699 char * kwnames[] = {
45700 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45701 };
45702
45703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45704 if (obj0) {
45705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45706 if (!SWIG_IsOK(res1)) {
45707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45708 }
45709 arg1 = reinterpret_cast< wxMenu * >(argp1);
45710 }
45711 if (obj1) {
45712 ecode2 = SWIG_AsVal_int(obj1, &val2);
45713 if (!SWIG_IsOK(ecode2)) {
45714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45715 }
45716 arg2 = static_cast< int >(val2);
45717 }
45718 if (obj2) {
45719 {
45720 arg3 = wxString_in_helper(obj2);
45721 if (arg3 == NULL) SWIG_fail;
45722 temp3 = true;
45723 }
45724 }
45725 if (obj3) {
45726 {
45727 arg4 = wxString_in_helper(obj3);
45728 if (arg4 == NULL) SWIG_fail;
45729 temp4 = true;
45730 }
45731 }
45732 if (obj4) {
45733 ecode5 = SWIG_AsVal_int(obj4, &val5);
45734 if (!SWIG_IsOK(ecode5)) {
45735 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45736 }
45737 arg5 = static_cast< wxItemKind >(val5);
45738 }
45739 if (obj5) {
45740 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45741 if (!SWIG_IsOK(res6)) {
45742 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45743 }
45744 arg6 = reinterpret_cast< wxMenu * >(argp6);
45745 }
45746 {
45747 PyThreadState* __tstate = wxPyBeginAllowThreads();
45748 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45749 wxPyEndAllowThreads(__tstate);
45750 if (PyErr_Occurred()) SWIG_fail;
45751 }
45752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45753 {
45754 if (temp3)
45755 delete arg3;
45756 }
45757 {
45758 if (temp4)
45759 delete arg4;
45760 }
45761 return resultobj;
45762 fail:
45763 {
45764 if (temp3)
45765 delete arg3;
45766 }
45767 {
45768 if (temp4)
45769 delete arg4;
45770 }
45771 return NULL;
45772 }
45773
45774
45775 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45776 PyObject *resultobj = 0;
45777 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45778 void *argp1 = 0 ;
45779 int res1 = 0 ;
45780 PyObject *swig_obj[1] ;
45781
45782 if (!args) SWIG_fail;
45783 swig_obj[0] = args;
45784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45785 if (!SWIG_IsOK(res1)) {
45786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45787 }
45788 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45789 {
45790 PyThreadState* __tstate = wxPyBeginAllowThreads();
45791 delete arg1;
45792
45793 wxPyEndAllowThreads(__tstate);
45794 if (PyErr_Occurred()) SWIG_fail;
45795 }
45796 resultobj = SWIG_Py_Void();
45797 return resultobj;
45798 fail:
45799 return NULL;
45800 }
45801
45802
45803 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45804 PyObject *resultobj = 0;
45805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45806 wxMenu *result = 0 ;
45807 void *argp1 = 0 ;
45808 int res1 = 0 ;
45809 PyObject *swig_obj[1] ;
45810
45811 if (!args) SWIG_fail;
45812 swig_obj[0] = args;
45813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45814 if (!SWIG_IsOK(res1)) {
45815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45816 }
45817 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45818 {
45819 PyThreadState* __tstate = wxPyBeginAllowThreads();
45820 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 {
45825 resultobj = wxPyMake_wxObject(result, 0);
45826 }
45827 return resultobj;
45828 fail:
45829 return NULL;
45830 }
45831
45832
45833 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45834 PyObject *resultobj = 0;
45835 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45836 wxMenu *arg2 = (wxMenu *) 0 ;
45837 void *argp1 = 0 ;
45838 int res1 = 0 ;
45839 void *argp2 = 0 ;
45840 int res2 = 0 ;
45841 PyObject * obj0 = 0 ;
45842 PyObject * obj1 = 0 ;
45843 char * kwnames[] = {
45844 (char *) "self",(char *) "menu", NULL
45845 };
45846
45847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45849 if (!SWIG_IsOK(res1)) {
45850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45851 }
45852 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45854 if (!SWIG_IsOK(res2)) {
45855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45856 }
45857 arg2 = reinterpret_cast< wxMenu * >(argp2);
45858 {
45859 PyThreadState* __tstate = wxPyBeginAllowThreads();
45860 (arg1)->SetMenu(arg2);
45861 wxPyEndAllowThreads(__tstate);
45862 if (PyErr_Occurred()) SWIG_fail;
45863 }
45864 resultobj = SWIG_Py_Void();
45865 return resultobj;
45866 fail:
45867 return NULL;
45868 }
45869
45870
45871 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45872 PyObject *resultobj = 0;
45873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45874 int arg2 ;
45875 void *argp1 = 0 ;
45876 int res1 = 0 ;
45877 int val2 ;
45878 int ecode2 = 0 ;
45879 PyObject * obj0 = 0 ;
45880 PyObject * obj1 = 0 ;
45881 char * kwnames[] = {
45882 (char *) "self",(char *) "id", NULL
45883 };
45884
45885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45887 if (!SWIG_IsOK(res1)) {
45888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45889 }
45890 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45891 ecode2 = SWIG_AsVal_int(obj1, &val2);
45892 if (!SWIG_IsOK(ecode2)) {
45893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45894 }
45895 arg2 = static_cast< int >(val2);
45896 {
45897 PyThreadState* __tstate = wxPyBeginAllowThreads();
45898 (arg1)->SetId(arg2);
45899 wxPyEndAllowThreads(__tstate);
45900 if (PyErr_Occurred()) SWIG_fail;
45901 }
45902 resultobj = SWIG_Py_Void();
45903 return resultobj;
45904 fail:
45905 return NULL;
45906 }
45907
45908
45909 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45910 PyObject *resultobj = 0;
45911 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45912 int result;
45913 void *argp1 = 0 ;
45914 int res1 = 0 ;
45915 PyObject *swig_obj[1] ;
45916
45917 if (!args) SWIG_fail;
45918 swig_obj[0] = args;
45919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45920 if (!SWIG_IsOK(res1)) {
45921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45922 }
45923 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45924 {
45925 PyThreadState* __tstate = wxPyBeginAllowThreads();
45926 result = (int)((wxMenuItem const *)arg1)->GetId();
45927 wxPyEndAllowThreads(__tstate);
45928 if (PyErr_Occurred()) SWIG_fail;
45929 }
45930 resultobj = SWIG_From_int(static_cast< int >(result));
45931 return resultobj;
45932 fail:
45933 return NULL;
45934 }
45935
45936
45937 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45938 PyObject *resultobj = 0;
45939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45940 bool result;
45941 void *argp1 = 0 ;
45942 int res1 = 0 ;
45943 PyObject *swig_obj[1] ;
45944
45945 if (!args) SWIG_fail;
45946 swig_obj[0] = args;
45947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45948 if (!SWIG_IsOK(res1)) {
45949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45950 }
45951 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45952 {
45953 PyThreadState* __tstate = wxPyBeginAllowThreads();
45954 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45955 wxPyEndAllowThreads(__tstate);
45956 if (PyErr_Occurred()) SWIG_fail;
45957 }
45958 {
45959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45960 }
45961 return resultobj;
45962 fail:
45963 return NULL;
45964 }
45965
45966
45967 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45968 PyObject *resultobj = 0;
45969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45970 wxString *arg2 = 0 ;
45971 void *argp1 = 0 ;
45972 int res1 = 0 ;
45973 bool temp2 = false ;
45974 PyObject * obj0 = 0 ;
45975 PyObject * obj1 = 0 ;
45976 char * kwnames[] = {
45977 (char *) "self",(char *) "str", NULL
45978 };
45979
45980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45982 if (!SWIG_IsOK(res1)) {
45983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45984 }
45985 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45986 {
45987 arg2 = wxString_in_helper(obj1);
45988 if (arg2 == NULL) SWIG_fail;
45989 temp2 = true;
45990 }
45991 {
45992 PyThreadState* __tstate = wxPyBeginAllowThreads();
45993 (arg1)->SetText((wxString const &)*arg2);
45994 wxPyEndAllowThreads(__tstate);
45995 if (PyErr_Occurred()) SWIG_fail;
45996 }
45997 resultobj = SWIG_Py_Void();
45998 {
45999 if (temp2)
46000 delete arg2;
46001 }
46002 return resultobj;
46003 fail:
46004 {
46005 if (temp2)
46006 delete arg2;
46007 }
46008 return NULL;
46009 }
46010
46011
46012 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46013 PyObject *resultobj = 0;
46014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46015 wxString result;
46016 void *argp1 = 0 ;
46017 int res1 = 0 ;
46018 PyObject *swig_obj[1] ;
46019
46020 if (!args) SWIG_fail;
46021 swig_obj[0] = args;
46022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46025 }
46026 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46027 {
46028 PyThreadState* __tstate = wxPyBeginAllowThreads();
46029 result = ((wxMenuItem const *)arg1)->GetLabel();
46030 wxPyEndAllowThreads(__tstate);
46031 if (PyErr_Occurred()) SWIG_fail;
46032 }
46033 {
46034 #if wxUSE_UNICODE
46035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46036 #else
46037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46038 #endif
46039 }
46040 return resultobj;
46041 fail:
46042 return NULL;
46043 }
46044
46045
46046 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46047 PyObject *resultobj = 0;
46048 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46049 wxString *result = 0 ;
46050 void *argp1 = 0 ;
46051 int res1 = 0 ;
46052 PyObject *swig_obj[1] ;
46053
46054 if (!args) SWIG_fail;
46055 swig_obj[0] = args;
46056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46057 if (!SWIG_IsOK(res1)) {
46058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46059 }
46060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46061 {
46062 PyThreadState* __tstate = wxPyBeginAllowThreads();
46063 {
46064 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46065 result = (wxString *) &_result_ref;
46066 }
46067 wxPyEndAllowThreads(__tstate);
46068 if (PyErr_Occurred()) SWIG_fail;
46069 }
46070 {
46071 #if wxUSE_UNICODE
46072 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46073 #else
46074 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46075 #endif
46076 }
46077 return resultobj;
46078 fail:
46079 return NULL;
46080 }
46081
46082
46083 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46084 PyObject *resultobj = 0;
46085 wxString *arg1 = 0 ;
46086 wxString result;
46087 bool temp1 = false ;
46088 PyObject * obj0 = 0 ;
46089 char * kwnames[] = {
46090 (char *) "text", NULL
46091 };
46092
46093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46094 {
46095 arg1 = wxString_in_helper(obj0);
46096 if (arg1 == NULL) SWIG_fail;
46097 temp1 = true;
46098 }
46099 {
46100 PyThreadState* __tstate = wxPyBeginAllowThreads();
46101 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46102 wxPyEndAllowThreads(__tstate);
46103 if (PyErr_Occurred()) SWIG_fail;
46104 }
46105 {
46106 #if wxUSE_UNICODE
46107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46108 #else
46109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46110 #endif
46111 }
46112 {
46113 if (temp1)
46114 delete arg1;
46115 }
46116 return resultobj;
46117 fail:
46118 {
46119 if (temp1)
46120 delete arg1;
46121 }
46122 return NULL;
46123 }
46124
46125
46126 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46127 PyObject *resultobj = 0;
46128 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46129 wxItemKind result;
46130 void *argp1 = 0 ;
46131 int res1 = 0 ;
46132 PyObject *swig_obj[1] ;
46133
46134 if (!args) SWIG_fail;
46135 swig_obj[0] = args;
46136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46137 if (!SWIG_IsOK(res1)) {
46138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46139 }
46140 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46141 {
46142 PyThreadState* __tstate = wxPyBeginAllowThreads();
46143 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46144 wxPyEndAllowThreads(__tstate);
46145 if (PyErr_Occurred()) SWIG_fail;
46146 }
46147 resultobj = SWIG_From_int(static_cast< int >(result));
46148 return resultobj;
46149 fail:
46150 return NULL;
46151 }
46152
46153
46154 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46155 PyObject *resultobj = 0;
46156 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46157 wxItemKind arg2 ;
46158 void *argp1 = 0 ;
46159 int res1 = 0 ;
46160 int val2 ;
46161 int ecode2 = 0 ;
46162 PyObject * obj0 = 0 ;
46163 PyObject * obj1 = 0 ;
46164 char * kwnames[] = {
46165 (char *) "self",(char *) "kind", NULL
46166 };
46167
46168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46170 if (!SWIG_IsOK(res1)) {
46171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46172 }
46173 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46174 ecode2 = SWIG_AsVal_int(obj1, &val2);
46175 if (!SWIG_IsOK(ecode2)) {
46176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46177 }
46178 arg2 = static_cast< wxItemKind >(val2);
46179 {
46180 PyThreadState* __tstate = wxPyBeginAllowThreads();
46181 (arg1)->SetKind(arg2);
46182 wxPyEndAllowThreads(__tstate);
46183 if (PyErr_Occurred()) SWIG_fail;
46184 }
46185 resultobj = SWIG_Py_Void();
46186 return resultobj;
46187 fail:
46188 return NULL;
46189 }
46190
46191
46192 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46193 PyObject *resultobj = 0;
46194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46195 bool arg2 ;
46196 void *argp1 = 0 ;
46197 int res1 = 0 ;
46198 bool val2 ;
46199 int ecode2 = 0 ;
46200 PyObject * obj0 = 0 ;
46201 PyObject * obj1 = 0 ;
46202 char * kwnames[] = {
46203 (char *) "self",(char *) "checkable", NULL
46204 };
46205
46206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46208 if (!SWIG_IsOK(res1)) {
46209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46210 }
46211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46212 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46213 if (!SWIG_IsOK(ecode2)) {
46214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46215 }
46216 arg2 = static_cast< bool >(val2);
46217 {
46218 PyThreadState* __tstate = wxPyBeginAllowThreads();
46219 (arg1)->SetCheckable(arg2);
46220 wxPyEndAllowThreads(__tstate);
46221 if (PyErr_Occurred()) SWIG_fail;
46222 }
46223 resultobj = SWIG_Py_Void();
46224 return resultobj;
46225 fail:
46226 return NULL;
46227 }
46228
46229
46230 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46231 PyObject *resultobj = 0;
46232 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46233 bool result;
46234 void *argp1 = 0 ;
46235 int res1 = 0 ;
46236 PyObject *swig_obj[1] ;
46237
46238 if (!args) SWIG_fail;
46239 swig_obj[0] = args;
46240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46241 if (!SWIG_IsOK(res1)) {
46242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46243 }
46244 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46245 {
46246 PyThreadState* __tstate = wxPyBeginAllowThreads();
46247 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46248 wxPyEndAllowThreads(__tstate);
46249 if (PyErr_Occurred()) SWIG_fail;
46250 }
46251 {
46252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46253 }
46254 return resultobj;
46255 fail:
46256 return NULL;
46257 }
46258
46259
46260 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46261 PyObject *resultobj = 0;
46262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46263 bool result;
46264 void *argp1 = 0 ;
46265 int res1 = 0 ;
46266 PyObject *swig_obj[1] ;
46267
46268 if (!args) SWIG_fail;
46269 swig_obj[0] = args;
46270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46271 if (!SWIG_IsOK(res1)) {
46272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46273 }
46274 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46275 {
46276 PyThreadState* __tstate = wxPyBeginAllowThreads();
46277 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46278 wxPyEndAllowThreads(__tstate);
46279 if (PyErr_Occurred()) SWIG_fail;
46280 }
46281 {
46282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46283 }
46284 return resultobj;
46285 fail:
46286 return NULL;
46287 }
46288
46289
46290 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46291 PyObject *resultobj = 0;
46292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46293 wxMenu *arg2 = (wxMenu *) 0 ;
46294 void *argp1 = 0 ;
46295 int res1 = 0 ;
46296 void *argp2 = 0 ;
46297 int res2 = 0 ;
46298 PyObject * obj0 = 0 ;
46299 PyObject * obj1 = 0 ;
46300 char * kwnames[] = {
46301 (char *) "self",(char *) "menu", NULL
46302 };
46303
46304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46306 if (!SWIG_IsOK(res1)) {
46307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46308 }
46309 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46311 if (!SWIG_IsOK(res2)) {
46312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46313 }
46314 arg2 = reinterpret_cast< wxMenu * >(argp2);
46315 {
46316 PyThreadState* __tstate = wxPyBeginAllowThreads();
46317 (arg1)->SetSubMenu(arg2);
46318 wxPyEndAllowThreads(__tstate);
46319 if (PyErr_Occurred()) SWIG_fail;
46320 }
46321 resultobj = SWIG_Py_Void();
46322 return resultobj;
46323 fail:
46324 return NULL;
46325 }
46326
46327
46328 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46329 PyObject *resultobj = 0;
46330 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46331 wxMenu *result = 0 ;
46332 void *argp1 = 0 ;
46333 int res1 = 0 ;
46334 PyObject *swig_obj[1] ;
46335
46336 if (!args) SWIG_fail;
46337 swig_obj[0] = args;
46338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46339 if (!SWIG_IsOK(res1)) {
46340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46341 }
46342 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46343 {
46344 PyThreadState* __tstate = wxPyBeginAllowThreads();
46345 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46346 wxPyEndAllowThreads(__tstate);
46347 if (PyErr_Occurred()) SWIG_fail;
46348 }
46349 {
46350 resultobj = wxPyMake_wxObject(result, 0);
46351 }
46352 return resultobj;
46353 fail:
46354 return NULL;
46355 }
46356
46357
46358 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46359 PyObject *resultobj = 0;
46360 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46361 bool arg2 = (bool) true ;
46362 void *argp1 = 0 ;
46363 int res1 = 0 ;
46364 bool val2 ;
46365 int ecode2 = 0 ;
46366 PyObject * obj0 = 0 ;
46367 PyObject * obj1 = 0 ;
46368 char * kwnames[] = {
46369 (char *) "self",(char *) "enable", NULL
46370 };
46371
46372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46374 if (!SWIG_IsOK(res1)) {
46375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46376 }
46377 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46378 if (obj1) {
46379 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46380 if (!SWIG_IsOK(ecode2)) {
46381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46382 }
46383 arg2 = static_cast< bool >(val2);
46384 }
46385 {
46386 PyThreadState* __tstate = wxPyBeginAllowThreads();
46387 (arg1)->Enable(arg2);
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_Py_Void();
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46399 PyObject *resultobj = 0;
46400 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46401 bool result;
46402 void *argp1 = 0 ;
46403 int res1 = 0 ;
46404 PyObject *swig_obj[1] ;
46405
46406 if (!args) SWIG_fail;
46407 swig_obj[0] = args;
46408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46409 if (!SWIG_IsOK(res1)) {
46410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46411 }
46412 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46413 {
46414 PyThreadState* __tstate = wxPyBeginAllowThreads();
46415 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46416 wxPyEndAllowThreads(__tstate);
46417 if (PyErr_Occurred()) SWIG_fail;
46418 }
46419 {
46420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46421 }
46422 return resultobj;
46423 fail:
46424 return NULL;
46425 }
46426
46427
46428 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46429 PyObject *resultobj = 0;
46430 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46431 bool arg2 = (bool) true ;
46432 void *argp1 = 0 ;
46433 int res1 = 0 ;
46434 bool val2 ;
46435 int ecode2 = 0 ;
46436 PyObject * obj0 = 0 ;
46437 PyObject * obj1 = 0 ;
46438 char * kwnames[] = {
46439 (char *) "self",(char *) "check", NULL
46440 };
46441
46442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46444 if (!SWIG_IsOK(res1)) {
46445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46446 }
46447 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46448 if (obj1) {
46449 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46450 if (!SWIG_IsOK(ecode2)) {
46451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46452 }
46453 arg2 = static_cast< bool >(val2);
46454 }
46455 {
46456 PyThreadState* __tstate = wxPyBeginAllowThreads();
46457 (arg1)->Check(arg2);
46458 wxPyEndAllowThreads(__tstate);
46459 if (PyErr_Occurred()) SWIG_fail;
46460 }
46461 resultobj = SWIG_Py_Void();
46462 return resultobj;
46463 fail:
46464 return NULL;
46465 }
46466
46467
46468 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46469 PyObject *resultobj = 0;
46470 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46471 bool result;
46472 void *argp1 = 0 ;
46473 int res1 = 0 ;
46474 PyObject *swig_obj[1] ;
46475
46476 if (!args) SWIG_fail;
46477 swig_obj[0] = args;
46478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46479 if (!SWIG_IsOK(res1)) {
46480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46481 }
46482 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46483 {
46484 PyThreadState* __tstate = wxPyBeginAllowThreads();
46485 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46486 wxPyEndAllowThreads(__tstate);
46487 if (PyErr_Occurred()) SWIG_fail;
46488 }
46489 {
46490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46491 }
46492 return resultobj;
46493 fail:
46494 return NULL;
46495 }
46496
46497
46498 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46499 PyObject *resultobj = 0;
46500 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 PyObject *swig_obj[1] ;
46504
46505 if (!args) SWIG_fail;
46506 swig_obj[0] = args;
46507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46508 if (!SWIG_IsOK(res1)) {
46509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46510 }
46511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46512 {
46513 PyThreadState* __tstate = wxPyBeginAllowThreads();
46514 (arg1)->Toggle();
46515 wxPyEndAllowThreads(__tstate);
46516 if (PyErr_Occurred()) SWIG_fail;
46517 }
46518 resultobj = SWIG_Py_Void();
46519 return resultobj;
46520 fail:
46521 return NULL;
46522 }
46523
46524
46525 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46526 PyObject *resultobj = 0;
46527 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46528 wxString *arg2 = 0 ;
46529 void *argp1 = 0 ;
46530 int res1 = 0 ;
46531 bool temp2 = false ;
46532 PyObject * obj0 = 0 ;
46533 PyObject * obj1 = 0 ;
46534 char * kwnames[] = {
46535 (char *) "self",(char *) "str", NULL
46536 };
46537
46538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46540 if (!SWIG_IsOK(res1)) {
46541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46542 }
46543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46544 {
46545 arg2 = wxString_in_helper(obj1);
46546 if (arg2 == NULL) SWIG_fail;
46547 temp2 = true;
46548 }
46549 {
46550 PyThreadState* __tstate = wxPyBeginAllowThreads();
46551 (arg1)->SetHelp((wxString const &)*arg2);
46552 wxPyEndAllowThreads(__tstate);
46553 if (PyErr_Occurred()) SWIG_fail;
46554 }
46555 resultobj = SWIG_Py_Void();
46556 {
46557 if (temp2)
46558 delete arg2;
46559 }
46560 return resultobj;
46561 fail:
46562 {
46563 if (temp2)
46564 delete arg2;
46565 }
46566 return NULL;
46567 }
46568
46569
46570 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46571 PyObject *resultobj = 0;
46572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46573 wxString *result = 0 ;
46574 void *argp1 = 0 ;
46575 int res1 = 0 ;
46576 PyObject *swig_obj[1] ;
46577
46578 if (!args) SWIG_fail;
46579 swig_obj[0] = args;
46580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46581 if (!SWIG_IsOK(res1)) {
46582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46583 }
46584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46585 {
46586 PyThreadState* __tstate = wxPyBeginAllowThreads();
46587 {
46588 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46589 result = (wxString *) &_result_ref;
46590 }
46591 wxPyEndAllowThreads(__tstate);
46592 if (PyErr_Occurred()) SWIG_fail;
46593 }
46594 {
46595 #if wxUSE_UNICODE
46596 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46597 #else
46598 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46599 #endif
46600 }
46601 return resultobj;
46602 fail:
46603 return NULL;
46604 }
46605
46606
46607 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46608 PyObject *resultobj = 0;
46609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46610 wxAcceleratorEntry *result = 0 ;
46611 void *argp1 = 0 ;
46612 int res1 = 0 ;
46613 PyObject *swig_obj[1] ;
46614
46615 if (!args) SWIG_fail;
46616 swig_obj[0] = args;
46617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46618 if (!SWIG_IsOK(res1)) {
46619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46620 }
46621 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46622 {
46623 PyThreadState* __tstate = wxPyBeginAllowThreads();
46624 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46625 wxPyEndAllowThreads(__tstate);
46626 if (PyErr_Occurred()) SWIG_fail;
46627 }
46628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46629 return resultobj;
46630 fail:
46631 return NULL;
46632 }
46633
46634
46635 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46636 PyObject *resultobj = 0;
46637 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46638 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46639 void *argp1 = 0 ;
46640 int res1 = 0 ;
46641 void *argp2 = 0 ;
46642 int res2 = 0 ;
46643 PyObject * obj0 = 0 ;
46644 PyObject * obj1 = 0 ;
46645 char * kwnames[] = {
46646 (char *) "self",(char *) "accel", NULL
46647 };
46648
46649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46651 if (!SWIG_IsOK(res1)) {
46652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46653 }
46654 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46656 if (!SWIG_IsOK(res2)) {
46657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46658 }
46659 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46660 {
46661 PyThreadState* __tstate = wxPyBeginAllowThreads();
46662 (arg1)->SetAccel(arg2);
46663 wxPyEndAllowThreads(__tstate);
46664 if (PyErr_Occurred()) SWIG_fail;
46665 }
46666 resultobj = SWIG_Py_Void();
46667 return resultobj;
46668 fail:
46669 return NULL;
46670 }
46671
46672
46673 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46674 PyObject *resultobj = 0;
46675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46676 wxBitmap *arg2 = 0 ;
46677 void *argp1 = 0 ;
46678 int res1 = 0 ;
46679 void *argp2 = 0 ;
46680 int res2 = 0 ;
46681 PyObject * obj0 = 0 ;
46682 PyObject * obj1 = 0 ;
46683 char * kwnames[] = {
46684 (char *) "self",(char *) "bitmap", NULL
46685 };
46686
46687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46689 if (!SWIG_IsOK(res1)) {
46690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46691 }
46692 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46693 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46694 if (!SWIG_IsOK(res2)) {
46695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46696 }
46697 if (!argp2) {
46698 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46699 }
46700 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46701 {
46702 PyThreadState* __tstate = wxPyBeginAllowThreads();
46703 (arg1)->SetBitmap((wxBitmap const &)*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_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46715 PyObject *resultobj = 0;
46716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46717 wxBitmap *result = 0 ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 PyObject *swig_obj[1] ;
46721
46722 if (!args) SWIG_fail;
46723 swig_obj[0] = args;
46724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46725 if (!SWIG_IsOK(res1)) {
46726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46727 }
46728 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46729 {
46730 PyThreadState* __tstate = wxPyBeginAllowThreads();
46731 {
46732 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46733 result = (wxBitmap *) &_result_ref;
46734 }
46735 wxPyEndAllowThreads(__tstate);
46736 if (PyErr_Occurred()) SWIG_fail;
46737 }
46738 {
46739 wxBitmap* resultptr = new wxBitmap(*result);
46740 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46741 }
46742 return resultobj;
46743 fail:
46744 return NULL;
46745 }
46746
46747
46748 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46749 PyObject *resultobj = 0;
46750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46751 wxFont *arg2 = 0 ;
46752 void *argp1 = 0 ;
46753 int res1 = 0 ;
46754 void *argp2 = 0 ;
46755 int res2 = 0 ;
46756 PyObject * obj0 = 0 ;
46757 PyObject * obj1 = 0 ;
46758 char * kwnames[] = {
46759 (char *) "self",(char *) "font", NULL
46760 };
46761
46762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46764 if (!SWIG_IsOK(res1)) {
46765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46766 }
46767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46768 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46769 if (!SWIG_IsOK(res2)) {
46770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46771 }
46772 if (!argp2) {
46773 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46774 }
46775 arg2 = reinterpret_cast< wxFont * >(argp2);
46776 {
46777 PyThreadState* __tstate = wxPyBeginAllowThreads();
46778 (arg1)->SetFont((wxFont const &)*arg2);
46779 wxPyEndAllowThreads(__tstate);
46780 if (PyErr_Occurred()) SWIG_fail;
46781 }
46782 resultobj = SWIG_Py_Void();
46783 return resultobj;
46784 fail:
46785 return NULL;
46786 }
46787
46788
46789 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46790 PyObject *resultobj = 0;
46791 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46792 wxFont result;
46793 void *argp1 = 0 ;
46794 int res1 = 0 ;
46795 PyObject *swig_obj[1] ;
46796
46797 if (!args) SWIG_fail;
46798 swig_obj[0] = args;
46799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46800 if (!SWIG_IsOK(res1)) {
46801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46802 }
46803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46804 {
46805 PyThreadState* __tstate = wxPyBeginAllowThreads();
46806 result = (arg1)->GetFont();
46807 wxPyEndAllowThreads(__tstate);
46808 if (PyErr_Occurred()) SWIG_fail;
46809 }
46810 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46811 return resultobj;
46812 fail:
46813 return NULL;
46814 }
46815
46816
46817 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46818 PyObject *resultobj = 0;
46819 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46820 wxColour *arg2 = 0 ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 wxColour temp2 ;
46824 PyObject * obj0 = 0 ;
46825 PyObject * obj1 = 0 ;
46826 char * kwnames[] = {
46827 (char *) "self",(char *) "colText", NULL
46828 };
46829
46830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46832 if (!SWIG_IsOK(res1)) {
46833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46834 }
46835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46836 {
46837 arg2 = &temp2;
46838 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46839 }
46840 {
46841 PyThreadState* __tstate = wxPyBeginAllowThreads();
46842 (arg1)->SetTextColour((wxColour const &)*arg2);
46843 wxPyEndAllowThreads(__tstate);
46844 if (PyErr_Occurred()) SWIG_fail;
46845 }
46846 resultobj = SWIG_Py_Void();
46847 return resultobj;
46848 fail:
46849 return NULL;
46850 }
46851
46852
46853 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46854 PyObject *resultobj = 0;
46855 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46856 wxColour result;
46857 void *argp1 = 0 ;
46858 int res1 = 0 ;
46859 PyObject *swig_obj[1] ;
46860
46861 if (!args) SWIG_fail;
46862 swig_obj[0] = args;
46863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46864 if (!SWIG_IsOK(res1)) {
46865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46866 }
46867 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46868 {
46869 PyThreadState* __tstate = wxPyBeginAllowThreads();
46870 result = (arg1)->GetTextColour();
46871 wxPyEndAllowThreads(__tstate);
46872 if (PyErr_Occurred()) SWIG_fail;
46873 }
46874 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46875 return resultobj;
46876 fail:
46877 return NULL;
46878 }
46879
46880
46881 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46882 PyObject *resultobj = 0;
46883 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46884 wxColour *arg2 = 0 ;
46885 void *argp1 = 0 ;
46886 int res1 = 0 ;
46887 wxColour temp2 ;
46888 PyObject * obj0 = 0 ;
46889 PyObject * obj1 = 0 ;
46890 char * kwnames[] = {
46891 (char *) "self",(char *) "colBack", NULL
46892 };
46893
46894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46896 if (!SWIG_IsOK(res1)) {
46897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46898 }
46899 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46900 {
46901 arg2 = &temp2;
46902 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46903 }
46904 {
46905 PyThreadState* __tstate = wxPyBeginAllowThreads();
46906 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46907 wxPyEndAllowThreads(__tstate);
46908 if (PyErr_Occurred()) SWIG_fail;
46909 }
46910 resultobj = SWIG_Py_Void();
46911 return resultobj;
46912 fail:
46913 return NULL;
46914 }
46915
46916
46917 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46918 PyObject *resultobj = 0;
46919 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46920 wxColour result;
46921 void *argp1 = 0 ;
46922 int res1 = 0 ;
46923 PyObject *swig_obj[1] ;
46924
46925 if (!args) SWIG_fail;
46926 swig_obj[0] = args;
46927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46928 if (!SWIG_IsOK(res1)) {
46929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46930 }
46931 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46932 {
46933 PyThreadState* __tstate = wxPyBeginAllowThreads();
46934 result = (arg1)->GetBackgroundColour();
46935 wxPyEndAllowThreads(__tstate);
46936 if (PyErr_Occurred()) SWIG_fail;
46937 }
46938 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46939 return resultobj;
46940 fail:
46941 return NULL;
46942 }
46943
46944
46945 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46946 PyObject *resultobj = 0;
46947 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46948 wxBitmap *arg2 = 0 ;
46949 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46950 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46951 void *argp1 = 0 ;
46952 int res1 = 0 ;
46953 void *argp2 = 0 ;
46954 int res2 = 0 ;
46955 void *argp3 = 0 ;
46956 int res3 = 0 ;
46957 PyObject * obj0 = 0 ;
46958 PyObject * obj1 = 0 ;
46959 PyObject * obj2 = 0 ;
46960 char * kwnames[] = {
46961 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46962 };
46963
46964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46966 if (!SWIG_IsOK(res1)) {
46967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46968 }
46969 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46971 if (!SWIG_IsOK(res2)) {
46972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46973 }
46974 if (!argp2) {
46975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46976 }
46977 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46978 if (obj2) {
46979 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46980 if (!SWIG_IsOK(res3)) {
46981 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46982 }
46983 if (!argp3) {
46984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46985 }
46986 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46987 }
46988 {
46989 PyThreadState* __tstate = wxPyBeginAllowThreads();
46990 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46991 wxPyEndAllowThreads(__tstate);
46992 if (PyErr_Occurred()) SWIG_fail;
46993 }
46994 resultobj = SWIG_Py_Void();
46995 return resultobj;
46996 fail:
46997 return NULL;
46998 }
46999
47000
47001 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47002 PyObject *resultobj = 0;
47003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47004 wxBitmap *arg2 = 0 ;
47005 void *argp1 = 0 ;
47006 int res1 = 0 ;
47007 void *argp2 = 0 ;
47008 int res2 = 0 ;
47009 PyObject * obj0 = 0 ;
47010 PyObject * obj1 = 0 ;
47011 char * kwnames[] = {
47012 (char *) "self",(char *) "bmpDisabled", NULL
47013 };
47014
47015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47017 if (!SWIG_IsOK(res1)) {
47018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47019 }
47020 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47022 if (!SWIG_IsOK(res2)) {
47023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47024 }
47025 if (!argp2) {
47026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47027 }
47028 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47029 {
47030 PyThreadState* __tstate = wxPyBeginAllowThreads();
47031 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47032 wxPyEndAllowThreads(__tstate);
47033 if (PyErr_Occurred()) SWIG_fail;
47034 }
47035 resultobj = SWIG_Py_Void();
47036 return resultobj;
47037 fail:
47038 return NULL;
47039 }
47040
47041
47042 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47043 PyObject *resultobj = 0;
47044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47045 wxBitmap *result = 0 ;
47046 void *argp1 = 0 ;
47047 int res1 = 0 ;
47048 PyObject *swig_obj[1] ;
47049
47050 if (!args) SWIG_fail;
47051 swig_obj[0] = args;
47052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47053 if (!SWIG_IsOK(res1)) {
47054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47055 }
47056 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47057 {
47058 PyThreadState* __tstate = wxPyBeginAllowThreads();
47059 {
47060 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47061 result = (wxBitmap *) &_result_ref;
47062 }
47063 wxPyEndAllowThreads(__tstate);
47064 if (PyErr_Occurred()) SWIG_fail;
47065 }
47066 {
47067 wxBitmap* resultptr = new wxBitmap(*result);
47068 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47069 }
47070 return resultobj;
47071 fail:
47072 return NULL;
47073 }
47074
47075
47076 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47077 PyObject *resultobj = 0;
47078 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47079 int arg2 ;
47080 void *argp1 = 0 ;
47081 int res1 = 0 ;
47082 int val2 ;
47083 int ecode2 = 0 ;
47084 PyObject * obj0 = 0 ;
47085 PyObject * obj1 = 0 ;
47086 char * kwnames[] = {
47087 (char *) "self",(char *) "nWidth", NULL
47088 };
47089
47090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47092 if (!SWIG_IsOK(res1)) {
47093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47094 }
47095 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47096 ecode2 = SWIG_AsVal_int(obj1, &val2);
47097 if (!SWIG_IsOK(ecode2)) {
47098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47099 }
47100 arg2 = static_cast< int >(val2);
47101 {
47102 PyThreadState* __tstate = wxPyBeginAllowThreads();
47103 (arg1)->SetMarginWidth(arg2);
47104 wxPyEndAllowThreads(__tstate);
47105 if (PyErr_Occurred()) SWIG_fail;
47106 }
47107 resultobj = SWIG_Py_Void();
47108 return resultobj;
47109 fail:
47110 return NULL;
47111 }
47112
47113
47114 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47115 PyObject *resultobj = 0;
47116 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47117 int result;
47118 void *argp1 = 0 ;
47119 int res1 = 0 ;
47120 PyObject *swig_obj[1] ;
47121
47122 if (!args) SWIG_fail;
47123 swig_obj[0] = args;
47124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47125 if (!SWIG_IsOK(res1)) {
47126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47127 }
47128 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47129 {
47130 PyThreadState* __tstate = wxPyBeginAllowThreads();
47131 result = (int)(arg1)->GetMarginWidth();
47132 wxPyEndAllowThreads(__tstate);
47133 if (PyErr_Occurred()) SWIG_fail;
47134 }
47135 resultobj = SWIG_From_int(static_cast< int >(result));
47136 return resultobj;
47137 fail:
47138 return NULL;
47139 }
47140
47141
47142 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47143 PyObject *resultobj = 0;
47144 int result;
47145
47146 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47147 {
47148 PyThreadState* __tstate = wxPyBeginAllowThreads();
47149 result = (int)wxMenuItem::GetDefaultMarginWidth();
47150 wxPyEndAllowThreads(__tstate);
47151 if (PyErr_Occurred()) SWIG_fail;
47152 }
47153 resultobj = SWIG_From_int(static_cast< int >(result));
47154 return resultobj;
47155 fail:
47156 return NULL;
47157 }
47158
47159
47160 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47161 PyObject *resultobj = 0;
47162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47163 bool result;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 PyObject *swig_obj[1] ;
47167
47168 if (!args) SWIG_fail;
47169 swig_obj[0] = args;
47170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47171 if (!SWIG_IsOK(res1)) {
47172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47173 }
47174 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47175 {
47176 PyThreadState* __tstate = wxPyBeginAllowThreads();
47177 result = (bool)(arg1)->IsOwnerDrawn();
47178 wxPyEndAllowThreads(__tstate);
47179 if (PyErr_Occurred()) SWIG_fail;
47180 }
47181 {
47182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47183 }
47184 return resultobj;
47185 fail:
47186 return NULL;
47187 }
47188
47189
47190 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47191 PyObject *resultobj = 0;
47192 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47193 bool arg2 = (bool) true ;
47194 void *argp1 = 0 ;
47195 int res1 = 0 ;
47196 bool val2 ;
47197 int ecode2 = 0 ;
47198 PyObject * obj0 = 0 ;
47199 PyObject * obj1 = 0 ;
47200 char * kwnames[] = {
47201 (char *) "self",(char *) "ownerDrawn", NULL
47202 };
47203
47204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47206 if (!SWIG_IsOK(res1)) {
47207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47208 }
47209 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47210 if (obj1) {
47211 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47212 if (!SWIG_IsOK(ecode2)) {
47213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47214 }
47215 arg2 = static_cast< bool >(val2);
47216 }
47217 {
47218 PyThreadState* __tstate = wxPyBeginAllowThreads();
47219 (arg1)->SetOwnerDrawn(arg2);
47220 wxPyEndAllowThreads(__tstate);
47221 if (PyErr_Occurred()) SWIG_fail;
47222 }
47223 resultobj = SWIG_Py_Void();
47224 return resultobj;
47225 fail:
47226 return NULL;
47227 }
47228
47229
47230 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47231 PyObject *resultobj = 0;
47232 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47233 void *argp1 = 0 ;
47234 int res1 = 0 ;
47235 PyObject *swig_obj[1] ;
47236
47237 if (!args) SWIG_fail;
47238 swig_obj[0] = args;
47239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47240 if (!SWIG_IsOK(res1)) {
47241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47242 }
47243 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47244 {
47245 PyThreadState* __tstate = wxPyBeginAllowThreads();
47246 (arg1)->ResetOwnerDrawn();
47247 wxPyEndAllowThreads(__tstate);
47248 if (PyErr_Occurred()) SWIG_fail;
47249 }
47250 resultobj = SWIG_Py_Void();
47251 return resultobj;
47252 fail:
47253 return NULL;
47254 }
47255
47256
47257 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47258 PyObject *obj;
47259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47260 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47261 return SWIG_Py_Void();
47262 }
47263
47264 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47265 return SWIG_Python_InitShadowInstance(args);
47266 }
47267
47268 SWIGINTERN int ControlNameStr_set(PyObject *) {
47269 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47270 return 1;
47271 }
47272
47273
47274 SWIGINTERN PyObject *ControlNameStr_get(void) {
47275 PyObject *pyobj = 0;
47276
47277 {
47278 #if wxUSE_UNICODE
47279 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47280 #else
47281 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47282 #endif
47283 }
47284 return pyobj;
47285 }
47286
47287
47288 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47289 PyObject *resultobj = 0;
47290 wxWindow *arg1 = (wxWindow *) 0 ;
47291 int arg2 = (int) -1 ;
47292 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47293 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47294 wxSize const &arg4_defvalue = wxDefaultSize ;
47295 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47296 long arg5 = (long) 0 ;
47297 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47298 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47299 wxString const &arg7_defvalue = wxPyControlNameStr ;
47300 wxString *arg7 = (wxString *) &arg7_defvalue ;
47301 wxControl *result = 0 ;
47302 void *argp1 = 0 ;
47303 int res1 = 0 ;
47304 int val2 ;
47305 int ecode2 = 0 ;
47306 wxPoint temp3 ;
47307 wxSize temp4 ;
47308 long val5 ;
47309 int ecode5 = 0 ;
47310 void *argp6 = 0 ;
47311 int res6 = 0 ;
47312 bool temp7 = false ;
47313 PyObject * obj0 = 0 ;
47314 PyObject * obj1 = 0 ;
47315 PyObject * obj2 = 0 ;
47316 PyObject * obj3 = 0 ;
47317 PyObject * obj4 = 0 ;
47318 PyObject * obj5 = 0 ;
47319 PyObject * obj6 = 0 ;
47320 char * kwnames[] = {
47321 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47322 };
47323
47324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47326 if (!SWIG_IsOK(res1)) {
47327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47328 }
47329 arg1 = reinterpret_cast< wxWindow * >(argp1);
47330 if (obj1) {
47331 ecode2 = SWIG_AsVal_int(obj1, &val2);
47332 if (!SWIG_IsOK(ecode2)) {
47333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47334 }
47335 arg2 = static_cast< int >(val2);
47336 }
47337 if (obj2) {
47338 {
47339 arg3 = &temp3;
47340 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47341 }
47342 }
47343 if (obj3) {
47344 {
47345 arg4 = &temp4;
47346 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47347 }
47348 }
47349 if (obj4) {
47350 ecode5 = SWIG_AsVal_long(obj4, &val5);
47351 if (!SWIG_IsOK(ecode5)) {
47352 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47353 }
47354 arg5 = static_cast< long >(val5);
47355 }
47356 if (obj5) {
47357 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47358 if (!SWIG_IsOK(res6)) {
47359 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47360 }
47361 if (!argp6) {
47362 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47363 }
47364 arg6 = reinterpret_cast< wxValidator * >(argp6);
47365 }
47366 if (obj6) {
47367 {
47368 arg7 = wxString_in_helper(obj6);
47369 if (arg7 == NULL) SWIG_fail;
47370 temp7 = true;
47371 }
47372 }
47373 {
47374 if (!wxPyCheckForApp()) SWIG_fail;
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47377 wxPyEndAllowThreads(__tstate);
47378 if (PyErr_Occurred()) SWIG_fail;
47379 }
47380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47381 {
47382 if (temp7)
47383 delete arg7;
47384 }
47385 return resultobj;
47386 fail:
47387 {
47388 if (temp7)
47389 delete arg7;
47390 }
47391 return NULL;
47392 }
47393
47394
47395 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47396 PyObject *resultobj = 0;
47397 wxControl *result = 0 ;
47398
47399 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47400 {
47401 if (!wxPyCheckForApp()) SWIG_fail;
47402 PyThreadState* __tstate = wxPyBeginAllowThreads();
47403 result = (wxControl *)new wxControl();
47404 wxPyEndAllowThreads(__tstate);
47405 if (PyErr_Occurred()) SWIG_fail;
47406 }
47407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47408 return resultobj;
47409 fail:
47410 return NULL;
47411 }
47412
47413
47414 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47415 PyObject *resultobj = 0;
47416 wxControl *arg1 = (wxControl *) 0 ;
47417 wxWindow *arg2 = (wxWindow *) 0 ;
47418 int arg3 = (int) -1 ;
47419 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47420 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47421 wxSize const &arg5_defvalue = wxDefaultSize ;
47422 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47423 long arg6 = (long) 0 ;
47424 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47425 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47426 wxString const &arg8_defvalue = wxPyControlNameStr ;
47427 wxString *arg8 = (wxString *) &arg8_defvalue ;
47428 bool result;
47429 void *argp1 = 0 ;
47430 int res1 = 0 ;
47431 void *argp2 = 0 ;
47432 int res2 = 0 ;
47433 int val3 ;
47434 int ecode3 = 0 ;
47435 wxPoint temp4 ;
47436 wxSize temp5 ;
47437 long val6 ;
47438 int ecode6 = 0 ;
47439 void *argp7 = 0 ;
47440 int res7 = 0 ;
47441 bool temp8 = false ;
47442 PyObject * obj0 = 0 ;
47443 PyObject * obj1 = 0 ;
47444 PyObject * obj2 = 0 ;
47445 PyObject * obj3 = 0 ;
47446 PyObject * obj4 = 0 ;
47447 PyObject * obj5 = 0 ;
47448 PyObject * obj6 = 0 ;
47449 PyObject * obj7 = 0 ;
47450 char * kwnames[] = {
47451 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47452 };
47453
47454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47456 if (!SWIG_IsOK(res1)) {
47457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47458 }
47459 arg1 = reinterpret_cast< wxControl * >(argp1);
47460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47461 if (!SWIG_IsOK(res2)) {
47462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47463 }
47464 arg2 = reinterpret_cast< wxWindow * >(argp2);
47465 if (obj2) {
47466 ecode3 = SWIG_AsVal_int(obj2, &val3);
47467 if (!SWIG_IsOK(ecode3)) {
47468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47469 }
47470 arg3 = static_cast< int >(val3);
47471 }
47472 if (obj3) {
47473 {
47474 arg4 = &temp4;
47475 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47476 }
47477 }
47478 if (obj4) {
47479 {
47480 arg5 = &temp5;
47481 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47482 }
47483 }
47484 if (obj5) {
47485 ecode6 = SWIG_AsVal_long(obj5, &val6);
47486 if (!SWIG_IsOK(ecode6)) {
47487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47488 }
47489 arg6 = static_cast< long >(val6);
47490 }
47491 if (obj6) {
47492 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47493 if (!SWIG_IsOK(res7)) {
47494 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47495 }
47496 if (!argp7) {
47497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47498 }
47499 arg7 = reinterpret_cast< wxValidator * >(argp7);
47500 }
47501 if (obj7) {
47502 {
47503 arg8 = wxString_in_helper(obj7);
47504 if (arg8 == NULL) SWIG_fail;
47505 temp8 = true;
47506 }
47507 }
47508 {
47509 PyThreadState* __tstate = wxPyBeginAllowThreads();
47510 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47511 wxPyEndAllowThreads(__tstate);
47512 if (PyErr_Occurred()) SWIG_fail;
47513 }
47514 {
47515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47516 }
47517 {
47518 if (temp8)
47519 delete arg8;
47520 }
47521 return resultobj;
47522 fail:
47523 {
47524 if (temp8)
47525 delete arg8;
47526 }
47527 return NULL;
47528 }
47529
47530
47531 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47532 PyObject *resultobj = 0;
47533 wxControl *arg1 = (wxControl *) 0 ;
47534 int result;
47535 void *argp1 = 0 ;
47536 int res1 = 0 ;
47537 PyObject *swig_obj[1] ;
47538
47539 if (!args) SWIG_fail;
47540 swig_obj[0] = args;
47541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47542 if (!SWIG_IsOK(res1)) {
47543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47544 }
47545 arg1 = reinterpret_cast< wxControl * >(argp1);
47546 {
47547 PyThreadState* __tstate = wxPyBeginAllowThreads();
47548 result = (int)((wxControl const *)arg1)->GetAlignment();
47549 wxPyEndAllowThreads(__tstate);
47550 if (PyErr_Occurred()) SWIG_fail;
47551 }
47552 resultobj = SWIG_From_int(static_cast< int >(result));
47553 return resultobj;
47554 fail:
47555 return NULL;
47556 }
47557
47558
47559 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47560 PyObject *resultobj = 0;
47561 wxControl *arg1 = (wxControl *) 0 ;
47562 wxString result;
47563 void *argp1 = 0 ;
47564 int res1 = 0 ;
47565 PyObject *swig_obj[1] ;
47566
47567 if (!args) SWIG_fail;
47568 swig_obj[0] = args;
47569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47570 if (!SWIG_IsOK(res1)) {
47571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47572 }
47573 arg1 = reinterpret_cast< wxControl * >(argp1);
47574 {
47575 PyThreadState* __tstate = wxPyBeginAllowThreads();
47576 result = ((wxControl const *)arg1)->GetLabelText();
47577 wxPyEndAllowThreads(__tstate);
47578 if (PyErr_Occurred()) SWIG_fail;
47579 }
47580 {
47581 #if wxUSE_UNICODE
47582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47583 #else
47584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47585 #endif
47586 }
47587 return resultobj;
47588 fail:
47589 return NULL;
47590 }
47591
47592
47593 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47594 PyObject *resultobj = 0;
47595 wxControl *arg1 = (wxControl *) 0 ;
47596 wxCommandEvent *arg2 = 0 ;
47597 void *argp1 = 0 ;
47598 int res1 = 0 ;
47599 void *argp2 = 0 ;
47600 int res2 = 0 ;
47601 PyObject * obj0 = 0 ;
47602 PyObject * obj1 = 0 ;
47603 char * kwnames[] = {
47604 (char *) "self",(char *) "event", NULL
47605 };
47606
47607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47609 if (!SWIG_IsOK(res1)) {
47610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47611 }
47612 arg1 = reinterpret_cast< wxControl * >(argp1);
47613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47614 if (!SWIG_IsOK(res2)) {
47615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47616 }
47617 if (!argp2) {
47618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47619 }
47620 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47621 {
47622 PyThreadState* __tstate = wxPyBeginAllowThreads();
47623 (arg1)->Command(*arg2);
47624 wxPyEndAllowThreads(__tstate);
47625 if (PyErr_Occurred()) SWIG_fail;
47626 }
47627 resultobj = SWIG_Py_Void();
47628 return resultobj;
47629 fail:
47630 return NULL;
47631 }
47632
47633
47634 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47635 PyObject *resultobj = 0;
47636 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47637 SwigValueWrapper<wxVisualAttributes > result;
47638 int val1 ;
47639 int ecode1 = 0 ;
47640 PyObject * obj0 = 0 ;
47641 char * kwnames[] = {
47642 (char *) "variant", NULL
47643 };
47644
47645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47646 if (obj0) {
47647 ecode1 = SWIG_AsVal_int(obj0, &val1);
47648 if (!SWIG_IsOK(ecode1)) {
47649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47650 }
47651 arg1 = static_cast< wxWindowVariant >(val1);
47652 }
47653 {
47654 if (!wxPyCheckForApp()) SWIG_fail;
47655 PyThreadState* __tstate = wxPyBeginAllowThreads();
47656 result = wxControl::GetClassDefaultAttributes(arg1);
47657 wxPyEndAllowThreads(__tstate);
47658 if (PyErr_Occurred()) SWIG_fail;
47659 }
47660 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47661 return resultobj;
47662 fail:
47663 return NULL;
47664 }
47665
47666
47667 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47668 PyObject *obj;
47669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47670 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47671 return SWIG_Py_Void();
47672 }
47673
47674 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47675 return SWIG_Python_InitShadowInstance(args);
47676 }
47677
47678 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47679 PyObject *resultobj = 0;
47680 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47681 wxString *arg2 = 0 ;
47682 PyObject *arg3 = (PyObject *) NULL ;
47683 int result;
47684 void *argp1 = 0 ;
47685 int res1 = 0 ;
47686 bool temp2 = false ;
47687 PyObject * obj0 = 0 ;
47688 PyObject * obj1 = 0 ;
47689 PyObject * obj2 = 0 ;
47690 char * kwnames[] = {
47691 (char *) "self",(char *) "item",(char *) "clientData", NULL
47692 };
47693
47694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47696 if (!SWIG_IsOK(res1)) {
47697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47698 }
47699 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47700 {
47701 arg2 = wxString_in_helper(obj1);
47702 if (arg2 == NULL) SWIG_fail;
47703 temp2 = true;
47704 }
47705 if (obj2) {
47706 arg3 = obj2;
47707 }
47708 {
47709 PyThreadState* __tstate = wxPyBeginAllowThreads();
47710 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47711 wxPyEndAllowThreads(__tstate);
47712 if (PyErr_Occurred()) SWIG_fail;
47713 }
47714 resultobj = SWIG_From_int(static_cast< int >(result));
47715 {
47716 if (temp2)
47717 delete arg2;
47718 }
47719 return resultobj;
47720 fail:
47721 {
47722 if (temp2)
47723 delete arg2;
47724 }
47725 return NULL;
47726 }
47727
47728
47729 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47730 PyObject *resultobj = 0;
47731 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47732 wxArrayString *arg2 = 0 ;
47733 void *argp1 = 0 ;
47734 int res1 = 0 ;
47735 bool temp2 = false ;
47736 PyObject * obj0 = 0 ;
47737 PyObject * obj1 = 0 ;
47738 char * kwnames[] = {
47739 (char *) "self",(char *) "strings", NULL
47740 };
47741
47742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47744 if (!SWIG_IsOK(res1)) {
47745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47746 }
47747 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47748 {
47749 if (! PySequence_Check(obj1)) {
47750 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47751 SWIG_fail;
47752 }
47753 arg2 = new wxArrayString;
47754 temp2 = true;
47755 int i, len=PySequence_Length(obj1);
47756 for (i=0; i<len; i++) {
47757 PyObject* item = PySequence_GetItem(obj1, i);
47758 wxString* s = wxString_in_helper(item);
47759 if (PyErr_Occurred()) SWIG_fail;
47760 arg2->Add(*s);
47761 delete s;
47762 Py_DECREF(item);
47763 }
47764 }
47765 {
47766 PyThreadState* __tstate = wxPyBeginAllowThreads();
47767 (arg1)->Append((wxArrayString const &)*arg2);
47768 wxPyEndAllowThreads(__tstate);
47769 if (PyErr_Occurred()) SWIG_fail;
47770 }
47771 resultobj = SWIG_Py_Void();
47772 {
47773 if (temp2) delete arg2;
47774 }
47775 return resultobj;
47776 fail:
47777 {
47778 if (temp2) delete arg2;
47779 }
47780 return NULL;
47781 }
47782
47783
47784 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47785 PyObject *resultobj = 0;
47786 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47787 wxString *arg2 = 0 ;
47788 int arg3 ;
47789 PyObject *arg4 = (PyObject *) NULL ;
47790 int result;
47791 void *argp1 = 0 ;
47792 int res1 = 0 ;
47793 bool temp2 = false ;
47794 int val3 ;
47795 int ecode3 = 0 ;
47796 PyObject * obj0 = 0 ;
47797 PyObject * obj1 = 0 ;
47798 PyObject * obj2 = 0 ;
47799 PyObject * obj3 = 0 ;
47800 char * kwnames[] = {
47801 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47802 };
47803
47804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47806 if (!SWIG_IsOK(res1)) {
47807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47808 }
47809 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47810 {
47811 arg2 = wxString_in_helper(obj1);
47812 if (arg2 == NULL) SWIG_fail;
47813 temp2 = true;
47814 }
47815 ecode3 = SWIG_AsVal_int(obj2, &val3);
47816 if (!SWIG_IsOK(ecode3)) {
47817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47818 }
47819 arg3 = static_cast< int >(val3);
47820 if (obj3) {
47821 arg4 = obj3;
47822 }
47823 {
47824 PyThreadState* __tstate = wxPyBeginAllowThreads();
47825 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47826 wxPyEndAllowThreads(__tstate);
47827 if (PyErr_Occurred()) SWIG_fail;
47828 }
47829 resultobj = SWIG_From_int(static_cast< int >(result));
47830 {
47831 if (temp2)
47832 delete arg2;
47833 }
47834 return resultobj;
47835 fail:
47836 {
47837 if (temp2)
47838 delete arg2;
47839 }
47840 return NULL;
47841 }
47842
47843
47844 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47845 PyObject *resultobj = 0;
47846 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47847 void *argp1 = 0 ;
47848 int res1 = 0 ;
47849 PyObject *swig_obj[1] ;
47850
47851 if (!args) SWIG_fail;
47852 swig_obj[0] = args;
47853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47854 if (!SWIG_IsOK(res1)) {
47855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47856 }
47857 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47858 {
47859 PyThreadState* __tstate = wxPyBeginAllowThreads();
47860 (arg1)->Clear();
47861 wxPyEndAllowThreads(__tstate);
47862 if (PyErr_Occurred()) SWIG_fail;
47863 }
47864 resultobj = SWIG_Py_Void();
47865 return resultobj;
47866 fail:
47867 return NULL;
47868 }
47869
47870
47871 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47872 PyObject *resultobj = 0;
47873 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47874 int arg2 ;
47875 void *argp1 = 0 ;
47876 int res1 = 0 ;
47877 int val2 ;
47878 int ecode2 = 0 ;
47879 PyObject * obj0 = 0 ;
47880 PyObject * obj1 = 0 ;
47881 char * kwnames[] = {
47882 (char *) "self",(char *) "n", NULL
47883 };
47884
47885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47887 if (!SWIG_IsOK(res1)) {
47888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47889 }
47890 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47891 ecode2 = SWIG_AsVal_int(obj1, &val2);
47892 if (!SWIG_IsOK(ecode2)) {
47893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
47894 }
47895 arg2 = static_cast< int >(val2);
47896 {
47897 PyThreadState* __tstate = wxPyBeginAllowThreads();
47898 (arg1)->Delete(arg2);
47899 wxPyEndAllowThreads(__tstate);
47900 if (PyErr_Occurred()) SWIG_fail;
47901 }
47902 resultobj = SWIG_Py_Void();
47903 return resultobj;
47904 fail:
47905 return NULL;
47906 }
47907
47908
47909 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47910 PyObject *resultobj = 0;
47911 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47912 int arg2 ;
47913 PyObject *result = 0 ;
47914 void *argp1 = 0 ;
47915 int res1 = 0 ;
47916 int val2 ;
47917 int ecode2 = 0 ;
47918 PyObject * obj0 = 0 ;
47919 PyObject * obj1 = 0 ;
47920 char * kwnames[] = {
47921 (char *) "self",(char *) "n", NULL
47922 };
47923
47924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47926 if (!SWIG_IsOK(res1)) {
47927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47928 }
47929 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47930 ecode2 = SWIG_AsVal_int(obj1, &val2);
47931 if (!SWIG_IsOK(ecode2)) {
47932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
47933 }
47934 arg2 = static_cast< int >(val2);
47935 {
47936 PyThreadState* __tstate = wxPyBeginAllowThreads();
47937 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47938 wxPyEndAllowThreads(__tstate);
47939 if (PyErr_Occurred()) SWIG_fail;
47940 }
47941 resultobj = result;
47942 return resultobj;
47943 fail:
47944 return NULL;
47945 }
47946
47947
47948 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47949 PyObject *resultobj = 0;
47950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47951 int arg2 ;
47952 PyObject *arg3 = (PyObject *) 0 ;
47953 void *argp1 = 0 ;
47954 int res1 = 0 ;
47955 int val2 ;
47956 int ecode2 = 0 ;
47957 PyObject * obj0 = 0 ;
47958 PyObject * obj1 = 0 ;
47959 PyObject * obj2 = 0 ;
47960 char * kwnames[] = {
47961 (char *) "self",(char *) "n",(char *) "clientData", NULL
47962 };
47963
47964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47966 if (!SWIG_IsOK(res1)) {
47967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47968 }
47969 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47970 ecode2 = SWIG_AsVal_int(obj1, &val2);
47971 if (!SWIG_IsOK(ecode2)) {
47972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
47973 }
47974 arg2 = static_cast< int >(val2);
47975 arg3 = obj2;
47976 {
47977 PyThreadState* __tstate = wxPyBeginAllowThreads();
47978 wxItemContainer_SetClientData(arg1,arg2,arg3);
47979 wxPyEndAllowThreads(__tstate);
47980 if (PyErr_Occurred()) SWIG_fail;
47981 }
47982 resultobj = SWIG_Py_Void();
47983 return resultobj;
47984 fail:
47985 return NULL;
47986 }
47987
47988
47989 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47990 PyObject *resultobj = 0;
47991 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47992 int result;
47993 void *argp1 = 0 ;
47994 int res1 = 0 ;
47995 PyObject *swig_obj[1] ;
47996
47997 if (!args) SWIG_fail;
47998 swig_obj[0] = args;
47999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48000 if (!SWIG_IsOK(res1)) {
48001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48002 }
48003 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48004 {
48005 PyThreadState* __tstate = wxPyBeginAllowThreads();
48006 result = (int)((wxItemContainer const *)arg1)->GetCount();
48007 wxPyEndAllowThreads(__tstate);
48008 if (PyErr_Occurred()) SWIG_fail;
48009 }
48010 resultobj = SWIG_From_int(static_cast< int >(result));
48011 return resultobj;
48012 fail:
48013 return NULL;
48014 }
48015
48016
48017 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48018 PyObject *resultobj = 0;
48019 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48020 bool result;
48021 void *argp1 = 0 ;
48022 int res1 = 0 ;
48023 PyObject *swig_obj[1] ;
48024
48025 if (!args) SWIG_fail;
48026 swig_obj[0] = args;
48027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48028 if (!SWIG_IsOK(res1)) {
48029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48030 }
48031 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48032 {
48033 PyThreadState* __tstate = wxPyBeginAllowThreads();
48034 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48035 wxPyEndAllowThreads(__tstate);
48036 if (PyErr_Occurred()) SWIG_fail;
48037 }
48038 {
48039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48040 }
48041 return resultobj;
48042 fail:
48043 return NULL;
48044 }
48045
48046
48047 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48048 PyObject *resultobj = 0;
48049 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48050 int arg2 ;
48051 wxString result;
48052 void *argp1 = 0 ;
48053 int res1 = 0 ;
48054 int val2 ;
48055 int ecode2 = 0 ;
48056 PyObject * obj0 = 0 ;
48057 PyObject * obj1 = 0 ;
48058 char * kwnames[] = {
48059 (char *) "self",(char *) "n", NULL
48060 };
48061
48062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48064 if (!SWIG_IsOK(res1)) {
48065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48066 }
48067 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48068 ecode2 = SWIG_AsVal_int(obj1, &val2);
48069 if (!SWIG_IsOK(ecode2)) {
48070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48071 }
48072 arg2 = static_cast< int >(val2);
48073 {
48074 PyThreadState* __tstate = wxPyBeginAllowThreads();
48075 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48076 wxPyEndAllowThreads(__tstate);
48077 if (PyErr_Occurred()) SWIG_fail;
48078 }
48079 {
48080 #if wxUSE_UNICODE
48081 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48082 #else
48083 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48084 #endif
48085 }
48086 return resultobj;
48087 fail:
48088 return NULL;
48089 }
48090
48091
48092 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48093 PyObject *resultobj = 0;
48094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48095 wxArrayString result;
48096 void *argp1 = 0 ;
48097 int res1 = 0 ;
48098 PyObject *swig_obj[1] ;
48099
48100 if (!args) SWIG_fail;
48101 swig_obj[0] = args;
48102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48103 if (!SWIG_IsOK(res1)) {
48104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48105 }
48106 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48107 {
48108 PyThreadState* __tstate = wxPyBeginAllowThreads();
48109 result = ((wxItemContainer const *)arg1)->GetStrings();
48110 wxPyEndAllowThreads(__tstate);
48111 if (PyErr_Occurred()) SWIG_fail;
48112 }
48113 {
48114 resultobj = wxArrayString2PyList_helper(result);
48115 }
48116 return resultobj;
48117 fail:
48118 return NULL;
48119 }
48120
48121
48122 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48123 PyObject *resultobj = 0;
48124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48125 int arg2 ;
48126 wxString *arg3 = 0 ;
48127 void *argp1 = 0 ;
48128 int res1 = 0 ;
48129 int val2 ;
48130 int ecode2 = 0 ;
48131 bool temp3 = false ;
48132 PyObject * obj0 = 0 ;
48133 PyObject * obj1 = 0 ;
48134 PyObject * obj2 = 0 ;
48135 char * kwnames[] = {
48136 (char *) "self",(char *) "n",(char *) "s", NULL
48137 };
48138
48139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48141 if (!SWIG_IsOK(res1)) {
48142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48143 }
48144 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48145 ecode2 = SWIG_AsVal_int(obj1, &val2);
48146 if (!SWIG_IsOK(ecode2)) {
48147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48148 }
48149 arg2 = static_cast< int >(val2);
48150 {
48151 arg3 = wxString_in_helper(obj2);
48152 if (arg3 == NULL) SWIG_fail;
48153 temp3 = true;
48154 }
48155 {
48156 PyThreadState* __tstate = wxPyBeginAllowThreads();
48157 (arg1)->SetString(arg2,(wxString const &)*arg3);
48158 wxPyEndAllowThreads(__tstate);
48159 if (PyErr_Occurred()) SWIG_fail;
48160 }
48161 resultobj = SWIG_Py_Void();
48162 {
48163 if (temp3)
48164 delete arg3;
48165 }
48166 return resultobj;
48167 fail:
48168 {
48169 if (temp3)
48170 delete arg3;
48171 }
48172 return NULL;
48173 }
48174
48175
48176 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48177 PyObject *resultobj = 0;
48178 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48179 wxString *arg2 = 0 ;
48180 int result;
48181 void *argp1 = 0 ;
48182 int res1 = 0 ;
48183 bool temp2 = false ;
48184 PyObject * obj0 = 0 ;
48185 PyObject * obj1 = 0 ;
48186 char * kwnames[] = {
48187 (char *) "self",(char *) "s", NULL
48188 };
48189
48190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48192 if (!SWIG_IsOK(res1)) {
48193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48194 }
48195 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48196 {
48197 arg2 = wxString_in_helper(obj1);
48198 if (arg2 == NULL) SWIG_fail;
48199 temp2 = true;
48200 }
48201 {
48202 PyThreadState* __tstate = wxPyBeginAllowThreads();
48203 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48204 wxPyEndAllowThreads(__tstate);
48205 if (PyErr_Occurred()) SWIG_fail;
48206 }
48207 resultobj = SWIG_From_int(static_cast< int >(result));
48208 {
48209 if (temp2)
48210 delete arg2;
48211 }
48212 return resultobj;
48213 fail:
48214 {
48215 if (temp2)
48216 delete arg2;
48217 }
48218 return NULL;
48219 }
48220
48221
48222 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48223 PyObject *resultobj = 0;
48224 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48225 int arg2 ;
48226 void *argp1 = 0 ;
48227 int res1 = 0 ;
48228 int val2 ;
48229 int ecode2 = 0 ;
48230 PyObject * obj0 = 0 ;
48231 PyObject * obj1 = 0 ;
48232 char * kwnames[] = {
48233 (char *) "self",(char *) "n", NULL
48234 };
48235
48236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48240 }
48241 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48242 ecode2 = SWIG_AsVal_int(obj1, &val2);
48243 if (!SWIG_IsOK(ecode2)) {
48244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48245 }
48246 arg2 = static_cast< int >(val2);
48247 {
48248 PyThreadState* __tstate = wxPyBeginAllowThreads();
48249 (arg1)->SetSelection(arg2);
48250 wxPyEndAllowThreads(__tstate);
48251 if (PyErr_Occurred()) SWIG_fail;
48252 }
48253 resultobj = SWIG_Py_Void();
48254 return resultobj;
48255 fail:
48256 return NULL;
48257 }
48258
48259
48260 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48261 PyObject *resultobj = 0;
48262 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48263 int result;
48264 void *argp1 = 0 ;
48265 int res1 = 0 ;
48266 PyObject *swig_obj[1] ;
48267
48268 if (!args) SWIG_fail;
48269 swig_obj[0] = args;
48270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48271 if (!SWIG_IsOK(res1)) {
48272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48273 }
48274 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48275 {
48276 PyThreadState* __tstate = wxPyBeginAllowThreads();
48277 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48278 wxPyEndAllowThreads(__tstate);
48279 if (PyErr_Occurred()) SWIG_fail;
48280 }
48281 resultobj = SWIG_From_int(static_cast< int >(result));
48282 return resultobj;
48283 fail:
48284 return NULL;
48285 }
48286
48287
48288 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48289 PyObject *resultobj = 0;
48290 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48291 wxString *arg2 = 0 ;
48292 bool result;
48293 void *argp1 = 0 ;
48294 int res1 = 0 ;
48295 bool temp2 = false ;
48296 PyObject * obj0 = 0 ;
48297 PyObject * obj1 = 0 ;
48298 char * kwnames[] = {
48299 (char *) "self",(char *) "s", NULL
48300 };
48301
48302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48304 if (!SWIG_IsOK(res1)) {
48305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48306 }
48307 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48308 {
48309 arg2 = wxString_in_helper(obj1);
48310 if (arg2 == NULL) SWIG_fail;
48311 temp2 = true;
48312 }
48313 {
48314 PyThreadState* __tstate = wxPyBeginAllowThreads();
48315 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48316 wxPyEndAllowThreads(__tstate);
48317 if (PyErr_Occurred()) SWIG_fail;
48318 }
48319 {
48320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48321 }
48322 {
48323 if (temp2)
48324 delete arg2;
48325 }
48326 return resultobj;
48327 fail:
48328 {
48329 if (temp2)
48330 delete arg2;
48331 }
48332 return NULL;
48333 }
48334
48335
48336 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48337 PyObject *resultobj = 0;
48338 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48339 wxString result;
48340 void *argp1 = 0 ;
48341 int res1 = 0 ;
48342 PyObject *swig_obj[1] ;
48343
48344 if (!args) SWIG_fail;
48345 swig_obj[0] = args;
48346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48347 if (!SWIG_IsOK(res1)) {
48348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48349 }
48350 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48351 {
48352 PyThreadState* __tstate = wxPyBeginAllowThreads();
48353 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48354 wxPyEndAllowThreads(__tstate);
48355 if (PyErr_Occurred()) SWIG_fail;
48356 }
48357 {
48358 #if wxUSE_UNICODE
48359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48360 #else
48361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48362 #endif
48363 }
48364 return resultobj;
48365 fail:
48366 return NULL;
48367 }
48368
48369
48370 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48371 PyObject *resultobj = 0;
48372 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48373 int arg2 ;
48374 void *argp1 = 0 ;
48375 int res1 = 0 ;
48376 int val2 ;
48377 int ecode2 = 0 ;
48378 PyObject * obj0 = 0 ;
48379 PyObject * obj1 = 0 ;
48380 char * kwnames[] = {
48381 (char *) "self",(char *) "n", NULL
48382 };
48383
48384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48386 if (!SWIG_IsOK(res1)) {
48387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48388 }
48389 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48390 ecode2 = SWIG_AsVal_int(obj1, &val2);
48391 if (!SWIG_IsOK(ecode2)) {
48392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48393 }
48394 arg2 = static_cast< int >(val2);
48395 {
48396 PyThreadState* __tstate = wxPyBeginAllowThreads();
48397 (arg1)->Select(arg2);
48398 wxPyEndAllowThreads(__tstate);
48399 if (PyErr_Occurred()) SWIG_fail;
48400 }
48401 resultobj = SWIG_Py_Void();
48402 return resultobj;
48403 fail:
48404 return NULL;
48405 }
48406
48407
48408 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48409 PyObject *obj;
48410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48411 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48412 return SWIG_Py_Void();
48413 }
48414
48415 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48416 PyObject *obj;
48417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48418 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48419 return SWIG_Py_Void();
48420 }
48421
48422 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48423 PyObject *resultobj = 0;
48424 wxSizerItem *result = 0 ;
48425
48426 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48427 {
48428 PyThreadState* __tstate = wxPyBeginAllowThreads();
48429 result = (wxSizerItem *)new wxSizerItem();
48430 wxPyEndAllowThreads(__tstate);
48431 if (PyErr_Occurred()) SWIG_fail;
48432 }
48433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48434 return resultobj;
48435 fail:
48436 return NULL;
48437 }
48438
48439
48440 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48441 PyObject *resultobj = 0;
48442 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48443 void *argp1 = 0 ;
48444 int res1 = 0 ;
48445 PyObject *swig_obj[1] ;
48446
48447 if (!args) SWIG_fail;
48448 swig_obj[0] = args;
48449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48450 if (!SWIG_IsOK(res1)) {
48451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48452 }
48453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48454 {
48455 PyThreadState* __tstate = wxPyBeginAllowThreads();
48456 delete arg1;
48457
48458 wxPyEndAllowThreads(__tstate);
48459 if (PyErr_Occurred()) SWIG_fail;
48460 }
48461 resultobj = SWIG_Py_Void();
48462 return resultobj;
48463 fail:
48464 return NULL;
48465 }
48466
48467
48468 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48469 PyObject *resultobj = 0;
48470 wxWindow *arg1 = (wxWindow *) 0 ;
48471 int arg2 ;
48472 int arg3 ;
48473 int arg4 ;
48474 PyObject *arg5 = (PyObject *) NULL ;
48475 wxSizerItem *result = 0 ;
48476 void *argp1 = 0 ;
48477 int res1 = 0 ;
48478 int val2 ;
48479 int ecode2 = 0 ;
48480 int val3 ;
48481 int ecode3 = 0 ;
48482 int val4 ;
48483 int ecode4 = 0 ;
48484 PyObject * obj0 = 0 ;
48485 PyObject * obj1 = 0 ;
48486 PyObject * obj2 = 0 ;
48487 PyObject * obj3 = 0 ;
48488 PyObject * obj4 = 0 ;
48489 char * kwnames[] = {
48490 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48491 };
48492
48493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48495 if (!SWIG_IsOK(res1)) {
48496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48497 }
48498 arg1 = reinterpret_cast< wxWindow * >(argp1);
48499 ecode2 = SWIG_AsVal_int(obj1, &val2);
48500 if (!SWIG_IsOK(ecode2)) {
48501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48502 }
48503 arg2 = static_cast< int >(val2);
48504 ecode3 = SWIG_AsVal_int(obj2, &val3);
48505 if (!SWIG_IsOK(ecode3)) {
48506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48507 }
48508 arg3 = static_cast< int >(val3);
48509 ecode4 = SWIG_AsVal_int(obj3, &val4);
48510 if (!SWIG_IsOK(ecode4)) {
48511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48512 }
48513 arg4 = static_cast< int >(val4);
48514 if (obj4) {
48515 arg5 = obj4;
48516 }
48517 {
48518 PyThreadState* __tstate = wxPyBeginAllowThreads();
48519 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48520 wxPyEndAllowThreads(__tstate);
48521 if (PyErr_Occurred()) SWIG_fail;
48522 }
48523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48524 return resultobj;
48525 fail:
48526 return NULL;
48527 }
48528
48529
48530 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48531 PyObject *resultobj = 0;
48532 int arg1 ;
48533 int arg2 ;
48534 int arg3 ;
48535 int arg4 ;
48536 int arg5 ;
48537 PyObject *arg6 = (PyObject *) NULL ;
48538 wxSizerItem *result = 0 ;
48539 int val1 ;
48540 int ecode1 = 0 ;
48541 int val2 ;
48542 int ecode2 = 0 ;
48543 int val3 ;
48544 int ecode3 = 0 ;
48545 int val4 ;
48546 int ecode4 = 0 ;
48547 int val5 ;
48548 int ecode5 = 0 ;
48549 PyObject * obj0 = 0 ;
48550 PyObject * obj1 = 0 ;
48551 PyObject * obj2 = 0 ;
48552 PyObject * obj3 = 0 ;
48553 PyObject * obj4 = 0 ;
48554 PyObject * obj5 = 0 ;
48555 char * kwnames[] = {
48556 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48557 };
48558
48559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48560 ecode1 = SWIG_AsVal_int(obj0, &val1);
48561 if (!SWIG_IsOK(ecode1)) {
48562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48563 }
48564 arg1 = static_cast< int >(val1);
48565 ecode2 = SWIG_AsVal_int(obj1, &val2);
48566 if (!SWIG_IsOK(ecode2)) {
48567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48568 }
48569 arg2 = static_cast< int >(val2);
48570 ecode3 = SWIG_AsVal_int(obj2, &val3);
48571 if (!SWIG_IsOK(ecode3)) {
48572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48573 }
48574 arg3 = static_cast< int >(val3);
48575 ecode4 = SWIG_AsVal_int(obj3, &val4);
48576 if (!SWIG_IsOK(ecode4)) {
48577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48578 }
48579 arg4 = static_cast< int >(val4);
48580 ecode5 = SWIG_AsVal_int(obj4, &val5);
48581 if (!SWIG_IsOK(ecode5)) {
48582 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48583 }
48584 arg5 = static_cast< int >(val5);
48585 if (obj5) {
48586 arg6 = obj5;
48587 }
48588 {
48589 PyThreadState* __tstate = wxPyBeginAllowThreads();
48590 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48591 wxPyEndAllowThreads(__tstate);
48592 if (PyErr_Occurred()) SWIG_fail;
48593 }
48594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48595 return resultobj;
48596 fail:
48597 return NULL;
48598 }
48599
48600
48601 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48602 PyObject *resultobj = 0;
48603 wxSizer *arg1 = (wxSizer *) 0 ;
48604 int arg2 ;
48605 int arg3 ;
48606 int arg4 ;
48607 PyObject *arg5 = (PyObject *) NULL ;
48608 wxSizerItem *result = 0 ;
48609 int res1 = 0 ;
48610 int val2 ;
48611 int ecode2 = 0 ;
48612 int val3 ;
48613 int ecode3 = 0 ;
48614 int val4 ;
48615 int ecode4 = 0 ;
48616 PyObject * obj0 = 0 ;
48617 PyObject * obj1 = 0 ;
48618 PyObject * obj2 = 0 ;
48619 PyObject * obj3 = 0 ;
48620 PyObject * obj4 = 0 ;
48621 char * kwnames[] = {
48622 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48623 };
48624
48625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48626 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48627 if (!SWIG_IsOK(res1)) {
48628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48629 }
48630 ecode2 = SWIG_AsVal_int(obj1, &val2);
48631 if (!SWIG_IsOK(ecode2)) {
48632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48633 }
48634 arg2 = static_cast< int >(val2);
48635 ecode3 = SWIG_AsVal_int(obj2, &val3);
48636 if (!SWIG_IsOK(ecode3)) {
48637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48638 }
48639 arg3 = static_cast< int >(val3);
48640 ecode4 = SWIG_AsVal_int(obj3, &val4);
48641 if (!SWIG_IsOK(ecode4)) {
48642 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48643 }
48644 arg4 = static_cast< int >(val4);
48645 if (obj4) {
48646 arg5 = obj4;
48647 }
48648 {
48649 PyThreadState* __tstate = wxPyBeginAllowThreads();
48650 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48651 wxPyEndAllowThreads(__tstate);
48652 if (PyErr_Occurred()) SWIG_fail;
48653 }
48654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48655 return resultobj;
48656 fail:
48657 return NULL;
48658 }
48659
48660
48661 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48662 PyObject *resultobj = 0;
48663 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48664 void *argp1 = 0 ;
48665 int res1 = 0 ;
48666 PyObject *swig_obj[1] ;
48667
48668 if (!args) SWIG_fail;
48669 swig_obj[0] = args;
48670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48673 }
48674 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48675 {
48676 PyThreadState* __tstate = wxPyBeginAllowThreads();
48677 (arg1)->DeleteWindows();
48678 wxPyEndAllowThreads(__tstate);
48679 if (PyErr_Occurred()) SWIG_fail;
48680 }
48681 resultobj = SWIG_Py_Void();
48682 return resultobj;
48683 fail:
48684 return NULL;
48685 }
48686
48687
48688 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48689 PyObject *resultobj = 0;
48690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48691 void *argp1 = 0 ;
48692 int res1 = 0 ;
48693 PyObject *swig_obj[1] ;
48694
48695 if (!args) SWIG_fail;
48696 swig_obj[0] = args;
48697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48698 if (!SWIG_IsOK(res1)) {
48699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48700 }
48701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48702 {
48703 PyThreadState* __tstate = wxPyBeginAllowThreads();
48704 (arg1)->DetachSizer();
48705 wxPyEndAllowThreads(__tstate);
48706 if (PyErr_Occurred()) SWIG_fail;
48707 }
48708 resultobj = SWIG_Py_Void();
48709 return resultobj;
48710 fail:
48711 return NULL;
48712 }
48713
48714
48715 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48716 PyObject *resultobj = 0;
48717 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48718 wxSize result;
48719 void *argp1 = 0 ;
48720 int res1 = 0 ;
48721 PyObject *swig_obj[1] ;
48722
48723 if (!args) SWIG_fail;
48724 swig_obj[0] = args;
48725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48726 if (!SWIG_IsOK(res1)) {
48727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48728 }
48729 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48730 {
48731 PyThreadState* __tstate = wxPyBeginAllowThreads();
48732 result = (arg1)->GetSize();
48733 wxPyEndAllowThreads(__tstate);
48734 if (PyErr_Occurred()) SWIG_fail;
48735 }
48736 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48737 return resultobj;
48738 fail:
48739 return NULL;
48740 }
48741
48742
48743 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48744 PyObject *resultobj = 0;
48745 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48746 wxSize result;
48747 void *argp1 = 0 ;
48748 int res1 = 0 ;
48749 PyObject *swig_obj[1] ;
48750
48751 if (!args) SWIG_fail;
48752 swig_obj[0] = args;
48753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48754 if (!SWIG_IsOK(res1)) {
48755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48756 }
48757 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48758 {
48759 PyThreadState* __tstate = wxPyBeginAllowThreads();
48760 result = (arg1)->CalcMin();
48761 wxPyEndAllowThreads(__tstate);
48762 if (PyErr_Occurred()) SWIG_fail;
48763 }
48764 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48765 return resultobj;
48766 fail:
48767 return NULL;
48768 }
48769
48770
48771 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48772 PyObject *resultobj = 0;
48773 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48774 wxPoint *arg2 = 0 ;
48775 wxSize *arg3 = 0 ;
48776 void *argp1 = 0 ;
48777 int res1 = 0 ;
48778 wxPoint temp2 ;
48779 wxSize temp3 ;
48780 PyObject * obj0 = 0 ;
48781 PyObject * obj1 = 0 ;
48782 PyObject * obj2 = 0 ;
48783 char * kwnames[] = {
48784 (char *) "self",(char *) "pos",(char *) "size", NULL
48785 };
48786
48787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48789 if (!SWIG_IsOK(res1)) {
48790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48791 }
48792 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48793 {
48794 arg2 = &temp2;
48795 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48796 }
48797 {
48798 arg3 = &temp3;
48799 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48800 }
48801 {
48802 PyThreadState* __tstate = wxPyBeginAllowThreads();
48803 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48804 wxPyEndAllowThreads(__tstate);
48805 if (PyErr_Occurred()) SWIG_fail;
48806 }
48807 resultobj = SWIG_Py_Void();
48808 return resultobj;
48809 fail:
48810 return NULL;
48811 }
48812
48813
48814 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48815 PyObject *resultobj = 0;
48816 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48817 wxSize result;
48818 void *argp1 = 0 ;
48819 int res1 = 0 ;
48820 PyObject *swig_obj[1] ;
48821
48822 if (!args) SWIG_fail;
48823 swig_obj[0] = args;
48824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48825 if (!SWIG_IsOK(res1)) {
48826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48827 }
48828 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48829 {
48830 PyThreadState* __tstate = wxPyBeginAllowThreads();
48831 result = (arg1)->GetMinSize();
48832 wxPyEndAllowThreads(__tstate);
48833 if (PyErr_Occurred()) SWIG_fail;
48834 }
48835 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48836 return resultobj;
48837 fail:
48838 return NULL;
48839 }
48840
48841
48842 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48843 PyObject *resultobj = 0;
48844 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48845 wxSize result;
48846 void *argp1 = 0 ;
48847 int res1 = 0 ;
48848 PyObject *swig_obj[1] ;
48849
48850 if (!args) SWIG_fail;
48851 swig_obj[0] = args;
48852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48853 if (!SWIG_IsOK(res1)) {
48854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48855 }
48856 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48857 {
48858 PyThreadState* __tstate = wxPyBeginAllowThreads();
48859 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48860 wxPyEndAllowThreads(__tstate);
48861 if (PyErr_Occurred()) SWIG_fail;
48862 }
48863 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48864 return resultobj;
48865 fail:
48866 return NULL;
48867 }
48868
48869
48870 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48871 PyObject *resultobj = 0;
48872 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48873 int arg2 ;
48874 int arg3 ;
48875 void *argp1 = 0 ;
48876 int res1 = 0 ;
48877 int val2 ;
48878 int ecode2 = 0 ;
48879 int val3 ;
48880 int ecode3 = 0 ;
48881 PyObject * obj0 = 0 ;
48882 PyObject * obj1 = 0 ;
48883 PyObject * obj2 = 0 ;
48884 char * kwnames[] = {
48885 (char *) "self",(char *) "x",(char *) "y", NULL
48886 };
48887
48888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48890 if (!SWIG_IsOK(res1)) {
48891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48892 }
48893 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48894 ecode2 = SWIG_AsVal_int(obj1, &val2);
48895 if (!SWIG_IsOK(ecode2)) {
48896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48897 }
48898 arg2 = static_cast< int >(val2);
48899 ecode3 = SWIG_AsVal_int(obj2, &val3);
48900 if (!SWIG_IsOK(ecode3)) {
48901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48902 }
48903 arg3 = static_cast< int >(val3);
48904 {
48905 PyThreadState* __tstate = wxPyBeginAllowThreads();
48906 (arg1)->SetInitSize(arg2,arg3);
48907 wxPyEndAllowThreads(__tstate);
48908 if (PyErr_Occurred()) SWIG_fail;
48909 }
48910 resultobj = SWIG_Py_Void();
48911 return resultobj;
48912 fail:
48913 return NULL;
48914 }
48915
48916
48917 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48918 PyObject *resultobj = 0;
48919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48920 int arg2 ;
48921 int arg3 ;
48922 void *argp1 = 0 ;
48923 int res1 = 0 ;
48924 int val2 ;
48925 int ecode2 = 0 ;
48926 int val3 ;
48927 int ecode3 = 0 ;
48928 PyObject * obj0 = 0 ;
48929 PyObject * obj1 = 0 ;
48930 PyObject * obj2 = 0 ;
48931 char * kwnames[] = {
48932 (char *) "self",(char *) "width",(char *) "height", NULL
48933 };
48934
48935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48937 if (!SWIG_IsOK(res1)) {
48938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48939 }
48940 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48941 ecode2 = SWIG_AsVal_int(obj1, &val2);
48942 if (!SWIG_IsOK(ecode2)) {
48943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48944 }
48945 arg2 = static_cast< int >(val2);
48946 ecode3 = SWIG_AsVal_int(obj2, &val3);
48947 if (!SWIG_IsOK(ecode3)) {
48948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48949 }
48950 arg3 = static_cast< int >(val3);
48951 {
48952 PyThreadState* __tstate = wxPyBeginAllowThreads();
48953 (arg1)->SetRatio(arg2,arg3);
48954 wxPyEndAllowThreads(__tstate);
48955 if (PyErr_Occurred()) SWIG_fail;
48956 }
48957 resultobj = SWIG_Py_Void();
48958 return resultobj;
48959 fail:
48960 return NULL;
48961 }
48962
48963
48964 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48965 PyObject *resultobj = 0;
48966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48967 wxSize *arg2 = 0 ;
48968 void *argp1 = 0 ;
48969 int res1 = 0 ;
48970 wxSize temp2 ;
48971 PyObject * obj0 = 0 ;
48972 PyObject * obj1 = 0 ;
48973 char * kwnames[] = {
48974 (char *) "self",(char *) "size", NULL
48975 };
48976
48977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48979 if (!SWIG_IsOK(res1)) {
48980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48981 }
48982 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48983 {
48984 arg2 = &temp2;
48985 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48986 }
48987 {
48988 PyThreadState* __tstate = wxPyBeginAllowThreads();
48989 (arg1)->SetRatio((wxSize const &)*arg2);
48990 wxPyEndAllowThreads(__tstate);
48991 if (PyErr_Occurred()) SWIG_fail;
48992 }
48993 resultobj = SWIG_Py_Void();
48994 return resultobj;
48995 fail:
48996 return NULL;
48997 }
48998
48999
49000 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49001 PyObject *resultobj = 0;
49002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49003 float arg2 ;
49004 void *argp1 = 0 ;
49005 int res1 = 0 ;
49006 float val2 ;
49007 int ecode2 = 0 ;
49008 PyObject * obj0 = 0 ;
49009 PyObject * obj1 = 0 ;
49010 char * kwnames[] = {
49011 (char *) "self",(char *) "ratio", NULL
49012 };
49013
49014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49016 if (!SWIG_IsOK(res1)) {
49017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49018 }
49019 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49020 ecode2 = SWIG_AsVal_float(obj1, &val2);
49021 if (!SWIG_IsOK(ecode2)) {
49022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49023 }
49024 arg2 = static_cast< float >(val2);
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 (arg1)->SetRatio(arg2);
49028 wxPyEndAllowThreads(__tstate);
49029 if (PyErr_Occurred()) SWIG_fail;
49030 }
49031 resultobj = SWIG_Py_Void();
49032 return resultobj;
49033 fail:
49034 return NULL;
49035 }
49036
49037
49038 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49039 PyObject *resultobj = 0;
49040 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49041 float result;
49042 void *argp1 = 0 ;
49043 int res1 = 0 ;
49044 PyObject *swig_obj[1] ;
49045
49046 if (!args) SWIG_fail;
49047 swig_obj[0] = args;
49048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49049 if (!SWIG_IsOK(res1)) {
49050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49051 }
49052 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49053 {
49054 PyThreadState* __tstate = wxPyBeginAllowThreads();
49055 result = (float)(arg1)->GetRatio();
49056 wxPyEndAllowThreads(__tstate);
49057 if (PyErr_Occurred()) SWIG_fail;
49058 }
49059 resultobj = SWIG_From_float(static_cast< float >(result));
49060 return resultobj;
49061 fail:
49062 return NULL;
49063 }
49064
49065
49066 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49067 PyObject *resultobj = 0;
49068 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49069 wxRect result;
49070 void *argp1 = 0 ;
49071 int res1 = 0 ;
49072 PyObject *swig_obj[1] ;
49073
49074 if (!args) SWIG_fail;
49075 swig_obj[0] = args;
49076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49077 if (!SWIG_IsOK(res1)) {
49078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49079 }
49080 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49081 {
49082 PyThreadState* __tstate = wxPyBeginAllowThreads();
49083 result = (arg1)->GetRect();
49084 wxPyEndAllowThreads(__tstate);
49085 if (PyErr_Occurred()) SWIG_fail;
49086 }
49087 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49088 return resultobj;
49089 fail:
49090 return NULL;
49091 }
49092
49093
49094 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49095 PyObject *resultobj = 0;
49096 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49097 bool result;
49098 void *argp1 = 0 ;
49099 int res1 = 0 ;
49100 PyObject *swig_obj[1] ;
49101
49102 if (!args) SWIG_fail;
49103 swig_obj[0] = args;
49104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49105 if (!SWIG_IsOK(res1)) {
49106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49107 }
49108 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49109 {
49110 PyThreadState* __tstate = wxPyBeginAllowThreads();
49111 result = (bool)(arg1)->IsWindow();
49112 wxPyEndAllowThreads(__tstate);
49113 if (PyErr_Occurred()) SWIG_fail;
49114 }
49115 {
49116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49117 }
49118 return resultobj;
49119 fail:
49120 return NULL;
49121 }
49122
49123
49124 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49125 PyObject *resultobj = 0;
49126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49127 bool result;
49128 void *argp1 = 0 ;
49129 int res1 = 0 ;
49130 PyObject *swig_obj[1] ;
49131
49132 if (!args) SWIG_fail;
49133 swig_obj[0] = args;
49134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49135 if (!SWIG_IsOK(res1)) {
49136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49137 }
49138 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49139 {
49140 PyThreadState* __tstate = wxPyBeginAllowThreads();
49141 result = (bool)(arg1)->IsSizer();
49142 wxPyEndAllowThreads(__tstate);
49143 if (PyErr_Occurred()) SWIG_fail;
49144 }
49145 {
49146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49147 }
49148 return resultobj;
49149 fail:
49150 return NULL;
49151 }
49152
49153
49154 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49155 PyObject *resultobj = 0;
49156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49157 bool result;
49158 void *argp1 = 0 ;
49159 int res1 = 0 ;
49160 PyObject *swig_obj[1] ;
49161
49162 if (!args) SWIG_fail;
49163 swig_obj[0] = args;
49164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49165 if (!SWIG_IsOK(res1)) {
49166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49167 }
49168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49169 {
49170 PyThreadState* __tstate = wxPyBeginAllowThreads();
49171 result = (bool)(arg1)->IsSpacer();
49172 wxPyEndAllowThreads(__tstate);
49173 if (PyErr_Occurred()) SWIG_fail;
49174 }
49175 {
49176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49177 }
49178 return resultobj;
49179 fail:
49180 return NULL;
49181 }
49182
49183
49184 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49185 PyObject *resultobj = 0;
49186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49187 int arg2 ;
49188 void *argp1 = 0 ;
49189 int res1 = 0 ;
49190 int val2 ;
49191 int ecode2 = 0 ;
49192 PyObject * obj0 = 0 ;
49193 PyObject * obj1 = 0 ;
49194 char * kwnames[] = {
49195 (char *) "self",(char *) "proportion", NULL
49196 };
49197
49198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49200 if (!SWIG_IsOK(res1)) {
49201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49202 }
49203 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49204 ecode2 = SWIG_AsVal_int(obj1, &val2);
49205 if (!SWIG_IsOK(ecode2)) {
49206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49207 }
49208 arg2 = static_cast< int >(val2);
49209 {
49210 PyThreadState* __tstate = wxPyBeginAllowThreads();
49211 (arg1)->SetProportion(arg2);
49212 wxPyEndAllowThreads(__tstate);
49213 if (PyErr_Occurred()) SWIG_fail;
49214 }
49215 resultobj = SWIG_Py_Void();
49216 return resultobj;
49217 fail:
49218 return NULL;
49219 }
49220
49221
49222 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49223 PyObject *resultobj = 0;
49224 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49225 int 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_wxSizerItem, 0 | 0 );
49233 if (!SWIG_IsOK(res1)) {
49234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49235 }
49236 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49237 {
49238 PyThreadState* __tstate = wxPyBeginAllowThreads();
49239 result = (int)(arg1)->GetProportion();
49240 wxPyEndAllowThreads(__tstate);
49241 if (PyErr_Occurred()) SWIG_fail;
49242 }
49243 resultobj = SWIG_From_int(static_cast< int >(result));
49244 return resultobj;
49245 fail:
49246 return NULL;
49247 }
49248
49249
49250 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49251 PyObject *resultobj = 0;
49252 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49253 int arg2 ;
49254 void *argp1 = 0 ;
49255 int res1 = 0 ;
49256 int val2 ;
49257 int ecode2 = 0 ;
49258 PyObject * obj0 = 0 ;
49259 PyObject * obj1 = 0 ;
49260 char * kwnames[] = {
49261 (char *) "self",(char *) "flag", NULL
49262 };
49263
49264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49266 if (!SWIG_IsOK(res1)) {
49267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49268 }
49269 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49270 ecode2 = SWIG_AsVal_int(obj1, &val2);
49271 if (!SWIG_IsOK(ecode2)) {
49272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49273 }
49274 arg2 = static_cast< int >(val2);
49275 {
49276 PyThreadState* __tstate = wxPyBeginAllowThreads();
49277 (arg1)->SetFlag(arg2);
49278 wxPyEndAllowThreads(__tstate);
49279 if (PyErr_Occurred()) SWIG_fail;
49280 }
49281 resultobj = SWIG_Py_Void();
49282 return resultobj;
49283 fail:
49284 return NULL;
49285 }
49286
49287
49288 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49289 PyObject *resultobj = 0;
49290 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49291 int result;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 PyObject *swig_obj[1] ;
49295
49296 if (!args) SWIG_fail;
49297 swig_obj[0] = args;
49298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49299 if (!SWIG_IsOK(res1)) {
49300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49301 }
49302 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49303 {
49304 PyThreadState* __tstate = wxPyBeginAllowThreads();
49305 result = (int)(arg1)->GetFlag();
49306 wxPyEndAllowThreads(__tstate);
49307 if (PyErr_Occurred()) SWIG_fail;
49308 }
49309 resultobj = SWIG_From_int(static_cast< int >(result));
49310 return resultobj;
49311 fail:
49312 return NULL;
49313 }
49314
49315
49316 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49317 PyObject *resultobj = 0;
49318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49319 int arg2 ;
49320 void *argp1 = 0 ;
49321 int res1 = 0 ;
49322 int val2 ;
49323 int ecode2 = 0 ;
49324 PyObject * obj0 = 0 ;
49325 PyObject * obj1 = 0 ;
49326 char * kwnames[] = {
49327 (char *) "self",(char *) "border", NULL
49328 };
49329
49330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49332 if (!SWIG_IsOK(res1)) {
49333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49334 }
49335 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49336 ecode2 = SWIG_AsVal_int(obj1, &val2);
49337 if (!SWIG_IsOK(ecode2)) {
49338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49339 }
49340 arg2 = static_cast< int >(val2);
49341 {
49342 PyThreadState* __tstate = wxPyBeginAllowThreads();
49343 (arg1)->SetBorder(arg2);
49344 wxPyEndAllowThreads(__tstate);
49345 if (PyErr_Occurred()) SWIG_fail;
49346 }
49347 resultobj = SWIG_Py_Void();
49348 return resultobj;
49349 fail:
49350 return NULL;
49351 }
49352
49353
49354 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49355 PyObject *resultobj = 0;
49356 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49357 int result;
49358 void *argp1 = 0 ;
49359 int res1 = 0 ;
49360 PyObject *swig_obj[1] ;
49361
49362 if (!args) SWIG_fail;
49363 swig_obj[0] = args;
49364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49365 if (!SWIG_IsOK(res1)) {
49366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49367 }
49368 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49369 {
49370 PyThreadState* __tstate = wxPyBeginAllowThreads();
49371 result = (int)(arg1)->GetBorder();
49372 wxPyEndAllowThreads(__tstate);
49373 if (PyErr_Occurred()) SWIG_fail;
49374 }
49375 resultobj = SWIG_From_int(static_cast< int >(result));
49376 return resultobj;
49377 fail:
49378 return NULL;
49379 }
49380
49381
49382 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49383 PyObject *resultobj = 0;
49384 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49385 wxWindow *result = 0 ;
49386 void *argp1 = 0 ;
49387 int res1 = 0 ;
49388 PyObject *swig_obj[1] ;
49389
49390 if (!args) SWIG_fail;
49391 swig_obj[0] = args;
49392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49393 if (!SWIG_IsOK(res1)) {
49394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49395 }
49396 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49397 {
49398 PyThreadState* __tstate = wxPyBeginAllowThreads();
49399 result = (wxWindow *)(arg1)->GetWindow();
49400 wxPyEndAllowThreads(__tstate);
49401 if (PyErr_Occurred()) SWIG_fail;
49402 }
49403 {
49404 resultobj = wxPyMake_wxObject(result, 0);
49405 }
49406 return resultobj;
49407 fail:
49408 return NULL;
49409 }
49410
49411
49412 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49413 PyObject *resultobj = 0;
49414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49415 wxWindow *arg2 = (wxWindow *) 0 ;
49416 void *argp1 = 0 ;
49417 int res1 = 0 ;
49418 void *argp2 = 0 ;
49419 int res2 = 0 ;
49420 PyObject * obj0 = 0 ;
49421 PyObject * obj1 = 0 ;
49422 char * kwnames[] = {
49423 (char *) "self",(char *) "window", NULL
49424 };
49425
49426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49428 if (!SWIG_IsOK(res1)) {
49429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49430 }
49431 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49432 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49433 if (!SWIG_IsOK(res2)) {
49434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49435 }
49436 arg2 = reinterpret_cast< wxWindow * >(argp2);
49437 {
49438 PyThreadState* __tstate = wxPyBeginAllowThreads();
49439 (arg1)->SetWindow(arg2);
49440 wxPyEndAllowThreads(__tstate);
49441 if (PyErr_Occurred()) SWIG_fail;
49442 }
49443 resultobj = SWIG_Py_Void();
49444 return resultobj;
49445 fail:
49446 return NULL;
49447 }
49448
49449
49450 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49451 PyObject *resultobj = 0;
49452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49453 wxSizer *result = 0 ;
49454 void *argp1 = 0 ;
49455 int res1 = 0 ;
49456 PyObject *swig_obj[1] ;
49457
49458 if (!args) SWIG_fail;
49459 swig_obj[0] = args;
49460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49461 if (!SWIG_IsOK(res1)) {
49462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49463 }
49464 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49465 {
49466 PyThreadState* __tstate = wxPyBeginAllowThreads();
49467 result = (wxSizer *)(arg1)->GetSizer();
49468 wxPyEndAllowThreads(__tstate);
49469 if (PyErr_Occurred()) SWIG_fail;
49470 }
49471 {
49472 resultobj = wxPyMake_wxObject(result, (bool)0);
49473 }
49474 return resultobj;
49475 fail:
49476 return NULL;
49477 }
49478
49479
49480 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49481 PyObject *resultobj = 0;
49482 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49483 wxSizer *arg2 = (wxSizer *) 0 ;
49484 void *argp1 = 0 ;
49485 int res1 = 0 ;
49486 int res2 = 0 ;
49487 PyObject * obj0 = 0 ;
49488 PyObject * obj1 = 0 ;
49489 char * kwnames[] = {
49490 (char *) "self",(char *) "sizer", NULL
49491 };
49492
49493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49495 if (!SWIG_IsOK(res1)) {
49496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49497 }
49498 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49499 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49500 if (!SWIG_IsOK(res2)) {
49501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49502 }
49503 {
49504 PyThreadState* __tstate = wxPyBeginAllowThreads();
49505 (arg1)->SetSizer(arg2);
49506 wxPyEndAllowThreads(__tstate);
49507 if (PyErr_Occurred()) SWIG_fail;
49508 }
49509 resultobj = SWIG_Py_Void();
49510 return resultobj;
49511 fail:
49512 return NULL;
49513 }
49514
49515
49516 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49517 PyObject *resultobj = 0;
49518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49519 wxSize result;
49520 void *argp1 = 0 ;
49521 int res1 = 0 ;
49522 PyObject *swig_obj[1] ;
49523
49524 if (!args) SWIG_fail;
49525 swig_obj[0] = args;
49526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49527 if (!SWIG_IsOK(res1)) {
49528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49529 }
49530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49531 {
49532 PyThreadState* __tstate = wxPyBeginAllowThreads();
49533 result = (arg1)->GetSpacer();
49534 wxPyEndAllowThreads(__tstate);
49535 if (PyErr_Occurred()) SWIG_fail;
49536 }
49537 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49538 return resultobj;
49539 fail:
49540 return NULL;
49541 }
49542
49543
49544 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49545 PyObject *resultobj = 0;
49546 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49547 wxSize *arg2 = 0 ;
49548 void *argp1 = 0 ;
49549 int res1 = 0 ;
49550 wxSize temp2 ;
49551 PyObject * obj0 = 0 ;
49552 PyObject * obj1 = 0 ;
49553 char * kwnames[] = {
49554 (char *) "self",(char *) "size", NULL
49555 };
49556
49557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49559 if (!SWIG_IsOK(res1)) {
49560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49561 }
49562 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49563 {
49564 arg2 = &temp2;
49565 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49566 }
49567 {
49568 PyThreadState* __tstate = wxPyBeginAllowThreads();
49569 (arg1)->SetSpacer((wxSize const &)*arg2);
49570 wxPyEndAllowThreads(__tstate);
49571 if (PyErr_Occurred()) SWIG_fail;
49572 }
49573 resultobj = SWIG_Py_Void();
49574 return resultobj;
49575 fail:
49576 return NULL;
49577 }
49578
49579
49580 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49581 PyObject *resultobj = 0;
49582 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49583 bool arg2 ;
49584 void *argp1 = 0 ;
49585 int res1 = 0 ;
49586 bool val2 ;
49587 int ecode2 = 0 ;
49588 PyObject * obj0 = 0 ;
49589 PyObject * obj1 = 0 ;
49590 char * kwnames[] = {
49591 (char *) "self",(char *) "show", NULL
49592 };
49593
49594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49596 if (!SWIG_IsOK(res1)) {
49597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49598 }
49599 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49601 if (!SWIG_IsOK(ecode2)) {
49602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49603 }
49604 arg2 = static_cast< bool >(val2);
49605 {
49606 PyThreadState* __tstate = wxPyBeginAllowThreads();
49607 (arg1)->Show(arg2);
49608 wxPyEndAllowThreads(__tstate);
49609 if (PyErr_Occurred()) SWIG_fail;
49610 }
49611 resultobj = SWIG_Py_Void();
49612 return resultobj;
49613 fail:
49614 return NULL;
49615 }
49616
49617
49618 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49619 PyObject *resultobj = 0;
49620 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49621 bool result;
49622 void *argp1 = 0 ;
49623 int res1 = 0 ;
49624 PyObject *swig_obj[1] ;
49625
49626 if (!args) SWIG_fail;
49627 swig_obj[0] = args;
49628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49629 if (!SWIG_IsOK(res1)) {
49630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49631 }
49632 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = (bool)(arg1)->IsShown();
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 {
49640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49641 }
49642 return resultobj;
49643 fail:
49644 return NULL;
49645 }
49646
49647
49648 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49649 PyObject *resultobj = 0;
49650 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49651 wxPoint result;
49652 void *argp1 = 0 ;
49653 int res1 = 0 ;
49654 PyObject *swig_obj[1] ;
49655
49656 if (!args) SWIG_fail;
49657 swig_obj[0] = args;
49658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49659 if (!SWIG_IsOK(res1)) {
49660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49661 }
49662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49663 {
49664 PyThreadState* __tstate = wxPyBeginAllowThreads();
49665 result = (arg1)->GetPosition();
49666 wxPyEndAllowThreads(__tstate);
49667 if (PyErr_Occurred()) SWIG_fail;
49668 }
49669 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49670 return resultobj;
49671 fail:
49672 return NULL;
49673 }
49674
49675
49676 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49677 PyObject *resultobj = 0;
49678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49679 PyObject *result = 0 ;
49680 void *argp1 = 0 ;
49681 int res1 = 0 ;
49682 PyObject *swig_obj[1] ;
49683
49684 if (!args) SWIG_fail;
49685 swig_obj[0] = args;
49686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49687 if (!SWIG_IsOK(res1)) {
49688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49689 }
49690 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49691 {
49692 PyThreadState* __tstate = wxPyBeginAllowThreads();
49693 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49694 wxPyEndAllowThreads(__tstate);
49695 if (PyErr_Occurred()) SWIG_fail;
49696 }
49697 resultobj = result;
49698 return resultobj;
49699 fail:
49700 return NULL;
49701 }
49702
49703
49704 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49705 PyObject *resultobj = 0;
49706 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49707 PyObject *arg2 = (PyObject *) 0 ;
49708 void *argp1 = 0 ;
49709 int res1 = 0 ;
49710 PyObject * obj0 = 0 ;
49711 PyObject * obj1 = 0 ;
49712 char * kwnames[] = {
49713 (char *) "self",(char *) "userData", NULL
49714 };
49715
49716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49718 if (!SWIG_IsOK(res1)) {
49719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49720 }
49721 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49722 arg2 = obj1;
49723 {
49724 PyThreadState* __tstate = wxPyBeginAllowThreads();
49725 wxSizerItem_SetUserData(arg1,arg2);
49726 wxPyEndAllowThreads(__tstate);
49727 if (PyErr_Occurred()) SWIG_fail;
49728 }
49729 resultobj = SWIG_Py_Void();
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49737 PyObject *obj;
49738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49739 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49740 return SWIG_Py_Void();
49741 }
49742
49743 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49744 return SWIG_Python_InitShadowInstance(args);
49745 }
49746
49747 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49748 PyObject *resultobj = 0;
49749 wxSizer *arg1 = (wxSizer *) 0 ;
49750 void *argp1 = 0 ;
49751 int res1 = 0 ;
49752 PyObject *swig_obj[1] ;
49753
49754 if (!args) SWIG_fail;
49755 swig_obj[0] = args;
49756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49757 if (!SWIG_IsOK(res1)) {
49758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49759 }
49760 arg1 = reinterpret_cast< wxSizer * >(argp1);
49761 {
49762 PyThreadState* __tstate = wxPyBeginAllowThreads();
49763 delete arg1;
49764
49765 wxPyEndAllowThreads(__tstate);
49766 if (PyErr_Occurred()) SWIG_fail;
49767 }
49768 resultobj = SWIG_Py_Void();
49769 return resultobj;
49770 fail:
49771 return NULL;
49772 }
49773
49774
49775 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49776 PyObject *resultobj = 0;
49777 wxSizer *arg1 = (wxSizer *) 0 ;
49778 PyObject *arg2 = (PyObject *) 0 ;
49779 void *argp1 = 0 ;
49780 int res1 = 0 ;
49781 PyObject * obj0 = 0 ;
49782 PyObject * obj1 = 0 ;
49783 char * kwnames[] = {
49784 (char *) "self",(char *) "_self", NULL
49785 };
49786
49787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49789 if (!SWIG_IsOK(res1)) {
49790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49791 }
49792 arg1 = reinterpret_cast< wxSizer * >(argp1);
49793 arg2 = obj1;
49794 {
49795 PyThreadState* __tstate = wxPyBeginAllowThreads();
49796 wxSizer__setOORInfo(arg1,arg2);
49797 wxPyEndAllowThreads(__tstate);
49798 if (PyErr_Occurred()) SWIG_fail;
49799 }
49800 resultobj = SWIG_Py_Void();
49801 return resultobj;
49802 fail:
49803 return NULL;
49804 }
49805
49806
49807 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49808 PyObject *resultobj = 0;
49809 wxSizer *arg1 = (wxSizer *) 0 ;
49810 PyObject *arg2 = (PyObject *) 0 ;
49811 int arg3 = (int) 0 ;
49812 int arg4 = (int) 0 ;
49813 int arg5 = (int) 0 ;
49814 PyObject *arg6 = (PyObject *) NULL ;
49815 wxSizerItem *result = 0 ;
49816 void *argp1 = 0 ;
49817 int res1 = 0 ;
49818 int val3 ;
49819 int ecode3 = 0 ;
49820 int val4 ;
49821 int ecode4 = 0 ;
49822 int val5 ;
49823 int ecode5 = 0 ;
49824 PyObject * obj0 = 0 ;
49825 PyObject * obj1 = 0 ;
49826 PyObject * obj2 = 0 ;
49827 PyObject * obj3 = 0 ;
49828 PyObject * obj4 = 0 ;
49829 PyObject * obj5 = 0 ;
49830 char * kwnames[] = {
49831 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49832 };
49833
49834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49836 if (!SWIG_IsOK(res1)) {
49837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49838 }
49839 arg1 = reinterpret_cast< wxSizer * >(argp1);
49840 arg2 = obj1;
49841 if (obj2) {
49842 ecode3 = SWIG_AsVal_int(obj2, &val3);
49843 if (!SWIG_IsOK(ecode3)) {
49844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49845 }
49846 arg3 = static_cast< int >(val3);
49847 }
49848 if (obj3) {
49849 ecode4 = SWIG_AsVal_int(obj3, &val4);
49850 if (!SWIG_IsOK(ecode4)) {
49851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49852 }
49853 arg4 = static_cast< int >(val4);
49854 }
49855 if (obj4) {
49856 ecode5 = SWIG_AsVal_int(obj4, &val5);
49857 if (!SWIG_IsOK(ecode5)) {
49858 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49859 }
49860 arg5 = static_cast< int >(val5);
49861 }
49862 if (obj5) {
49863 arg6 = obj5;
49864 }
49865 {
49866 PyThreadState* __tstate = wxPyBeginAllowThreads();
49867 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49868 wxPyEndAllowThreads(__tstate);
49869 if (PyErr_Occurred()) SWIG_fail;
49870 }
49871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49872 return resultobj;
49873 fail:
49874 return NULL;
49875 }
49876
49877
49878 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49879 PyObject *resultobj = 0;
49880 wxSizer *arg1 = (wxSizer *) 0 ;
49881 int arg2 ;
49882 PyObject *arg3 = (PyObject *) 0 ;
49883 int arg4 = (int) 0 ;
49884 int arg5 = (int) 0 ;
49885 int arg6 = (int) 0 ;
49886 PyObject *arg7 = (PyObject *) NULL ;
49887 wxSizerItem *result = 0 ;
49888 void *argp1 = 0 ;
49889 int res1 = 0 ;
49890 int val2 ;
49891 int ecode2 = 0 ;
49892 int val4 ;
49893 int ecode4 = 0 ;
49894 int val5 ;
49895 int ecode5 = 0 ;
49896 int val6 ;
49897 int ecode6 = 0 ;
49898 PyObject * obj0 = 0 ;
49899 PyObject * obj1 = 0 ;
49900 PyObject * obj2 = 0 ;
49901 PyObject * obj3 = 0 ;
49902 PyObject * obj4 = 0 ;
49903 PyObject * obj5 = 0 ;
49904 PyObject * obj6 = 0 ;
49905 char * kwnames[] = {
49906 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49907 };
49908
49909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49911 if (!SWIG_IsOK(res1)) {
49912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49913 }
49914 arg1 = reinterpret_cast< wxSizer * >(argp1);
49915 ecode2 = SWIG_AsVal_int(obj1, &val2);
49916 if (!SWIG_IsOK(ecode2)) {
49917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49918 }
49919 arg2 = static_cast< int >(val2);
49920 arg3 = obj2;
49921 if (obj3) {
49922 ecode4 = SWIG_AsVal_int(obj3, &val4);
49923 if (!SWIG_IsOK(ecode4)) {
49924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49925 }
49926 arg4 = static_cast< int >(val4);
49927 }
49928 if (obj4) {
49929 ecode5 = SWIG_AsVal_int(obj4, &val5);
49930 if (!SWIG_IsOK(ecode5)) {
49931 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49932 }
49933 arg5 = static_cast< int >(val5);
49934 }
49935 if (obj5) {
49936 ecode6 = SWIG_AsVal_int(obj5, &val6);
49937 if (!SWIG_IsOK(ecode6)) {
49938 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49939 }
49940 arg6 = static_cast< int >(val6);
49941 }
49942 if (obj6) {
49943 arg7 = obj6;
49944 }
49945 {
49946 PyThreadState* __tstate = wxPyBeginAllowThreads();
49947 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49948 wxPyEndAllowThreads(__tstate);
49949 if (PyErr_Occurred()) SWIG_fail;
49950 }
49951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49959 PyObject *resultobj = 0;
49960 wxSizer *arg1 = (wxSizer *) 0 ;
49961 PyObject *arg2 = (PyObject *) 0 ;
49962 int arg3 = (int) 0 ;
49963 int arg4 = (int) 0 ;
49964 int arg5 = (int) 0 ;
49965 PyObject *arg6 = (PyObject *) NULL ;
49966 wxSizerItem *result = 0 ;
49967 void *argp1 = 0 ;
49968 int res1 = 0 ;
49969 int val3 ;
49970 int ecode3 = 0 ;
49971 int val4 ;
49972 int ecode4 = 0 ;
49973 int val5 ;
49974 int ecode5 = 0 ;
49975 PyObject * obj0 = 0 ;
49976 PyObject * obj1 = 0 ;
49977 PyObject * obj2 = 0 ;
49978 PyObject * obj3 = 0 ;
49979 PyObject * obj4 = 0 ;
49980 PyObject * obj5 = 0 ;
49981 char * kwnames[] = {
49982 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49983 };
49984
49985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49987 if (!SWIG_IsOK(res1)) {
49988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49989 }
49990 arg1 = reinterpret_cast< wxSizer * >(argp1);
49991 arg2 = obj1;
49992 if (obj2) {
49993 ecode3 = SWIG_AsVal_int(obj2, &val3);
49994 if (!SWIG_IsOK(ecode3)) {
49995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49996 }
49997 arg3 = static_cast< int >(val3);
49998 }
49999 if (obj3) {
50000 ecode4 = SWIG_AsVal_int(obj3, &val4);
50001 if (!SWIG_IsOK(ecode4)) {
50002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
50003 }
50004 arg4 = static_cast< int >(val4);
50005 }
50006 if (obj4) {
50007 ecode5 = SWIG_AsVal_int(obj4, &val5);
50008 if (!SWIG_IsOK(ecode5)) {
50009 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50010 }
50011 arg5 = static_cast< int >(val5);
50012 }
50013 if (obj5) {
50014 arg6 = obj5;
50015 }
50016 {
50017 PyThreadState* __tstate = wxPyBeginAllowThreads();
50018 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50019 wxPyEndAllowThreads(__tstate);
50020 if (PyErr_Occurred()) SWIG_fail;
50021 }
50022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50023 return resultobj;
50024 fail:
50025 return NULL;
50026 }
50027
50028
50029 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50030 PyObject *resultobj = 0;
50031 wxSizer *arg1 = (wxSizer *) 0 ;
50032 PyObject *arg2 = (PyObject *) 0 ;
50033 bool result;
50034 void *argp1 = 0 ;
50035 int res1 = 0 ;
50036 PyObject * obj0 = 0 ;
50037 PyObject * obj1 = 0 ;
50038 char * kwnames[] = {
50039 (char *) "self",(char *) "item", NULL
50040 };
50041
50042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50044 if (!SWIG_IsOK(res1)) {
50045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50046 }
50047 arg1 = reinterpret_cast< wxSizer * >(argp1);
50048 arg2 = obj1;
50049 {
50050 PyThreadState* __tstate = wxPyBeginAllowThreads();
50051 result = (bool)wxSizer_Remove(arg1,arg2);
50052 wxPyEndAllowThreads(__tstate);
50053 if (PyErr_Occurred()) SWIG_fail;
50054 }
50055 {
50056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50057 }
50058 return resultobj;
50059 fail:
50060 return NULL;
50061 }
50062
50063
50064 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50065 PyObject *resultobj = 0;
50066 wxSizer *arg1 = (wxSizer *) 0 ;
50067 PyObject *arg2 = (PyObject *) 0 ;
50068 bool result;
50069 void *argp1 = 0 ;
50070 int res1 = 0 ;
50071 PyObject * obj0 = 0 ;
50072 PyObject * obj1 = 0 ;
50073 char * kwnames[] = {
50074 (char *) "self",(char *) "item", NULL
50075 };
50076
50077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50079 if (!SWIG_IsOK(res1)) {
50080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50081 }
50082 arg1 = reinterpret_cast< wxSizer * >(argp1);
50083 arg2 = obj1;
50084 {
50085 PyThreadState* __tstate = wxPyBeginAllowThreads();
50086 result = (bool)wxSizer_Detach(arg1,arg2);
50087 wxPyEndAllowThreads(__tstate);
50088 if (PyErr_Occurred()) SWIG_fail;
50089 }
50090 {
50091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50092 }
50093 return resultobj;
50094 fail:
50095 return NULL;
50096 }
50097
50098
50099 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50100 PyObject *resultobj = 0;
50101 wxSizer *arg1 = (wxSizer *) 0 ;
50102 PyObject *arg2 = (PyObject *) 0 ;
50103 wxSizerItem *result = 0 ;
50104 void *argp1 = 0 ;
50105 int res1 = 0 ;
50106 PyObject * obj0 = 0 ;
50107 PyObject * obj1 = 0 ;
50108 char * kwnames[] = {
50109 (char *) "self",(char *) "item", NULL
50110 };
50111
50112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50114 if (!SWIG_IsOK(res1)) {
50115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50116 }
50117 arg1 = reinterpret_cast< wxSizer * >(argp1);
50118 arg2 = obj1;
50119 {
50120 PyThreadState* __tstate = wxPyBeginAllowThreads();
50121 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50122 wxPyEndAllowThreads(__tstate);
50123 if (PyErr_Occurred()) SWIG_fail;
50124 }
50125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50126 return resultobj;
50127 fail:
50128 return NULL;
50129 }
50130
50131
50132 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50133 PyObject *resultobj = 0;
50134 wxSizer *arg1 = (wxSizer *) 0 ;
50135 PyObject *arg2 = (PyObject *) 0 ;
50136 wxSize *arg3 = 0 ;
50137 void *argp1 = 0 ;
50138 int res1 = 0 ;
50139 wxSize temp3 ;
50140 PyObject * obj0 = 0 ;
50141 PyObject * obj1 = 0 ;
50142 PyObject * obj2 = 0 ;
50143 char * kwnames[] = {
50144 (char *) "self",(char *) "item",(char *) "size", NULL
50145 };
50146
50147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50149 if (!SWIG_IsOK(res1)) {
50150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50151 }
50152 arg1 = reinterpret_cast< wxSizer * >(argp1);
50153 arg2 = obj1;
50154 {
50155 arg3 = &temp3;
50156 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50157 }
50158 {
50159 PyThreadState* __tstate = wxPyBeginAllowThreads();
50160 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50161 wxPyEndAllowThreads(__tstate);
50162 if (PyErr_Occurred()) SWIG_fail;
50163 }
50164 resultobj = SWIG_Py_Void();
50165 return resultobj;
50166 fail:
50167 return NULL;
50168 }
50169
50170
50171 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50172 PyObject *resultobj = 0;
50173 wxSizer *arg1 = (wxSizer *) 0 ;
50174 wxWindow *arg2 = (wxWindow *) 0 ;
50175 wxWindow *arg3 = (wxWindow *) 0 ;
50176 bool arg4 = (bool) false ;
50177 bool result;
50178 void *argp1 = 0 ;
50179 int res1 = 0 ;
50180 void *argp2 = 0 ;
50181 int res2 = 0 ;
50182 void *argp3 = 0 ;
50183 int res3 = 0 ;
50184 bool val4 ;
50185 int ecode4 = 0 ;
50186 PyObject * obj0 = 0 ;
50187 PyObject * obj1 = 0 ;
50188 PyObject * obj2 = 0 ;
50189 PyObject * obj3 = 0 ;
50190 char * kwnames[] = {
50191 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50192 };
50193
50194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50196 if (!SWIG_IsOK(res1)) {
50197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50198 }
50199 arg1 = reinterpret_cast< wxSizer * >(argp1);
50200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50201 if (!SWIG_IsOK(res2)) {
50202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50203 }
50204 arg2 = reinterpret_cast< wxWindow * >(argp2);
50205 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50206 if (!SWIG_IsOK(res3)) {
50207 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50208 }
50209 arg3 = reinterpret_cast< wxWindow * >(argp3);
50210 if (obj3) {
50211 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50212 if (!SWIG_IsOK(ecode4)) {
50213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50214 }
50215 arg4 = static_cast< bool >(val4);
50216 }
50217 {
50218 PyThreadState* __tstate = wxPyBeginAllowThreads();
50219 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50220 wxPyEndAllowThreads(__tstate);
50221 if (PyErr_Occurred()) SWIG_fail;
50222 }
50223 {
50224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50225 }
50226 return resultobj;
50227 fail:
50228 return NULL;
50229 }
50230
50231
50232 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50233 PyObject *resultobj = 0;
50234 wxSizer *arg1 = (wxSizer *) 0 ;
50235 wxSizer *arg2 = (wxSizer *) 0 ;
50236 wxSizer *arg3 = (wxSizer *) 0 ;
50237 bool arg4 = (bool) false ;
50238 bool result;
50239 void *argp1 = 0 ;
50240 int res1 = 0 ;
50241 void *argp2 = 0 ;
50242 int res2 = 0 ;
50243 void *argp3 = 0 ;
50244 int res3 = 0 ;
50245 bool val4 ;
50246 int ecode4 = 0 ;
50247 PyObject * obj0 = 0 ;
50248 PyObject * obj1 = 0 ;
50249 PyObject * obj2 = 0 ;
50250 PyObject * obj3 = 0 ;
50251 char * kwnames[] = {
50252 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50253 };
50254
50255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50257 if (!SWIG_IsOK(res1)) {
50258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50259 }
50260 arg1 = reinterpret_cast< wxSizer * >(argp1);
50261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50262 if (!SWIG_IsOK(res2)) {
50263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50264 }
50265 arg2 = reinterpret_cast< wxSizer * >(argp2);
50266 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50267 if (!SWIG_IsOK(res3)) {
50268 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50269 }
50270 arg3 = reinterpret_cast< wxSizer * >(argp3);
50271 if (obj3) {
50272 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50273 if (!SWIG_IsOK(ecode4)) {
50274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50275 }
50276 arg4 = static_cast< bool >(val4);
50277 }
50278 {
50279 PyThreadState* __tstate = wxPyBeginAllowThreads();
50280 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50281 wxPyEndAllowThreads(__tstate);
50282 if (PyErr_Occurred()) SWIG_fail;
50283 }
50284 {
50285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50286 }
50287 return resultobj;
50288 fail:
50289 return NULL;
50290 }
50291
50292
50293 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50294 PyObject *resultobj = 0;
50295 wxSizer *arg1 = (wxSizer *) 0 ;
50296 size_t arg2 ;
50297 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50298 bool result;
50299 void *argp1 = 0 ;
50300 int res1 = 0 ;
50301 size_t val2 ;
50302 int ecode2 = 0 ;
50303 void *argp3 = 0 ;
50304 int res3 = 0 ;
50305 PyObject * obj0 = 0 ;
50306 PyObject * obj1 = 0 ;
50307 PyObject * obj2 = 0 ;
50308 char * kwnames[] = {
50309 (char *) "self",(char *) "index",(char *) "newitem", NULL
50310 };
50311
50312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50314 if (!SWIG_IsOK(res1)) {
50315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50316 }
50317 arg1 = reinterpret_cast< wxSizer * >(argp1);
50318 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50319 if (!SWIG_IsOK(ecode2)) {
50320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50321 }
50322 arg2 = static_cast< size_t >(val2);
50323 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50324 if (!SWIG_IsOK(res3)) {
50325 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50326 }
50327 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50328 {
50329 PyThreadState* __tstate = wxPyBeginAllowThreads();
50330 result = (bool)(arg1)->Replace(arg2,arg3);
50331 wxPyEndAllowThreads(__tstate);
50332 if (PyErr_Occurred()) SWIG_fail;
50333 }
50334 {
50335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50336 }
50337 return resultobj;
50338 fail:
50339 return NULL;
50340 }
50341
50342
50343 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50344 PyObject *resultobj = 0;
50345 wxSizer *arg1 = (wxSizer *) 0 ;
50346 wxWindow *arg2 = (wxWindow *) 0 ;
50347 void *argp1 = 0 ;
50348 int res1 = 0 ;
50349 void *argp2 = 0 ;
50350 int res2 = 0 ;
50351 PyObject * obj0 = 0 ;
50352 PyObject * obj1 = 0 ;
50353 char * kwnames[] = {
50354 (char *) "self",(char *) "window", NULL
50355 };
50356
50357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50359 if (!SWIG_IsOK(res1)) {
50360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50361 }
50362 arg1 = reinterpret_cast< wxSizer * >(argp1);
50363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50364 if (!SWIG_IsOK(res2)) {
50365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50366 }
50367 arg2 = reinterpret_cast< wxWindow * >(argp2);
50368 {
50369 PyThreadState* __tstate = wxPyBeginAllowThreads();
50370 (arg1)->SetContainingWindow(arg2);
50371 wxPyEndAllowThreads(__tstate);
50372 if (PyErr_Occurred()) SWIG_fail;
50373 }
50374 resultobj = SWIG_Py_Void();
50375 return resultobj;
50376 fail:
50377 return NULL;
50378 }
50379
50380
50381 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50382 PyObject *resultobj = 0;
50383 wxSizer *arg1 = (wxSizer *) 0 ;
50384 wxWindow *result = 0 ;
50385 void *argp1 = 0 ;
50386 int res1 = 0 ;
50387 PyObject *swig_obj[1] ;
50388
50389 if (!args) SWIG_fail;
50390 swig_obj[0] = args;
50391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50394 }
50395 arg1 = reinterpret_cast< wxSizer * >(argp1);
50396 {
50397 PyThreadState* __tstate = wxPyBeginAllowThreads();
50398 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50399 wxPyEndAllowThreads(__tstate);
50400 if (PyErr_Occurred()) SWIG_fail;
50401 }
50402 {
50403 resultobj = wxPyMake_wxObject(result, 0);
50404 }
50405 return resultobj;
50406 fail:
50407 return NULL;
50408 }
50409
50410
50411 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50412 PyObject *resultobj = 0;
50413 wxSizer *arg1 = (wxSizer *) 0 ;
50414 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50415 wxSizerItem *result = 0 ;
50416 void *argp1 = 0 ;
50417 int res1 = 0 ;
50418 int res2 = 0 ;
50419 PyObject * obj0 = 0 ;
50420 PyObject * obj1 = 0 ;
50421 char * kwnames[] = {
50422 (char *) "self",(char *) "item", NULL
50423 };
50424
50425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50427 if (!SWIG_IsOK(res1)) {
50428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50429 }
50430 arg1 = reinterpret_cast< wxSizer * >(argp1);
50431 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50432 if (!SWIG_IsOK(res2)) {
50433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50434 }
50435 {
50436 PyThreadState* __tstate = wxPyBeginAllowThreads();
50437 result = (wxSizerItem *)(arg1)->Add(arg2);
50438 wxPyEndAllowThreads(__tstate);
50439 if (PyErr_Occurred()) SWIG_fail;
50440 }
50441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50442 return resultobj;
50443 fail:
50444 return NULL;
50445 }
50446
50447
50448 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50449 PyObject *resultobj = 0;
50450 wxSizer *arg1 = (wxSizer *) 0 ;
50451 size_t arg2 ;
50452 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50453 wxSizerItem *result = 0 ;
50454 void *argp1 = 0 ;
50455 int res1 = 0 ;
50456 size_t val2 ;
50457 int ecode2 = 0 ;
50458 int res3 = 0 ;
50459 PyObject * obj0 = 0 ;
50460 PyObject * obj1 = 0 ;
50461 PyObject * obj2 = 0 ;
50462 char * kwnames[] = {
50463 (char *) "self",(char *) "index",(char *) "item", NULL
50464 };
50465
50466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50468 if (!SWIG_IsOK(res1)) {
50469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50470 }
50471 arg1 = reinterpret_cast< wxSizer * >(argp1);
50472 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50473 if (!SWIG_IsOK(ecode2)) {
50474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50475 }
50476 arg2 = static_cast< size_t >(val2);
50477 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50478 if (!SWIG_IsOK(res3)) {
50479 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50480 }
50481 {
50482 PyThreadState* __tstate = wxPyBeginAllowThreads();
50483 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50484 wxPyEndAllowThreads(__tstate);
50485 if (PyErr_Occurred()) SWIG_fail;
50486 }
50487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50488 return resultobj;
50489 fail:
50490 return NULL;
50491 }
50492
50493
50494 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50495 PyObject *resultobj = 0;
50496 wxSizer *arg1 = (wxSizer *) 0 ;
50497 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50498 wxSizerItem *result = 0 ;
50499 void *argp1 = 0 ;
50500 int res1 = 0 ;
50501 int res2 = 0 ;
50502 PyObject * obj0 = 0 ;
50503 PyObject * obj1 = 0 ;
50504 char * kwnames[] = {
50505 (char *) "self",(char *) "item", NULL
50506 };
50507
50508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50510 if (!SWIG_IsOK(res1)) {
50511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50512 }
50513 arg1 = reinterpret_cast< wxSizer * >(argp1);
50514 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50515 if (!SWIG_IsOK(res2)) {
50516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50517 }
50518 {
50519 PyThreadState* __tstate = wxPyBeginAllowThreads();
50520 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50521 wxPyEndAllowThreads(__tstate);
50522 if (PyErr_Occurred()) SWIG_fail;
50523 }
50524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50525 return resultobj;
50526 fail:
50527 return NULL;
50528 }
50529
50530
50531 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50532 PyObject *resultobj = 0;
50533 wxSizer *arg1 = (wxSizer *) 0 ;
50534 int arg2 ;
50535 int arg3 ;
50536 int arg4 ;
50537 int arg5 ;
50538 void *argp1 = 0 ;
50539 int res1 = 0 ;
50540 int val2 ;
50541 int ecode2 = 0 ;
50542 int val3 ;
50543 int ecode3 = 0 ;
50544 int val4 ;
50545 int ecode4 = 0 ;
50546 int val5 ;
50547 int ecode5 = 0 ;
50548 PyObject * obj0 = 0 ;
50549 PyObject * obj1 = 0 ;
50550 PyObject * obj2 = 0 ;
50551 PyObject * obj3 = 0 ;
50552 PyObject * obj4 = 0 ;
50553 char * kwnames[] = {
50554 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50555 };
50556
50557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50559 if (!SWIG_IsOK(res1)) {
50560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50561 }
50562 arg1 = reinterpret_cast< wxSizer * >(argp1);
50563 ecode2 = SWIG_AsVal_int(obj1, &val2);
50564 if (!SWIG_IsOK(ecode2)) {
50565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50566 }
50567 arg2 = static_cast< int >(val2);
50568 ecode3 = SWIG_AsVal_int(obj2, &val3);
50569 if (!SWIG_IsOK(ecode3)) {
50570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50571 }
50572 arg3 = static_cast< int >(val3);
50573 ecode4 = SWIG_AsVal_int(obj3, &val4);
50574 if (!SWIG_IsOK(ecode4)) {
50575 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50576 }
50577 arg4 = static_cast< int >(val4);
50578 ecode5 = SWIG_AsVal_int(obj4, &val5);
50579 if (!SWIG_IsOK(ecode5)) {
50580 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50581 }
50582 arg5 = static_cast< int >(val5);
50583 {
50584 PyThreadState* __tstate = wxPyBeginAllowThreads();
50585 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50586 wxPyEndAllowThreads(__tstate);
50587 if (PyErr_Occurred()) SWIG_fail;
50588 }
50589 resultobj = SWIG_Py_Void();
50590 return resultobj;
50591 fail:
50592 return NULL;
50593 }
50594
50595
50596 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50597 PyObject *resultobj = 0;
50598 wxSizer *arg1 = (wxSizer *) 0 ;
50599 wxSize *arg2 = 0 ;
50600 void *argp1 = 0 ;
50601 int res1 = 0 ;
50602 wxSize temp2 ;
50603 PyObject * obj0 = 0 ;
50604 PyObject * obj1 = 0 ;
50605 char * kwnames[] = {
50606 (char *) "self",(char *) "size", NULL
50607 };
50608
50609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50611 if (!SWIG_IsOK(res1)) {
50612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50613 }
50614 arg1 = reinterpret_cast< wxSizer * >(argp1);
50615 {
50616 arg2 = &temp2;
50617 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50618 }
50619 {
50620 PyThreadState* __tstate = wxPyBeginAllowThreads();
50621 (arg1)->SetMinSize((wxSize const &)*arg2);
50622 wxPyEndAllowThreads(__tstate);
50623 if (PyErr_Occurred()) SWIG_fail;
50624 }
50625 resultobj = SWIG_Py_Void();
50626 return resultobj;
50627 fail:
50628 return NULL;
50629 }
50630
50631
50632 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50633 PyObject *resultobj = 0;
50634 wxSizer *arg1 = (wxSizer *) 0 ;
50635 wxSize result;
50636 void *argp1 = 0 ;
50637 int res1 = 0 ;
50638 PyObject *swig_obj[1] ;
50639
50640 if (!args) SWIG_fail;
50641 swig_obj[0] = args;
50642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50643 if (!SWIG_IsOK(res1)) {
50644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50645 }
50646 arg1 = reinterpret_cast< wxSizer * >(argp1);
50647 {
50648 PyThreadState* __tstate = wxPyBeginAllowThreads();
50649 result = (arg1)->GetSize();
50650 wxPyEndAllowThreads(__tstate);
50651 if (PyErr_Occurred()) SWIG_fail;
50652 }
50653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50654 return resultobj;
50655 fail:
50656 return NULL;
50657 }
50658
50659
50660 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50661 PyObject *resultobj = 0;
50662 wxSizer *arg1 = (wxSizer *) 0 ;
50663 wxPoint result;
50664 void *argp1 = 0 ;
50665 int res1 = 0 ;
50666 PyObject *swig_obj[1] ;
50667
50668 if (!args) SWIG_fail;
50669 swig_obj[0] = args;
50670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50671 if (!SWIG_IsOK(res1)) {
50672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50673 }
50674 arg1 = reinterpret_cast< wxSizer * >(argp1);
50675 {
50676 PyThreadState* __tstate = wxPyBeginAllowThreads();
50677 result = (arg1)->GetPosition();
50678 wxPyEndAllowThreads(__tstate);
50679 if (PyErr_Occurred()) SWIG_fail;
50680 }
50681 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50682 return resultobj;
50683 fail:
50684 return NULL;
50685 }
50686
50687
50688 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50689 PyObject *resultobj = 0;
50690 wxSizer *arg1 = (wxSizer *) 0 ;
50691 wxSize result;
50692 void *argp1 = 0 ;
50693 int res1 = 0 ;
50694 PyObject *swig_obj[1] ;
50695
50696 if (!args) SWIG_fail;
50697 swig_obj[0] = args;
50698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50699 if (!SWIG_IsOK(res1)) {
50700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50701 }
50702 arg1 = reinterpret_cast< wxSizer * >(argp1);
50703 {
50704 PyThreadState* __tstate = wxPyBeginAllowThreads();
50705 result = (arg1)->GetMinSize();
50706 wxPyEndAllowThreads(__tstate);
50707 if (PyErr_Occurred()) SWIG_fail;
50708 }
50709 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50710 return resultobj;
50711 fail:
50712 return NULL;
50713 }
50714
50715
50716 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50717 PyObject *resultobj = 0;
50718 wxSizer *arg1 = (wxSizer *) 0 ;
50719 void *argp1 = 0 ;
50720 int res1 = 0 ;
50721 PyObject *swig_obj[1] ;
50722
50723 if (!args) SWIG_fail;
50724 swig_obj[0] = args;
50725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50726 if (!SWIG_IsOK(res1)) {
50727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50728 }
50729 arg1 = reinterpret_cast< wxSizer * >(argp1);
50730 {
50731 PyThreadState* __tstate = wxPyBeginAllowThreads();
50732 (arg1)->RecalcSizes();
50733 wxPyEndAllowThreads(__tstate);
50734 if (PyErr_Occurred()) SWIG_fail;
50735 }
50736 resultobj = SWIG_Py_Void();
50737 return resultobj;
50738 fail:
50739 return NULL;
50740 }
50741
50742
50743 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50744 PyObject *resultobj = 0;
50745 wxSizer *arg1 = (wxSizer *) 0 ;
50746 wxSize result;
50747 void *argp1 = 0 ;
50748 int res1 = 0 ;
50749 PyObject *swig_obj[1] ;
50750
50751 if (!args) SWIG_fail;
50752 swig_obj[0] = args;
50753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50754 if (!SWIG_IsOK(res1)) {
50755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50756 }
50757 arg1 = reinterpret_cast< wxSizer * >(argp1);
50758 {
50759 PyThreadState* __tstate = wxPyBeginAllowThreads();
50760 result = (arg1)->CalcMin();
50761 wxPyEndAllowThreads(__tstate);
50762 if (PyErr_Occurred()) SWIG_fail;
50763 }
50764 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50765 return resultobj;
50766 fail:
50767 return NULL;
50768 }
50769
50770
50771 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50772 PyObject *resultobj = 0;
50773 wxSizer *arg1 = (wxSizer *) 0 ;
50774 void *argp1 = 0 ;
50775 int res1 = 0 ;
50776 PyObject *swig_obj[1] ;
50777
50778 if (!args) SWIG_fail;
50779 swig_obj[0] = args;
50780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50781 if (!SWIG_IsOK(res1)) {
50782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50783 }
50784 arg1 = reinterpret_cast< wxSizer * >(argp1);
50785 {
50786 PyThreadState* __tstate = wxPyBeginAllowThreads();
50787 (arg1)->Layout();
50788 wxPyEndAllowThreads(__tstate);
50789 if (PyErr_Occurred()) SWIG_fail;
50790 }
50791 resultobj = SWIG_Py_Void();
50792 return resultobj;
50793 fail:
50794 return NULL;
50795 }
50796
50797
50798 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50799 PyObject *resultobj = 0;
50800 wxSizer *arg1 = (wxSizer *) 0 ;
50801 wxWindow *arg2 = (wxWindow *) 0 ;
50802 wxSize result;
50803 void *argp1 = 0 ;
50804 int res1 = 0 ;
50805 void *argp2 = 0 ;
50806 int res2 = 0 ;
50807 PyObject * obj0 = 0 ;
50808 PyObject * obj1 = 0 ;
50809 char * kwnames[] = {
50810 (char *) "self",(char *) "window", NULL
50811 };
50812
50813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50815 if (!SWIG_IsOK(res1)) {
50816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50817 }
50818 arg1 = reinterpret_cast< wxSizer * >(argp1);
50819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50820 if (!SWIG_IsOK(res2)) {
50821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50822 }
50823 arg2 = reinterpret_cast< wxWindow * >(argp2);
50824 {
50825 PyThreadState* __tstate = wxPyBeginAllowThreads();
50826 result = (arg1)->Fit(arg2);
50827 wxPyEndAllowThreads(__tstate);
50828 if (PyErr_Occurred()) SWIG_fail;
50829 }
50830 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50831 return resultobj;
50832 fail:
50833 return NULL;
50834 }
50835
50836
50837 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50838 PyObject *resultobj = 0;
50839 wxSizer *arg1 = (wxSizer *) 0 ;
50840 wxWindow *arg2 = (wxWindow *) 0 ;
50841 void *argp1 = 0 ;
50842 int res1 = 0 ;
50843 void *argp2 = 0 ;
50844 int res2 = 0 ;
50845 PyObject * obj0 = 0 ;
50846 PyObject * obj1 = 0 ;
50847 char * kwnames[] = {
50848 (char *) "self",(char *) "window", NULL
50849 };
50850
50851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50853 if (!SWIG_IsOK(res1)) {
50854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50855 }
50856 arg1 = reinterpret_cast< wxSizer * >(argp1);
50857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50858 if (!SWIG_IsOK(res2)) {
50859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50860 }
50861 arg2 = reinterpret_cast< wxWindow * >(argp2);
50862 {
50863 PyThreadState* __tstate = wxPyBeginAllowThreads();
50864 (arg1)->FitInside(arg2);
50865 wxPyEndAllowThreads(__tstate);
50866 if (PyErr_Occurred()) SWIG_fail;
50867 }
50868 resultobj = SWIG_Py_Void();
50869 return resultobj;
50870 fail:
50871 return NULL;
50872 }
50873
50874
50875 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50876 PyObject *resultobj = 0;
50877 wxSizer *arg1 = (wxSizer *) 0 ;
50878 wxWindow *arg2 = (wxWindow *) 0 ;
50879 void *argp1 = 0 ;
50880 int res1 = 0 ;
50881 void *argp2 = 0 ;
50882 int res2 = 0 ;
50883 PyObject * obj0 = 0 ;
50884 PyObject * obj1 = 0 ;
50885 char * kwnames[] = {
50886 (char *) "self",(char *) "window", NULL
50887 };
50888
50889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50891 if (!SWIG_IsOK(res1)) {
50892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50893 }
50894 arg1 = reinterpret_cast< wxSizer * >(argp1);
50895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50896 if (!SWIG_IsOK(res2)) {
50897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50898 }
50899 arg2 = reinterpret_cast< wxWindow * >(argp2);
50900 {
50901 PyThreadState* __tstate = wxPyBeginAllowThreads();
50902 (arg1)->SetSizeHints(arg2);
50903 wxPyEndAllowThreads(__tstate);
50904 if (PyErr_Occurred()) SWIG_fail;
50905 }
50906 resultobj = SWIG_Py_Void();
50907 return resultobj;
50908 fail:
50909 return NULL;
50910 }
50911
50912
50913 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50914 PyObject *resultobj = 0;
50915 wxSizer *arg1 = (wxSizer *) 0 ;
50916 wxWindow *arg2 = (wxWindow *) 0 ;
50917 void *argp1 = 0 ;
50918 int res1 = 0 ;
50919 void *argp2 = 0 ;
50920 int res2 = 0 ;
50921 PyObject * obj0 = 0 ;
50922 PyObject * obj1 = 0 ;
50923 char * kwnames[] = {
50924 (char *) "self",(char *) "window", NULL
50925 };
50926
50927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50929 if (!SWIG_IsOK(res1)) {
50930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50931 }
50932 arg1 = reinterpret_cast< wxSizer * >(argp1);
50933 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50934 if (!SWIG_IsOK(res2)) {
50935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50936 }
50937 arg2 = reinterpret_cast< wxWindow * >(argp2);
50938 {
50939 PyThreadState* __tstate = wxPyBeginAllowThreads();
50940 (arg1)->SetVirtualSizeHints(arg2);
50941 wxPyEndAllowThreads(__tstate);
50942 if (PyErr_Occurred()) SWIG_fail;
50943 }
50944 resultobj = SWIG_Py_Void();
50945 return resultobj;
50946 fail:
50947 return NULL;
50948 }
50949
50950
50951 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50952 PyObject *resultobj = 0;
50953 wxSizer *arg1 = (wxSizer *) 0 ;
50954 bool arg2 = (bool) false ;
50955 void *argp1 = 0 ;
50956 int res1 = 0 ;
50957 bool val2 ;
50958 int ecode2 = 0 ;
50959 PyObject * obj0 = 0 ;
50960 PyObject * obj1 = 0 ;
50961 char * kwnames[] = {
50962 (char *) "self",(char *) "deleteWindows", NULL
50963 };
50964
50965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50967 if (!SWIG_IsOK(res1)) {
50968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50969 }
50970 arg1 = reinterpret_cast< wxSizer * >(argp1);
50971 if (obj1) {
50972 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50973 if (!SWIG_IsOK(ecode2)) {
50974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50975 }
50976 arg2 = static_cast< bool >(val2);
50977 }
50978 {
50979 PyThreadState* __tstate = wxPyBeginAllowThreads();
50980 (arg1)->Clear(arg2);
50981 wxPyEndAllowThreads(__tstate);
50982 if (PyErr_Occurred()) SWIG_fail;
50983 }
50984 resultobj = SWIG_Py_Void();
50985 return resultobj;
50986 fail:
50987 return NULL;
50988 }
50989
50990
50991 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50992 PyObject *resultobj = 0;
50993 wxSizer *arg1 = (wxSizer *) 0 ;
50994 void *argp1 = 0 ;
50995 int res1 = 0 ;
50996 PyObject *swig_obj[1] ;
50997
50998 if (!args) SWIG_fail;
50999 swig_obj[0] = args;
51000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51001 if (!SWIG_IsOK(res1)) {
51002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
51003 }
51004 arg1 = reinterpret_cast< wxSizer * >(argp1);
51005 {
51006 PyThreadState* __tstate = wxPyBeginAllowThreads();
51007 (arg1)->DeleteWindows();
51008 wxPyEndAllowThreads(__tstate);
51009 if (PyErr_Occurred()) SWIG_fail;
51010 }
51011 resultobj = SWIG_Py_Void();
51012 return resultobj;
51013 fail:
51014 return NULL;
51015 }
51016
51017
51018 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51019 PyObject *resultobj = 0;
51020 wxSizer *arg1 = (wxSizer *) 0 ;
51021 PyObject *result = 0 ;
51022 void *argp1 = 0 ;
51023 int res1 = 0 ;
51024 PyObject *swig_obj[1] ;
51025
51026 if (!args) SWIG_fail;
51027 swig_obj[0] = args;
51028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51029 if (!SWIG_IsOK(res1)) {
51030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51031 }
51032 arg1 = reinterpret_cast< wxSizer * >(argp1);
51033 {
51034 PyThreadState* __tstate = wxPyBeginAllowThreads();
51035 result = (PyObject *)wxSizer_GetChildren(arg1);
51036 wxPyEndAllowThreads(__tstate);
51037 if (PyErr_Occurred()) SWIG_fail;
51038 }
51039 resultobj = result;
51040 return resultobj;
51041 fail:
51042 return NULL;
51043 }
51044
51045
51046 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51047 PyObject *resultobj = 0;
51048 wxSizer *arg1 = (wxSizer *) 0 ;
51049 PyObject *arg2 = (PyObject *) 0 ;
51050 bool arg3 = (bool) true ;
51051 bool arg4 = (bool) false ;
51052 bool result;
51053 void *argp1 = 0 ;
51054 int res1 = 0 ;
51055 bool val3 ;
51056 int ecode3 = 0 ;
51057 bool val4 ;
51058 int ecode4 = 0 ;
51059 PyObject * obj0 = 0 ;
51060 PyObject * obj1 = 0 ;
51061 PyObject * obj2 = 0 ;
51062 PyObject * obj3 = 0 ;
51063 char * kwnames[] = {
51064 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51065 };
51066
51067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51069 if (!SWIG_IsOK(res1)) {
51070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51071 }
51072 arg1 = reinterpret_cast< wxSizer * >(argp1);
51073 arg2 = obj1;
51074 if (obj2) {
51075 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51076 if (!SWIG_IsOK(ecode3)) {
51077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51078 }
51079 arg3 = static_cast< bool >(val3);
51080 }
51081 if (obj3) {
51082 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51083 if (!SWIG_IsOK(ecode4)) {
51084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51085 }
51086 arg4 = static_cast< bool >(val4);
51087 }
51088 {
51089 PyThreadState* __tstate = wxPyBeginAllowThreads();
51090 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51091 wxPyEndAllowThreads(__tstate);
51092 if (PyErr_Occurred()) SWIG_fail;
51093 }
51094 {
51095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51096 }
51097 return resultobj;
51098 fail:
51099 return NULL;
51100 }
51101
51102
51103 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51104 PyObject *resultobj = 0;
51105 wxSizer *arg1 = (wxSizer *) 0 ;
51106 PyObject *arg2 = (PyObject *) 0 ;
51107 bool result;
51108 void *argp1 = 0 ;
51109 int res1 = 0 ;
51110 PyObject * obj0 = 0 ;
51111 PyObject * obj1 = 0 ;
51112 char * kwnames[] = {
51113 (char *) "self",(char *) "item", NULL
51114 };
51115
51116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51118 if (!SWIG_IsOK(res1)) {
51119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51120 }
51121 arg1 = reinterpret_cast< wxSizer * >(argp1);
51122 arg2 = obj1;
51123 {
51124 PyThreadState* __tstate = wxPyBeginAllowThreads();
51125 result = (bool)wxSizer_IsShown(arg1,arg2);
51126 wxPyEndAllowThreads(__tstate);
51127 if (PyErr_Occurred()) SWIG_fail;
51128 }
51129 {
51130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51131 }
51132 return resultobj;
51133 fail:
51134 return NULL;
51135 }
51136
51137
51138 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51139 PyObject *resultobj = 0;
51140 wxSizer *arg1 = (wxSizer *) 0 ;
51141 bool arg2 ;
51142 void *argp1 = 0 ;
51143 int res1 = 0 ;
51144 bool val2 ;
51145 int ecode2 = 0 ;
51146 PyObject * obj0 = 0 ;
51147 PyObject * obj1 = 0 ;
51148 char * kwnames[] = {
51149 (char *) "self",(char *) "show", NULL
51150 };
51151
51152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51154 if (!SWIG_IsOK(res1)) {
51155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51156 }
51157 arg1 = reinterpret_cast< wxSizer * >(argp1);
51158 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51159 if (!SWIG_IsOK(ecode2)) {
51160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51161 }
51162 arg2 = static_cast< bool >(val2);
51163 {
51164 PyThreadState* __tstate = wxPyBeginAllowThreads();
51165 (arg1)->ShowItems(arg2);
51166 wxPyEndAllowThreads(__tstate);
51167 if (PyErr_Occurred()) SWIG_fail;
51168 }
51169 resultobj = SWIG_Py_Void();
51170 return resultobj;
51171 fail:
51172 return NULL;
51173 }
51174
51175
51176 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51177 PyObject *obj;
51178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51179 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51180 return SWIG_Py_Void();
51181 }
51182
51183 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51184 PyObject *resultobj = 0;
51185 wxPySizer *result = 0 ;
51186
51187 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51188 {
51189 PyThreadState* __tstate = wxPyBeginAllowThreads();
51190 result = (wxPySizer *)new wxPySizer();
51191 wxPyEndAllowThreads(__tstate);
51192 if (PyErr_Occurred()) SWIG_fail;
51193 }
51194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51195 return resultobj;
51196 fail:
51197 return NULL;
51198 }
51199
51200
51201 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51202 PyObject *resultobj = 0;
51203 wxPySizer *arg1 = (wxPySizer *) 0 ;
51204 PyObject *arg2 = (PyObject *) 0 ;
51205 PyObject *arg3 = (PyObject *) 0 ;
51206 void *argp1 = 0 ;
51207 int res1 = 0 ;
51208 PyObject * obj0 = 0 ;
51209 PyObject * obj1 = 0 ;
51210 PyObject * obj2 = 0 ;
51211 char * kwnames[] = {
51212 (char *) "self",(char *) "self",(char *) "_class", NULL
51213 };
51214
51215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51217 if (!SWIG_IsOK(res1)) {
51218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51219 }
51220 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51221 arg2 = obj1;
51222 arg3 = obj2;
51223 {
51224 PyThreadState* __tstate = wxPyBeginAllowThreads();
51225 (arg1)->_setCallbackInfo(arg2,arg3);
51226 wxPyEndAllowThreads(__tstate);
51227 if (PyErr_Occurred()) SWIG_fail;
51228 }
51229 resultobj = SWIG_Py_Void();
51230 return resultobj;
51231 fail:
51232 return NULL;
51233 }
51234
51235
51236 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51237 PyObject *obj;
51238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51239 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51240 return SWIG_Py_Void();
51241 }
51242
51243 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51244 return SWIG_Python_InitShadowInstance(args);
51245 }
51246
51247 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51248 PyObject *resultobj = 0;
51249 int arg1 = (int) wxHORIZONTAL ;
51250 wxBoxSizer *result = 0 ;
51251 int val1 ;
51252 int ecode1 = 0 ;
51253 PyObject * obj0 = 0 ;
51254 char * kwnames[] = {
51255 (char *) "orient", NULL
51256 };
51257
51258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51259 if (obj0) {
51260 ecode1 = SWIG_AsVal_int(obj0, &val1);
51261 if (!SWIG_IsOK(ecode1)) {
51262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51263 }
51264 arg1 = static_cast< int >(val1);
51265 }
51266 {
51267 PyThreadState* __tstate = wxPyBeginAllowThreads();
51268 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51269 wxPyEndAllowThreads(__tstate);
51270 if (PyErr_Occurred()) SWIG_fail;
51271 }
51272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51273 return resultobj;
51274 fail:
51275 return NULL;
51276 }
51277
51278
51279 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51280 PyObject *resultobj = 0;
51281 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51282 int result;
51283 void *argp1 = 0 ;
51284 int res1 = 0 ;
51285 PyObject *swig_obj[1] ;
51286
51287 if (!args) SWIG_fail;
51288 swig_obj[0] = args;
51289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51290 if (!SWIG_IsOK(res1)) {
51291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51292 }
51293 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51294 {
51295 PyThreadState* __tstate = wxPyBeginAllowThreads();
51296 result = (int)(arg1)->GetOrientation();
51297 wxPyEndAllowThreads(__tstate);
51298 if (PyErr_Occurred()) SWIG_fail;
51299 }
51300 resultobj = SWIG_From_int(static_cast< int >(result));
51301 return resultobj;
51302 fail:
51303 return NULL;
51304 }
51305
51306
51307 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51308 PyObject *resultobj = 0;
51309 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51310 int arg2 ;
51311 void *argp1 = 0 ;
51312 int res1 = 0 ;
51313 int val2 ;
51314 int ecode2 = 0 ;
51315 PyObject * obj0 = 0 ;
51316 PyObject * obj1 = 0 ;
51317 char * kwnames[] = {
51318 (char *) "self",(char *) "orient", NULL
51319 };
51320
51321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51323 if (!SWIG_IsOK(res1)) {
51324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51325 }
51326 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51327 ecode2 = SWIG_AsVal_int(obj1, &val2);
51328 if (!SWIG_IsOK(ecode2)) {
51329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51330 }
51331 arg2 = static_cast< int >(val2);
51332 {
51333 PyThreadState* __tstate = wxPyBeginAllowThreads();
51334 (arg1)->SetOrientation(arg2);
51335 wxPyEndAllowThreads(__tstate);
51336 if (PyErr_Occurred()) SWIG_fail;
51337 }
51338 resultobj = SWIG_Py_Void();
51339 return resultobj;
51340 fail:
51341 return NULL;
51342 }
51343
51344
51345 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51346 PyObject *obj;
51347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51348 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51349 return SWIG_Py_Void();
51350 }
51351
51352 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51353 return SWIG_Python_InitShadowInstance(args);
51354 }
51355
51356 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51357 PyObject *resultobj = 0;
51358 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51359 int arg2 = (int) wxHORIZONTAL ;
51360 wxStaticBoxSizer *result = 0 ;
51361 void *argp1 = 0 ;
51362 int res1 = 0 ;
51363 int val2 ;
51364 int ecode2 = 0 ;
51365 PyObject * obj0 = 0 ;
51366 PyObject * obj1 = 0 ;
51367 char * kwnames[] = {
51368 (char *) "box",(char *) "orient", NULL
51369 };
51370
51371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51373 if (!SWIG_IsOK(res1)) {
51374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51375 }
51376 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51377 if (obj1) {
51378 ecode2 = SWIG_AsVal_int(obj1, &val2);
51379 if (!SWIG_IsOK(ecode2)) {
51380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51381 }
51382 arg2 = static_cast< int >(val2);
51383 }
51384 {
51385 PyThreadState* __tstate = wxPyBeginAllowThreads();
51386 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51387 wxPyEndAllowThreads(__tstate);
51388 if (PyErr_Occurred()) SWIG_fail;
51389 }
51390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51391 return resultobj;
51392 fail:
51393 return NULL;
51394 }
51395
51396
51397 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51398 PyObject *resultobj = 0;
51399 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51400 wxStaticBox *result = 0 ;
51401 void *argp1 = 0 ;
51402 int res1 = 0 ;
51403 PyObject *swig_obj[1] ;
51404
51405 if (!args) SWIG_fail;
51406 swig_obj[0] = args;
51407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51408 if (!SWIG_IsOK(res1)) {
51409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51410 }
51411 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51412 {
51413 PyThreadState* __tstate = wxPyBeginAllowThreads();
51414 result = (wxStaticBox *)(arg1)->GetStaticBox();
51415 wxPyEndAllowThreads(__tstate);
51416 if (PyErr_Occurred()) SWIG_fail;
51417 }
51418 {
51419 resultobj = wxPyMake_wxObject(result, (bool)0);
51420 }
51421 return resultobj;
51422 fail:
51423 return NULL;
51424 }
51425
51426
51427 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51428 PyObject *obj;
51429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51430 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51431 return SWIG_Py_Void();
51432 }
51433
51434 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51435 return SWIG_Python_InitShadowInstance(args);
51436 }
51437
51438 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51439 PyObject *resultobj = 0;
51440 int arg1 = (int) 1 ;
51441 int arg2 = (int) 0 ;
51442 int arg3 = (int) 0 ;
51443 int arg4 = (int) 0 ;
51444 wxGridSizer *result = 0 ;
51445 int val1 ;
51446 int ecode1 = 0 ;
51447 int val2 ;
51448 int ecode2 = 0 ;
51449 int val3 ;
51450 int ecode3 = 0 ;
51451 int val4 ;
51452 int ecode4 = 0 ;
51453 PyObject * obj0 = 0 ;
51454 PyObject * obj1 = 0 ;
51455 PyObject * obj2 = 0 ;
51456 PyObject * obj3 = 0 ;
51457 char * kwnames[] = {
51458 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51459 };
51460
51461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51462 if (obj0) {
51463 ecode1 = SWIG_AsVal_int(obj0, &val1);
51464 if (!SWIG_IsOK(ecode1)) {
51465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51466 }
51467 arg1 = static_cast< int >(val1);
51468 }
51469 if (obj1) {
51470 ecode2 = SWIG_AsVal_int(obj1, &val2);
51471 if (!SWIG_IsOK(ecode2)) {
51472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51473 }
51474 arg2 = static_cast< int >(val2);
51475 }
51476 if (obj2) {
51477 ecode3 = SWIG_AsVal_int(obj2, &val3);
51478 if (!SWIG_IsOK(ecode3)) {
51479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51480 }
51481 arg3 = static_cast< int >(val3);
51482 }
51483 if (obj3) {
51484 ecode4 = SWIG_AsVal_int(obj3, &val4);
51485 if (!SWIG_IsOK(ecode4)) {
51486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51487 }
51488 arg4 = static_cast< int >(val4);
51489 }
51490 {
51491 PyThreadState* __tstate = wxPyBeginAllowThreads();
51492 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51493 wxPyEndAllowThreads(__tstate);
51494 if (PyErr_Occurred()) SWIG_fail;
51495 }
51496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51497 return resultobj;
51498 fail:
51499 return NULL;
51500 }
51501
51502
51503 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51504 PyObject *resultobj = 0;
51505 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51506 int arg2 ;
51507 void *argp1 = 0 ;
51508 int res1 = 0 ;
51509 int val2 ;
51510 int ecode2 = 0 ;
51511 PyObject * obj0 = 0 ;
51512 PyObject * obj1 = 0 ;
51513 char * kwnames[] = {
51514 (char *) "self",(char *) "cols", NULL
51515 };
51516
51517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51519 if (!SWIG_IsOK(res1)) {
51520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51521 }
51522 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51523 ecode2 = SWIG_AsVal_int(obj1, &val2);
51524 if (!SWIG_IsOK(ecode2)) {
51525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51526 }
51527 arg2 = static_cast< int >(val2);
51528 {
51529 PyThreadState* __tstate = wxPyBeginAllowThreads();
51530 (arg1)->SetCols(arg2);
51531 wxPyEndAllowThreads(__tstate);
51532 if (PyErr_Occurred()) SWIG_fail;
51533 }
51534 resultobj = SWIG_Py_Void();
51535 return resultobj;
51536 fail:
51537 return NULL;
51538 }
51539
51540
51541 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51542 PyObject *resultobj = 0;
51543 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51544 int arg2 ;
51545 void *argp1 = 0 ;
51546 int res1 = 0 ;
51547 int val2 ;
51548 int ecode2 = 0 ;
51549 PyObject * obj0 = 0 ;
51550 PyObject * obj1 = 0 ;
51551 char * kwnames[] = {
51552 (char *) "self",(char *) "rows", NULL
51553 };
51554
51555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51557 if (!SWIG_IsOK(res1)) {
51558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51559 }
51560 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51561 ecode2 = SWIG_AsVal_int(obj1, &val2);
51562 if (!SWIG_IsOK(ecode2)) {
51563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51564 }
51565 arg2 = static_cast< int >(val2);
51566 {
51567 PyThreadState* __tstate = wxPyBeginAllowThreads();
51568 (arg1)->SetRows(arg2);
51569 wxPyEndAllowThreads(__tstate);
51570 if (PyErr_Occurred()) SWIG_fail;
51571 }
51572 resultobj = SWIG_Py_Void();
51573 return resultobj;
51574 fail:
51575 return NULL;
51576 }
51577
51578
51579 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51580 PyObject *resultobj = 0;
51581 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51582 int arg2 ;
51583 void *argp1 = 0 ;
51584 int res1 = 0 ;
51585 int val2 ;
51586 int ecode2 = 0 ;
51587 PyObject * obj0 = 0 ;
51588 PyObject * obj1 = 0 ;
51589 char * kwnames[] = {
51590 (char *) "self",(char *) "gap", NULL
51591 };
51592
51593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51595 if (!SWIG_IsOK(res1)) {
51596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51597 }
51598 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51599 ecode2 = SWIG_AsVal_int(obj1, &val2);
51600 if (!SWIG_IsOK(ecode2)) {
51601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51602 }
51603 arg2 = static_cast< int >(val2);
51604 {
51605 PyThreadState* __tstate = wxPyBeginAllowThreads();
51606 (arg1)->SetVGap(arg2);
51607 wxPyEndAllowThreads(__tstate);
51608 if (PyErr_Occurred()) SWIG_fail;
51609 }
51610 resultobj = SWIG_Py_Void();
51611 return resultobj;
51612 fail:
51613 return NULL;
51614 }
51615
51616
51617 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51618 PyObject *resultobj = 0;
51619 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51620 int arg2 ;
51621 void *argp1 = 0 ;
51622 int res1 = 0 ;
51623 int val2 ;
51624 int ecode2 = 0 ;
51625 PyObject * obj0 = 0 ;
51626 PyObject * obj1 = 0 ;
51627 char * kwnames[] = {
51628 (char *) "self",(char *) "gap", NULL
51629 };
51630
51631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51633 if (!SWIG_IsOK(res1)) {
51634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51635 }
51636 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51637 ecode2 = SWIG_AsVal_int(obj1, &val2);
51638 if (!SWIG_IsOK(ecode2)) {
51639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51640 }
51641 arg2 = static_cast< int >(val2);
51642 {
51643 PyThreadState* __tstate = wxPyBeginAllowThreads();
51644 (arg1)->SetHGap(arg2);
51645 wxPyEndAllowThreads(__tstate);
51646 if (PyErr_Occurred()) SWIG_fail;
51647 }
51648 resultobj = SWIG_Py_Void();
51649 return resultobj;
51650 fail:
51651 return NULL;
51652 }
51653
51654
51655 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51656 PyObject *resultobj = 0;
51657 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51658 int result;
51659 void *argp1 = 0 ;
51660 int res1 = 0 ;
51661 PyObject *swig_obj[1] ;
51662
51663 if (!args) SWIG_fail;
51664 swig_obj[0] = args;
51665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51666 if (!SWIG_IsOK(res1)) {
51667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51668 }
51669 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51670 {
51671 PyThreadState* __tstate = wxPyBeginAllowThreads();
51672 result = (int)(arg1)->GetCols();
51673 wxPyEndAllowThreads(__tstate);
51674 if (PyErr_Occurred()) SWIG_fail;
51675 }
51676 resultobj = SWIG_From_int(static_cast< int >(result));
51677 return resultobj;
51678 fail:
51679 return NULL;
51680 }
51681
51682
51683 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51684 PyObject *resultobj = 0;
51685 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51686 int result;
51687 void *argp1 = 0 ;
51688 int res1 = 0 ;
51689 PyObject *swig_obj[1] ;
51690
51691 if (!args) SWIG_fail;
51692 swig_obj[0] = args;
51693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51694 if (!SWIG_IsOK(res1)) {
51695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51696 }
51697 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51698 {
51699 PyThreadState* __tstate = wxPyBeginAllowThreads();
51700 result = (int)(arg1)->GetRows();
51701 wxPyEndAllowThreads(__tstate);
51702 if (PyErr_Occurred()) SWIG_fail;
51703 }
51704 resultobj = SWIG_From_int(static_cast< int >(result));
51705 return resultobj;
51706 fail:
51707 return NULL;
51708 }
51709
51710
51711 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51712 PyObject *resultobj = 0;
51713 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51714 int result;
51715 void *argp1 = 0 ;
51716 int res1 = 0 ;
51717 PyObject *swig_obj[1] ;
51718
51719 if (!args) SWIG_fail;
51720 swig_obj[0] = args;
51721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51722 if (!SWIG_IsOK(res1)) {
51723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51724 }
51725 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51726 {
51727 PyThreadState* __tstate = wxPyBeginAllowThreads();
51728 result = (int)(arg1)->GetVGap();
51729 wxPyEndAllowThreads(__tstate);
51730 if (PyErr_Occurred()) SWIG_fail;
51731 }
51732 resultobj = SWIG_From_int(static_cast< int >(result));
51733 return resultobj;
51734 fail:
51735 return NULL;
51736 }
51737
51738
51739 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51740 PyObject *resultobj = 0;
51741 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51742 int result;
51743 void *argp1 = 0 ;
51744 int res1 = 0 ;
51745 PyObject *swig_obj[1] ;
51746
51747 if (!args) SWIG_fail;
51748 swig_obj[0] = args;
51749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51750 if (!SWIG_IsOK(res1)) {
51751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51752 }
51753 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51754 {
51755 PyThreadState* __tstate = wxPyBeginAllowThreads();
51756 result = (int)(arg1)->GetHGap();
51757 wxPyEndAllowThreads(__tstate);
51758 if (PyErr_Occurred()) SWIG_fail;
51759 }
51760 resultobj = SWIG_From_int(static_cast< int >(result));
51761 return resultobj;
51762 fail:
51763 return NULL;
51764 }
51765
51766
51767 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51768 PyObject *obj;
51769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51770 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51771 return SWIG_Py_Void();
51772 }
51773
51774 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51775 return SWIG_Python_InitShadowInstance(args);
51776 }
51777
51778 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51779 PyObject *resultobj = 0;
51780 int arg1 = (int) 1 ;
51781 int arg2 = (int) 0 ;
51782 int arg3 = (int) 0 ;
51783 int arg4 = (int) 0 ;
51784 wxFlexGridSizer *result = 0 ;
51785 int val1 ;
51786 int ecode1 = 0 ;
51787 int val2 ;
51788 int ecode2 = 0 ;
51789 int val3 ;
51790 int ecode3 = 0 ;
51791 int val4 ;
51792 int ecode4 = 0 ;
51793 PyObject * obj0 = 0 ;
51794 PyObject * obj1 = 0 ;
51795 PyObject * obj2 = 0 ;
51796 PyObject * obj3 = 0 ;
51797 char * kwnames[] = {
51798 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51799 };
51800
51801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51802 if (obj0) {
51803 ecode1 = SWIG_AsVal_int(obj0, &val1);
51804 if (!SWIG_IsOK(ecode1)) {
51805 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51806 }
51807 arg1 = static_cast< int >(val1);
51808 }
51809 if (obj1) {
51810 ecode2 = SWIG_AsVal_int(obj1, &val2);
51811 if (!SWIG_IsOK(ecode2)) {
51812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51813 }
51814 arg2 = static_cast< int >(val2);
51815 }
51816 if (obj2) {
51817 ecode3 = SWIG_AsVal_int(obj2, &val3);
51818 if (!SWIG_IsOK(ecode3)) {
51819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51820 }
51821 arg3 = static_cast< int >(val3);
51822 }
51823 if (obj3) {
51824 ecode4 = SWIG_AsVal_int(obj3, &val4);
51825 if (!SWIG_IsOK(ecode4)) {
51826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51827 }
51828 arg4 = static_cast< int >(val4);
51829 }
51830 {
51831 PyThreadState* __tstate = wxPyBeginAllowThreads();
51832 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51833 wxPyEndAllowThreads(__tstate);
51834 if (PyErr_Occurred()) SWIG_fail;
51835 }
51836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51837 return resultobj;
51838 fail:
51839 return NULL;
51840 }
51841
51842
51843 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51844 PyObject *resultobj = 0;
51845 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51846 size_t arg2 ;
51847 int arg3 = (int) 0 ;
51848 void *argp1 = 0 ;
51849 int res1 = 0 ;
51850 size_t val2 ;
51851 int ecode2 = 0 ;
51852 int val3 ;
51853 int ecode3 = 0 ;
51854 PyObject * obj0 = 0 ;
51855 PyObject * obj1 = 0 ;
51856 PyObject * obj2 = 0 ;
51857 char * kwnames[] = {
51858 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51859 };
51860
51861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51863 if (!SWIG_IsOK(res1)) {
51864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51865 }
51866 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51867 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51868 if (!SWIG_IsOK(ecode2)) {
51869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51870 }
51871 arg2 = static_cast< size_t >(val2);
51872 if (obj2) {
51873 ecode3 = SWIG_AsVal_int(obj2, &val3);
51874 if (!SWIG_IsOK(ecode3)) {
51875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51876 }
51877 arg3 = static_cast< int >(val3);
51878 }
51879 {
51880 PyThreadState* __tstate = wxPyBeginAllowThreads();
51881 (arg1)->AddGrowableRow(arg2,arg3);
51882 wxPyEndAllowThreads(__tstate);
51883 if (PyErr_Occurred()) SWIG_fail;
51884 }
51885 resultobj = SWIG_Py_Void();
51886 return resultobj;
51887 fail:
51888 return NULL;
51889 }
51890
51891
51892 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51893 PyObject *resultobj = 0;
51894 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51895 size_t arg2 ;
51896 void *argp1 = 0 ;
51897 int res1 = 0 ;
51898 size_t val2 ;
51899 int ecode2 = 0 ;
51900 PyObject * obj0 = 0 ;
51901 PyObject * obj1 = 0 ;
51902 char * kwnames[] = {
51903 (char *) "self",(char *) "idx", NULL
51904 };
51905
51906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51908 if (!SWIG_IsOK(res1)) {
51909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51910 }
51911 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51912 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51913 if (!SWIG_IsOK(ecode2)) {
51914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51915 }
51916 arg2 = static_cast< size_t >(val2);
51917 {
51918 PyThreadState* __tstate = wxPyBeginAllowThreads();
51919 (arg1)->RemoveGrowableRow(arg2);
51920 wxPyEndAllowThreads(__tstate);
51921 if (PyErr_Occurred()) SWIG_fail;
51922 }
51923 resultobj = SWIG_Py_Void();
51924 return resultobj;
51925 fail:
51926 return NULL;
51927 }
51928
51929
51930 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51931 PyObject *resultobj = 0;
51932 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51933 size_t arg2 ;
51934 int arg3 = (int) 0 ;
51935 void *argp1 = 0 ;
51936 int res1 = 0 ;
51937 size_t val2 ;
51938 int ecode2 = 0 ;
51939 int val3 ;
51940 int ecode3 = 0 ;
51941 PyObject * obj0 = 0 ;
51942 PyObject * obj1 = 0 ;
51943 PyObject * obj2 = 0 ;
51944 char * kwnames[] = {
51945 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51946 };
51947
51948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51950 if (!SWIG_IsOK(res1)) {
51951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51952 }
51953 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51954 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51955 if (!SWIG_IsOK(ecode2)) {
51956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51957 }
51958 arg2 = static_cast< size_t >(val2);
51959 if (obj2) {
51960 ecode3 = SWIG_AsVal_int(obj2, &val3);
51961 if (!SWIG_IsOK(ecode3)) {
51962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51963 }
51964 arg3 = static_cast< int >(val3);
51965 }
51966 {
51967 PyThreadState* __tstate = wxPyBeginAllowThreads();
51968 (arg1)->AddGrowableCol(arg2,arg3);
51969 wxPyEndAllowThreads(__tstate);
51970 if (PyErr_Occurred()) SWIG_fail;
51971 }
51972 resultobj = SWIG_Py_Void();
51973 return resultobj;
51974 fail:
51975 return NULL;
51976 }
51977
51978
51979 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51980 PyObject *resultobj = 0;
51981 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51982 size_t arg2 ;
51983 void *argp1 = 0 ;
51984 int res1 = 0 ;
51985 size_t val2 ;
51986 int ecode2 = 0 ;
51987 PyObject * obj0 = 0 ;
51988 PyObject * obj1 = 0 ;
51989 char * kwnames[] = {
51990 (char *) "self",(char *) "idx", NULL
51991 };
51992
51993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51995 if (!SWIG_IsOK(res1)) {
51996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51997 }
51998 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51999 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52000 if (!SWIG_IsOK(ecode2)) {
52001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52002 }
52003 arg2 = static_cast< size_t >(val2);
52004 {
52005 PyThreadState* __tstate = wxPyBeginAllowThreads();
52006 (arg1)->RemoveGrowableCol(arg2);
52007 wxPyEndAllowThreads(__tstate);
52008 if (PyErr_Occurred()) SWIG_fail;
52009 }
52010 resultobj = SWIG_Py_Void();
52011 return resultobj;
52012 fail:
52013 return NULL;
52014 }
52015
52016
52017 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52018 PyObject *resultobj = 0;
52019 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52020 int arg2 ;
52021 void *argp1 = 0 ;
52022 int res1 = 0 ;
52023 int val2 ;
52024 int ecode2 = 0 ;
52025 PyObject * obj0 = 0 ;
52026 PyObject * obj1 = 0 ;
52027 char * kwnames[] = {
52028 (char *) "self",(char *) "direction", NULL
52029 };
52030
52031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52033 if (!SWIG_IsOK(res1)) {
52034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52035 }
52036 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52037 ecode2 = SWIG_AsVal_int(obj1, &val2);
52038 if (!SWIG_IsOK(ecode2)) {
52039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52040 }
52041 arg2 = static_cast< int >(val2);
52042 {
52043 PyThreadState* __tstate = wxPyBeginAllowThreads();
52044 (arg1)->SetFlexibleDirection(arg2);
52045 wxPyEndAllowThreads(__tstate);
52046 if (PyErr_Occurred()) SWIG_fail;
52047 }
52048 resultobj = SWIG_Py_Void();
52049 return resultobj;
52050 fail:
52051 return NULL;
52052 }
52053
52054
52055 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52056 PyObject *resultobj = 0;
52057 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52058 int result;
52059 void *argp1 = 0 ;
52060 int res1 = 0 ;
52061 PyObject *swig_obj[1] ;
52062
52063 if (!args) SWIG_fail;
52064 swig_obj[0] = args;
52065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52066 if (!SWIG_IsOK(res1)) {
52067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52068 }
52069 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52070 {
52071 PyThreadState* __tstate = wxPyBeginAllowThreads();
52072 result = (int)(arg1)->GetFlexibleDirection();
52073 wxPyEndAllowThreads(__tstate);
52074 if (PyErr_Occurred()) SWIG_fail;
52075 }
52076 resultobj = SWIG_From_int(static_cast< int >(result));
52077 return resultobj;
52078 fail:
52079 return NULL;
52080 }
52081
52082
52083 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52084 PyObject *resultobj = 0;
52085 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52086 wxFlexSizerGrowMode arg2 ;
52087 void *argp1 = 0 ;
52088 int res1 = 0 ;
52089 int val2 ;
52090 int ecode2 = 0 ;
52091 PyObject * obj0 = 0 ;
52092 PyObject * obj1 = 0 ;
52093 char * kwnames[] = {
52094 (char *) "self",(char *) "mode", NULL
52095 };
52096
52097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52099 if (!SWIG_IsOK(res1)) {
52100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52101 }
52102 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52103 ecode2 = SWIG_AsVal_int(obj1, &val2);
52104 if (!SWIG_IsOK(ecode2)) {
52105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52106 }
52107 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52108 {
52109 PyThreadState* __tstate = wxPyBeginAllowThreads();
52110 (arg1)->SetNonFlexibleGrowMode(arg2);
52111 wxPyEndAllowThreads(__tstate);
52112 if (PyErr_Occurred()) SWIG_fail;
52113 }
52114 resultobj = SWIG_Py_Void();
52115 return resultobj;
52116 fail:
52117 return NULL;
52118 }
52119
52120
52121 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52122 PyObject *resultobj = 0;
52123 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52124 wxFlexSizerGrowMode result;
52125 void *argp1 = 0 ;
52126 int res1 = 0 ;
52127 PyObject *swig_obj[1] ;
52128
52129 if (!args) SWIG_fail;
52130 swig_obj[0] = args;
52131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52132 if (!SWIG_IsOK(res1)) {
52133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52134 }
52135 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52136 {
52137 PyThreadState* __tstate = wxPyBeginAllowThreads();
52138 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52139 wxPyEndAllowThreads(__tstate);
52140 if (PyErr_Occurred()) SWIG_fail;
52141 }
52142 resultobj = SWIG_From_int(static_cast< int >(result));
52143 return resultobj;
52144 fail:
52145 return NULL;
52146 }
52147
52148
52149 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52150 PyObject *resultobj = 0;
52151 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52152 wxArrayInt *result = 0 ;
52153 void *argp1 = 0 ;
52154 int res1 = 0 ;
52155 PyObject *swig_obj[1] ;
52156
52157 if (!args) SWIG_fail;
52158 swig_obj[0] = args;
52159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52160 if (!SWIG_IsOK(res1)) {
52161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52162 }
52163 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52164 {
52165 PyThreadState* __tstate = wxPyBeginAllowThreads();
52166 {
52167 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52168 result = (wxArrayInt *) &_result_ref;
52169 }
52170 wxPyEndAllowThreads(__tstate);
52171 if (PyErr_Occurred()) SWIG_fail;
52172 }
52173 {
52174 resultobj = wxArrayInt2PyList_helper(*result);
52175 }
52176 return resultobj;
52177 fail:
52178 return NULL;
52179 }
52180
52181
52182 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52183 PyObject *resultobj = 0;
52184 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52185 wxArrayInt *result = 0 ;
52186 void *argp1 = 0 ;
52187 int res1 = 0 ;
52188 PyObject *swig_obj[1] ;
52189
52190 if (!args) SWIG_fail;
52191 swig_obj[0] = args;
52192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52193 if (!SWIG_IsOK(res1)) {
52194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52195 }
52196 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52197 {
52198 PyThreadState* __tstate = wxPyBeginAllowThreads();
52199 {
52200 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52201 result = (wxArrayInt *) &_result_ref;
52202 }
52203 wxPyEndAllowThreads(__tstate);
52204 if (PyErr_Occurred()) SWIG_fail;
52205 }
52206 {
52207 resultobj = wxArrayInt2PyList_helper(*result);
52208 }
52209 return resultobj;
52210 fail:
52211 return NULL;
52212 }
52213
52214
52215 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52216 PyObject *obj;
52217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52218 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52219 return SWIG_Py_Void();
52220 }
52221
52222 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52223 return SWIG_Python_InitShadowInstance(args);
52224 }
52225
52226 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52227 PyObject *resultobj = 0;
52228 wxStdDialogButtonSizer *result = 0 ;
52229
52230 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52231 {
52232 PyThreadState* __tstate = wxPyBeginAllowThreads();
52233 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52234 wxPyEndAllowThreads(__tstate);
52235 if (PyErr_Occurred()) SWIG_fail;
52236 }
52237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52238 return resultobj;
52239 fail:
52240 return NULL;
52241 }
52242
52243
52244 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52245 PyObject *resultobj = 0;
52246 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52247 wxButton *arg2 = (wxButton *) 0 ;
52248 void *argp1 = 0 ;
52249 int res1 = 0 ;
52250 void *argp2 = 0 ;
52251 int res2 = 0 ;
52252 PyObject * obj0 = 0 ;
52253 PyObject * obj1 = 0 ;
52254 char * kwnames[] = {
52255 (char *) "self",(char *) "button", NULL
52256 };
52257
52258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52260 if (!SWIG_IsOK(res1)) {
52261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52262 }
52263 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52265 if (!SWIG_IsOK(res2)) {
52266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52267 }
52268 arg2 = reinterpret_cast< wxButton * >(argp2);
52269 {
52270 PyThreadState* __tstate = wxPyBeginAllowThreads();
52271 (arg1)->AddButton(arg2);
52272 wxPyEndAllowThreads(__tstate);
52273 if (PyErr_Occurred()) SWIG_fail;
52274 }
52275 resultobj = SWIG_Py_Void();
52276 return resultobj;
52277 fail:
52278 return NULL;
52279 }
52280
52281
52282 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52283 PyObject *resultobj = 0;
52284 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52285 void *argp1 = 0 ;
52286 int res1 = 0 ;
52287 PyObject *swig_obj[1] ;
52288
52289 if (!args) SWIG_fail;
52290 swig_obj[0] = args;
52291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52292 if (!SWIG_IsOK(res1)) {
52293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52294 }
52295 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52296 {
52297 PyThreadState* __tstate = wxPyBeginAllowThreads();
52298 (arg1)->Realize();
52299 wxPyEndAllowThreads(__tstate);
52300 if (PyErr_Occurred()) SWIG_fail;
52301 }
52302 resultobj = SWIG_Py_Void();
52303 return resultobj;
52304 fail:
52305 return NULL;
52306 }
52307
52308
52309 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52310 PyObject *resultobj = 0;
52311 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52312 wxButton *arg2 = (wxButton *) 0 ;
52313 void *argp1 = 0 ;
52314 int res1 = 0 ;
52315 void *argp2 = 0 ;
52316 int res2 = 0 ;
52317 PyObject * obj0 = 0 ;
52318 PyObject * obj1 = 0 ;
52319 char * kwnames[] = {
52320 (char *) "self",(char *) "button", NULL
52321 };
52322
52323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52325 if (!SWIG_IsOK(res1)) {
52326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52327 }
52328 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52329 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52330 if (!SWIG_IsOK(res2)) {
52331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52332 }
52333 arg2 = reinterpret_cast< wxButton * >(argp2);
52334 {
52335 PyThreadState* __tstate = wxPyBeginAllowThreads();
52336 (arg1)->SetAffirmativeButton(arg2);
52337 wxPyEndAllowThreads(__tstate);
52338 if (PyErr_Occurred()) SWIG_fail;
52339 }
52340 resultobj = SWIG_Py_Void();
52341 return resultobj;
52342 fail:
52343 return NULL;
52344 }
52345
52346
52347 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52348 PyObject *resultobj = 0;
52349 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52350 wxButton *arg2 = (wxButton *) 0 ;
52351 void *argp1 = 0 ;
52352 int res1 = 0 ;
52353 void *argp2 = 0 ;
52354 int res2 = 0 ;
52355 PyObject * obj0 = 0 ;
52356 PyObject * obj1 = 0 ;
52357 char * kwnames[] = {
52358 (char *) "self",(char *) "button", NULL
52359 };
52360
52361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52363 if (!SWIG_IsOK(res1)) {
52364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52365 }
52366 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52368 if (!SWIG_IsOK(res2)) {
52369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52370 }
52371 arg2 = reinterpret_cast< wxButton * >(argp2);
52372 {
52373 PyThreadState* __tstate = wxPyBeginAllowThreads();
52374 (arg1)->SetNegativeButton(arg2);
52375 wxPyEndAllowThreads(__tstate);
52376 if (PyErr_Occurred()) SWIG_fail;
52377 }
52378 resultobj = SWIG_Py_Void();
52379 return resultobj;
52380 fail:
52381 return NULL;
52382 }
52383
52384
52385 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52386 PyObject *resultobj = 0;
52387 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52388 wxButton *arg2 = (wxButton *) 0 ;
52389 void *argp1 = 0 ;
52390 int res1 = 0 ;
52391 void *argp2 = 0 ;
52392 int res2 = 0 ;
52393 PyObject * obj0 = 0 ;
52394 PyObject * obj1 = 0 ;
52395 char * kwnames[] = {
52396 (char *) "self",(char *) "button", NULL
52397 };
52398
52399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52401 if (!SWIG_IsOK(res1)) {
52402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52403 }
52404 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52406 if (!SWIG_IsOK(res2)) {
52407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52408 }
52409 arg2 = reinterpret_cast< wxButton * >(argp2);
52410 {
52411 PyThreadState* __tstate = wxPyBeginAllowThreads();
52412 (arg1)->SetCancelButton(arg2);
52413 wxPyEndAllowThreads(__tstate);
52414 if (PyErr_Occurred()) SWIG_fail;
52415 }
52416 resultobj = SWIG_Py_Void();
52417 return resultobj;
52418 fail:
52419 return NULL;
52420 }
52421
52422
52423 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52424 PyObject *resultobj = 0;
52425 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52426 wxButton *result = 0 ;
52427 void *argp1 = 0 ;
52428 int res1 = 0 ;
52429 PyObject *swig_obj[1] ;
52430
52431 if (!args) SWIG_fail;
52432 swig_obj[0] = args;
52433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52434 if (!SWIG_IsOK(res1)) {
52435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52436 }
52437 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52438 {
52439 PyThreadState* __tstate = wxPyBeginAllowThreads();
52440 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52441 wxPyEndAllowThreads(__tstate);
52442 if (PyErr_Occurred()) SWIG_fail;
52443 }
52444 {
52445 resultobj = wxPyMake_wxObject(result, (bool)0);
52446 }
52447 return resultobj;
52448 fail:
52449 return NULL;
52450 }
52451
52452
52453 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52454 PyObject *resultobj = 0;
52455 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52456 wxButton *result = 0 ;
52457 void *argp1 = 0 ;
52458 int res1 = 0 ;
52459 PyObject *swig_obj[1] ;
52460
52461 if (!args) SWIG_fail;
52462 swig_obj[0] = args;
52463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52464 if (!SWIG_IsOK(res1)) {
52465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52466 }
52467 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52468 {
52469 PyThreadState* __tstate = wxPyBeginAllowThreads();
52470 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52471 wxPyEndAllowThreads(__tstate);
52472 if (PyErr_Occurred()) SWIG_fail;
52473 }
52474 {
52475 resultobj = wxPyMake_wxObject(result, (bool)0);
52476 }
52477 return resultobj;
52478 fail:
52479 return NULL;
52480 }
52481
52482
52483 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52484 PyObject *resultobj = 0;
52485 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52486 wxButton *result = 0 ;
52487 void *argp1 = 0 ;
52488 int res1 = 0 ;
52489 PyObject *swig_obj[1] ;
52490
52491 if (!args) SWIG_fail;
52492 swig_obj[0] = args;
52493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52496 }
52497 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52498 {
52499 PyThreadState* __tstate = wxPyBeginAllowThreads();
52500 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52501 wxPyEndAllowThreads(__tstate);
52502 if (PyErr_Occurred()) SWIG_fail;
52503 }
52504 {
52505 resultobj = wxPyMake_wxObject(result, (bool)0);
52506 }
52507 return resultobj;
52508 fail:
52509 return NULL;
52510 }
52511
52512
52513 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52514 PyObject *resultobj = 0;
52515 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52516 wxButton *result = 0 ;
52517 void *argp1 = 0 ;
52518 int res1 = 0 ;
52519 PyObject *swig_obj[1] ;
52520
52521 if (!args) SWIG_fail;
52522 swig_obj[0] = args;
52523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52524 if (!SWIG_IsOK(res1)) {
52525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52526 }
52527 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52528 {
52529 PyThreadState* __tstate = wxPyBeginAllowThreads();
52530 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52531 wxPyEndAllowThreads(__tstate);
52532 if (PyErr_Occurred()) SWIG_fail;
52533 }
52534 {
52535 resultobj = wxPyMake_wxObject(result, (bool)0);
52536 }
52537 return resultobj;
52538 fail:
52539 return NULL;
52540 }
52541
52542
52543 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52544 PyObject *resultobj = 0;
52545 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52546 wxButton *result = 0 ;
52547 void *argp1 = 0 ;
52548 int res1 = 0 ;
52549 PyObject *swig_obj[1] ;
52550
52551 if (!args) SWIG_fail;
52552 swig_obj[0] = args;
52553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52554 if (!SWIG_IsOK(res1)) {
52555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52556 }
52557 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52558 {
52559 PyThreadState* __tstate = wxPyBeginAllowThreads();
52560 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52561 wxPyEndAllowThreads(__tstate);
52562 if (PyErr_Occurred()) SWIG_fail;
52563 }
52564 {
52565 resultobj = wxPyMake_wxObject(result, (bool)0);
52566 }
52567 return resultobj;
52568 fail:
52569 return NULL;
52570 }
52571
52572
52573 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52574 PyObject *obj;
52575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52576 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52577 return SWIG_Py_Void();
52578 }
52579
52580 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52581 return SWIG_Python_InitShadowInstance(args);
52582 }
52583
52584 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52585 PyObject *resultobj = 0;
52586 int arg1 = (int) 0 ;
52587 int arg2 = (int) 0 ;
52588 wxGBPosition *result = 0 ;
52589 int val1 ;
52590 int ecode1 = 0 ;
52591 int val2 ;
52592 int ecode2 = 0 ;
52593 PyObject * obj0 = 0 ;
52594 PyObject * obj1 = 0 ;
52595 char * kwnames[] = {
52596 (char *) "row",(char *) "col", NULL
52597 };
52598
52599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52600 if (obj0) {
52601 ecode1 = SWIG_AsVal_int(obj0, &val1);
52602 if (!SWIG_IsOK(ecode1)) {
52603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52604 }
52605 arg1 = static_cast< int >(val1);
52606 }
52607 if (obj1) {
52608 ecode2 = SWIG_AsVal_int(obj1, &val2);
52609 if (!SWIG_IsOK(ecode2)) {
52610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52611 }
52612 arg2 = static_cast< int >(val2);
52613 }
52614 {
52615 PyThreadState* __tstate = wxPyBeginAllowThreads();
52616 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52617 wxPyEndAllowThreads(__tstate);
52618 if (PyErr_Occurred()) SWIG_fail;
52619 }
52620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52621 return resultobj;
52622 fail:
52623 return NULL;
52624 }
52625
52626
52627 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52628 PyObject *resultobj = 0;
52629 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52630 void *argp1 = 0 ;
52631 int res1 = 0 ;
52632 PyObject *swig_obj[1] ;
52633
52634 if (!args) SWIG_fail;
52635 swig_obj[0] = args;
52636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52637 if (!SWIG_IsOK(res1)) {
52638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52639 }
52640 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52641 {
52642 PyThreadState* __tstate = wxPyBeginAllowThreads();
52643 delete arg1;
52644
52645 wxPyEndAllowThreads(__tstate);
52646 if (PyErr_Occurred()) SWIG_fail;
52647 }
52648 resultobj = SWIG_Py_Void();
52649 return resultobj;
52650 fail:
52651 return NULL;
52652 }
52653
52654
52655 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52656 PyObject *resultobj = 0;
52657 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52658 int result;
52659 void *argp1 = 0 ;
52660 int res1 = 0 ;
52661 PyObject *swig_obj[1] ;
52662
52663 if (!args) SWIG_fail;
52664 swig_obj[0] = args;
52665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52666 if (!SWIG_IsOK(res1)) {
52667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52668 }
52669 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52670 {
52671 PyThreadState* __tstate = wxPyBeginAllowThreads();
52672 result = (int)((wxGBPosition const *)arg1)->GetRow();
52673 wxPyEndAllowThreads(__tstate);
52674 if (PyErr_Occurred()) SWIG_fail;
52675 }
52676 resultobj = SWIG_From_int(static_cast< int >(result));
52677 return resultobj;
52678 fail:
52679 return NULL;
52680 }
52681
52682
52683 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52684 PyObject *resultobj = 0;
52685 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52686 int result;
52687 void *argp1 = 0 ;
52688 int res1 = 0 ;
52689 PyObject *swig_obj[1] ;
52690
52691 if (!args) SWIG_fail;
52692 swig_obj[0] = args;
52693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52694 if (!SWIG_IsOK(res1)) {
52695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52696 }
52697 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52698 {
52699 PyThreadState* __tstate = wxPyBeginAllowThreads();
52700 result = (int)((wxGBPosition const *)arg1)->GetCol();
52701 wxPyEndAllowThreads(__tstate);
52702 if (PyErr_Occurred()) SWIG_fail;
52703 }
52704 resultobj = SWIG_From_int(static_cast< int >(result));
52705 return resultobj;
52706 fail:
52707 return NULL;
52708 }
52709
52710
52711 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52712 PyObject *resultobj = 0;
52713 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52714 int arg2 ;
52715 void *argp1 = 0 ;
52716 int res1 = 0 ;
52717 int val2 ;
52718 int ecode2 = 0 ;
52719 PyObject * obj0 = 0 ;
52720 PyObject * obj1 = 0 ;
52721 char * kwnames[] = {
52722 (char *) "self",(char *) "row", NULL
52723 };
52724
52725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52727 if (!SWIG_IsOK(res1)) {
52728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52729 }
52730 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52731 ecode2 = SWIG_AsVal_int(obj1, &val2);
52732 if (!SWIG_IsOK(ecode2)) {
52733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52734 }
52735 arg2 = static_cast< int >(val2);
52736 {
52737 PyThreadState* __tstate = wxPyBeginAllowThreads();
52738 (arg1)->SetRow(arg2);
52739 wxPyEndAllowThreads(__tstate);
52740 if (PyErr_Occurred()) SWIG_fail;
52741 }
52742 resultobj = SWIG_Py_Void();
52743 return resultobj;
52744 fail:
52745 return NULL;
52746 }
52747
52748
52749 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52750 PyObject *resultobj = 0;
52751 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52752 int arg2 ;
52753 void *argp1 = 0 ;
52754 int res1 = 0 ;
52755 int val2 ;
52756 int ecode2 = 0 ;
52757 PyObject * obj0 = 0 ;
52758 PyObject * obj1 = 0 ;
52759 char * kwnames[] = {
52760 (char *) "self",(char *) "col", NULL
52761 };
52762
52763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52765 if (!SWIG_IsOK(res1)) {
52766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52767 }
52768 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52769 ecode2 = SWIG_AsVal_int(obj1, &val2);
52770 if (!SWIG_IsOK(ecode2)) {
52771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52772 }
52773 arg2 = static_cast< int >(val2);
52774 {
52775 PyThreadState* __tstate = wxPyBeginAllowThreads();
52776 (arg1)->SetCol(arg2);
52777 wxPyEndAllowThreads(__tstate);
52778 if (PyErr_Occurred()) SWIG_fail;
52779 }
52780 resultobj = SWIG_Py_Void();
52781 return resultobj;
52782 fail:
52783 return NULL;
52784 }
52785
52786
52787 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52788 PyObject *resultobj = 0;
52789 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52790 PyObject *arg2 = (PyObject *) 0 ;
52791 bool result;
52792 void *argp1 = 0 ;
52793 int res1 = 0 ;
52794 PyObject * obj0 = 0 ;
52795 PyObject * obj1 = 0 ;
52796 char * kwnames[] = {
52797 (char *) "self",(char *) "other", NULL
52798 };
52799
52800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52802 if (!SWIG_IsOK(res1)) {
52803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52804 }
52805 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52806 arg2 = obj1;
52807 {
52808 result = (bool)wxGBPosition___eq__(arg1,arg2);
52809 if (PyErr_Occurred()) SWIG_fail;
52810 }
52811 {
52812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52813 }
52814 return resultobj;
52815 fail:
52816 return NULL;
52817 }
52818
52819
52820 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52821 PyObject *resultobj = 0;
52822 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52823 PyObject *arg2 = (PyObject *) 0 ;
52824 bool result;
52825 void *argp1 = 0 ;
52826 int res1 = 0 ;
52827 PyObject * obj0 = 0 ;
52828 PyObject * obj1 = 0 ;
52829 char * kwnames[] = {
52830 (char *) "self",(char *) "other", NULL
52831 };
52832
52833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52835 if (!SWIG_IsOK(res1)) {
52836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52837 }
52838 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52839 arg2 = obj1;
52840 {
52841 result = (bool)wxGBPosition___ne__(arg1,arg2);
52842 if (PyErr_Occurred()) SWIG_fail;
52843 }
52844 {
52845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52846 }
52847 return resultobj;
52848 fail:
52849 return NULL;
52850 }
52851
52852
52853 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52854 PyObject *resultobj = 0;
52855 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52856 int arg2 = (int) 0 ;
52857 int arg3 = (int) 0 ;
52858 void *argp1 = 0 ;
52859 int res1 = 0 ;
52860 int val2 ;
52861 int ecode2 = 0 ;
52862 int val3 ;
52863 int ecode3 = 0 ;
52864 PyObject * obj0 = 0 ;
52865 PyObject * obj1 = 0 ;
52866 PyObject * obj2 = 0 ;
52867 char * kwnames[] = {
52868 (char *) "self",(char *) "row",(char *) "col", NULL
52869 };
52870
52871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52873 if (!SWIG_IsOK(res1)) {
52874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52875 }
52876 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52877 if (obj1) {
52878 ecode2 = SWIG_AsVal_int(obj1, &val2);
52879 if (!SWIG_IsOK(ecode2)) {
52880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52881 }
52882 arg2 = static_cast< int >(val2);
52883 }
52884 if (obj2) {
52885 ecode3 = SWIG_AsVal_int(obj2, &val3);
52886 if (!SWIG_IsOK(ecode3)) {
52887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52888 }
52889 arg3 = static_cast< int >(val3);
52890 }
52891 {
52892 PyThreadState* __tstate = wxPyBeginAllowThreads();
52893 wxGBPosition_Set(arg1,arg2,arg3);
52894 wxPyEndAllowThreads(__tstate);
52895 if (PyErr_Occurred()) SWIG_fail;
52896 }
52897 resultobj = SWIG_Py_Void();
52898 return resultobj;
52899 fail:
52900 return NULL;
52901 }
52902
52903
52904 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52905 PyObject *resultobj = 0;
52906 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52907 PyObject *result = 0 ;
52908 void *argp1 = 0 ;
52909 int res1 = 0 ;
52910 PyObject *swig_obj[1] ;
52911
52912 if (!args) SWIG_fail;
52913 swig_obj[0] = args;
52914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52915 if (!SWIG_IsOK(res1)) {
52916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52917 }
52918 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52919 {
52920 PyThreadState* __tstate = wxPyBeginAllowThreads();
52921 result = (PyObject *)wxGBPosition_Get(arg1);
52922 wxPyEndAllowThreads(__tstate);
52923 if (PyErr_Occurred()) SWIG_fail;
52924 }
52925 resultobj = result;
52926 return resultobj;
52927 fail:
52928 return NULL;
52929 }
52930
52931
52932 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52933 PyObject *obj;
52934 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52935 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52936 return SWIG_Py_Void();
52937 }
52938
52939 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52940 return SWIG_Python_InitShadowInstance(args);
52941 }
52942
52943 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52944 PyObject *resultobj = 0;
52945 int arg1 = (int) 1 ;
52946 int arg2 = (int) 1 ;
52947 wxGBSpan *result = 0 ;
52948 int val1 ;
52949 int ecode1 = 0 ;
52950 int val2 ;
52951 int ecode2 = 0 ;
52952 PyObject * obj0 = 0 ;
52953 PyObject * obj1 = 0 ;
52954 char * kwnames[] = {
52955 (char *) "rowspan",(char *) "colspan", NULL
52956 };
52957
52958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52959 if (obj0) {
52960 ecode1 = SWIG_AsVal_int(obj0, &val1);
52961 if (!SWIG_IsOK(ecode1)) {
52962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52963 }
52964 arg1 = static_cast< int >(val1);
52965 }
52966 if (obj1) {
52967 ecode2 = SWIG_AsVal_int(obj1, &val2);
52968 if (!SWIG_IsOK(ecode2)) {
52969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52970 }
52971 arg2 = static_cast< int >(val2);
52972 }
52973 {
52974 PyThreadState* __tstate = wxPyBeginAllowThreads();
52975 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52976 wxPyEndAllowThreads(__tstate);
52977 if (PyErr_Occurred()) SWIG_fail;
52978 }
52979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52980 return resultobj;
52981 fail:
52982 return NULL;
52983 }
52984
52985
52986 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52987 PyObject *resultobj = 0;
52988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52989 void *argp1 = 0 ;
52990 int res1 = 0 ;
52991 PyObject *swig_obj[1] ;
52992
52993 if (!args) SWIG_fail;
52994 swig_obj[0] = args;
52995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52996 if (!SWIG_IsOK(res1)) {
52997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52998 }
52999 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53000 {
53001 PyThreadState* __tstate = wxPyBeginAllowThreads();
53002 delete arg1;
53003
53004 wxPyEndAllowThreads(__tstate);
53005 if (PyErr_Occurred()) SWIG_fail;
53006 }
53007 resultobj = SWIG_Py_Void();
53008 return resultobj;
53009 fail:
53010 return NULL;
53011 }
53012
53013
53014 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53015 PyObject *resultobj = 0;
53016 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53017 int result;
53018 void *argp1 = 0 ;
53019 int res1 = 0 ;
53020 PyObject *swig_obj[1] ;
53021
53022 if (!args) SWIG_fail;
53023 swig_obj[0] = args;
53024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53025 if (!SWIG_IsOK(res1)) {
53026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53027 }
53028 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53029 {
53030 PyThreadState* __tstate = wxPyBeginAllowThreads();
53031 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53032 wxPyEndAllowThreads(__tstate);
53033 if (PyErr_Occurred()) SWIG_fail;
53034 }
53035 resultobj = SWIG_From_int(static_cast< int >(result));
53036 return resultobj;
53037 fail:
53038 return NULL;
53039 }
53040
53041
53042 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53043 PyObject *resultobj = 0;
53044 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53045 int result;
53046 void *argp1 = 0 ;
53047 int res1 = 0 ;
53048 PyObject *swig_obj[1] ;
53049
53050 if (!args) SWIG_fail;
53051 swig_obj[0] = args;
53052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53053 if (!SWIG_IsOK(res1)) {
53054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53055 }
53056 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53057 {
53058 PyThreadState* __tstate = wxPyBeginAllowThreads();
53059 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53060 wxPyEndAllowThreads(__tstate);
53061 if (PyErr_Occurred()) SWIG_fail;
53062 }
53063 resultobj = SWIG_From_int(static_cast< int >(result));
53064 return resultobj;
53065 fail:
53066 return NULL;
53067 }
53068
53069
53070 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53071 PyObject *resultobj = 0;
53072 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53073 int arg2 ;
53074 void *argp1 = 0 ;
53075 int res1 = 0 ;
53076 int val2 ;
53077 int ecode2 = 0 ;
53078 PyObject * obj0 = 0 ;
53079 PyObject * obj1 = 0 ;
53080 char * kwnames[] = {
53081 (char *) "self",(char *) "rowspan", NULL
53082 };
53083
53084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53086 if (!SWIG_IsOK(res1)) {
53087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53088 }
53089 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53090 ecode2 = SWIG_AsVal_int(obj1, &val2);
53091 if (!SWIG_IsOK(ecode2)) {
53092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53093 }
53094 arg2 = static_cast< int >(val2);
53095 {
53096 PyThreadState* __tstate = wxPyBeginAllowThreads();
53097 (arg1)->SetRowspan(arg2);
53098 wxPyEndAllowThreads(__tstate);
53099 if (PyErr_Occurred()) SWIG_fail;
53100 }
53101 resultobj = SWIG_Py_Void();
53102 return resultobj;
53103 fail:
53104 return NULL;
53105 }
53106
53107
53108 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53109 PyObject *resultobj = 0;
53110 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53111 int arg2 ;
53112 void *argp1 = 0 ;
53113 int res1 = 0 ;
53114 int val2 ;
53115 int ecode2 = 0 ;
53116 PyObject * obj0 = 0 ;
53117 PyObject * obj1 = 0 ;
53118 char * kwnames[] = {
53119 (char *) "self",(char *) "colspan", NULL
53120 };
53121
53122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53124 if (!SWIG_IsOK(res1)) {
53125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53126 }
53127 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53128 ecode2 = SWIG_AsVal_int(obj1, &val2);
53129 if (!SWIG_IsOK(ecode2)) {
53130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53131 }
53132 arg2 = static_cast< int >(val2);
53133 {
53134 PyThreadState* __tstate = wxPyBeginAllowThreads();
53135 (arg1)->SetColspan(arg2);
53136 wxPyEndAllowThreads(__tstate);
53137 if (PyErr_Occurred()) SWIG_fail;
53138 }
53139 resultobj = SWIG_Py_Void();
53140 return resultobj;
53141 fail:
53142 return NULL;
53143 }
53144
53145
53146 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53147 PyObject *resultobj = 0;
53148 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53149 PyObject *arg2 = (PyObject *) 0 ;
53150 bool result;
53151 void *argp1 = 0 ;
53152 int res1 = 0 ;
53153 PyObject * obj0 = 0 ;
53154 PyObject * obj1 = 0 ;
53155 char * kwnames[] = {
53156 (char *) "self",(char *) "other", NULL
53157 };
53158
53159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53161 if (!SWIG_IsOK(res1)) {
53162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53163 }
53164 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53165 arg2 = obj1;
53166 {
53167 result = (bool)wxGBSpan___eq__(arg1,arg2);
53168 if (PyErr_Occurred()) SWIG_fail;
53169 }
53170 {
53171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53172 }
53173 return resultobj;
53174 fail:
53175 return NULL;
53176 }
53177
53178
53179 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53180 PyObject *resultobj = 0;
53181 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53182 PyObject *arg2 = (PyObject *) 0 ;
53183 bool result;
53184 void *argp1 = 0 ;
53185 int res1 = 0 ;
53186 PyObject * obj0 = 0 ;
53187 PyObject * obj1 = 0 ;
53188 char * kwnames[] = {
53189 (char *) "self",(char *) "other", NULL
53190 };
53191
53192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53194 if (!SWIG_IsOK(res1)) {
53195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53196 }
53197 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53198 arg2 = obj1;
53199 {
53200 result = (bool)wxGBSpan___ne__(arg1,arg2);
53201 if (PyErr_Occurred()) SWIG_fail;
53202 }
53203 {
53204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53205 }
53206 return resultobj;
53207 fail:
53208 return NULL;
53209 }
53210
53211
53212 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53213 PyObject *resultobj = 0;
53214 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53215 int arg2 = (int) 1 ;
53216 int arg3 = (int) 1 ;
53217 void *argp1 = 0 ;
53218 int res1 = 0 ;
53219 int val2 ;
53220 int ecode2 = 0 ;
53221 int val3 ;
53222 int ecode3 = 0 ;
53223 PyObject * obj0 = 0 ;
53224 PyObject * obj1 = 0 ;
53225 PyObject * obj2 = 0 ;
53226 char * kwnames[] = {
53227 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53228 };
53229
53230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53232 if (!SWIG_IsOK(res1)) {
53233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53234 }
53235 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53236 if (obj1) {
53237 ecode2 = SWIG_AsVal_int(obj1, &val2);
53238 if (!SWIG_IsOK(ecode2)) {
53239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53240 }
53241 arg2 = static_cast< int >(val2);
53242 }
53243 if (obj2) {
53244 ecode3 = SWIG_AsVal_int(obj2, &val3);
53245 if (!SWIG_IsOK(ecode3)) {
53246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53247 }
53248 arg3 = static_cast< int >(val3);
53249 }
53250 {
53251 PyThreadState* __tstate = wxPyBeginAllowThreads();
53252 wxGBSpan_Set(arg1,arg2,arg3);
53253 wxPyEndAllowThreads(__tstate);
53254 if (PyErr_Occurred()) SWIG_fail;
53255 }
53256 resultobj = SWIG_Py_Void();
53257 return resultobj;
53258 fail:
53259 return NULL;
53260 }
53261
53262
53263 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53264 PyObject *resultobj = 0;
53265 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53266 PyObject *result = 0 ;
53267 void *argp1 = 0 ;
53268 int res1 = 0 ;
53269 PyObject *swig_obj[1] ;
53270
53271 if (!args) SWIG_fail;
53272 swig_obj[0] = args;
53273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53274 if (!SWIG_IsOK(res1)) {
53275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53276 }
53277 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53278 {
53279 PyThreadState* __tstate = wxPyBeginAllowThreads();
53280 result = (PyObject *)wxGBSpan_Get(arg1);
53281 wxPyEndAllowThreads(__tstate);
53282 if (PyErr_Occurred()) SWIG_fail;
53283 }
53284 resultobj = result;
53285 return resultobj;
53286 fail:
53287 return NULL;
53288 }
53289
53290
53291 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53292 PyObject *obj;
53293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53294 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53295 return SWIG_Py_Void();
53296 }
53297
53298 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53299 return SWIG_Python_InitShadowInstance(args);
53300 }
53301
53302 SWIGINTERN int DefaultSpan_set(PyObject *) {
53303 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53304 return 1;
53305 }
53306
53307
53308 SWIGINTERN PyObject *DefaultSpan_get(void) {
53309 PyObject *pyobj = 0;
53310
53311 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53312 return pyobj;
53313 }
53314
53315
53316 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53317 PyObject *resultobj = 0;
53318 wxGBSizerItem *result = 0 ;
53319
53320 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53321 {
53322 PyThreadState* __tstate = wxPyBeginAllowThreads();
53323 result = (wxGBSizerItem *)new wxGBSizerItem();
53324 wxPyEndAllowThreads(__tstate);
53325 if (PyErr_Occurred()) SWIG_fail;
53326 }
53327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53328 return resultobj;
53329 fail:
53330 return NULL;
53331 }
53332
53333
53334 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53335 PyObject *resultobj = 0;
53336 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53337 void *argp1 = 0 ;
53338 int res1 = 0 ;
53339 PyObject *swig_obj[1] ;
53340
53341 if (!args) SWIG_fail;
53342 swig_obj[0] = args;
53343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53344 if (!SWIG_IsOK(res1)) {
53345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53346 }
53347 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53348 {
53349 PyThreadState* __tstate = wxPyBeginAllowThreads();
53350 delete arg1;
53351
53352 wxPyEndAllowThreads(__tstate);
53353 if (PyErr_Occurred()) SWIG_fail;
53354 }
53355 resultobj = SWIG_Py_Void();
53356 return resultobj;
53357 fail:
53358 return NULL;
53359 }
53360
53361
53362 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53363 PyObject *resultobj = 0;
53364 wxWindow *arg1 = (wxWindow *) 0 ;
53365 wxGBPosition *arg2 = 0 ;
53366 wxGBSpan *arg3 = 0 ;
53367 int arg4 ;
53368 int arg5 ;
53369 PyObject *arg6 = (PyObject *) NULL ;
53370 wxGBSizerItem *result = 0 ;
53371 void *argp1 = 0 ;
53372 int res1 = 0 ;
53373 wxGBPosition temp2 ;
53374 wxGBSpan temp3 ;
53375 int val4 ;
53376 int ecode4 = 0 ;
53377 int val5 ;
53378 int ecode5 = 0 ;
53379 PyObject * obj0 = 0 ;
53380 PyObject * obj1 = 0 ;
53381 PyObject * obj2 = 0 ;
53382 PyObject * obj3 = 0 ;
53383 PyObject * obj4 = 0 ;
53384 PyObject * obj5 = 0 ;
53385 char * kwnames[] = {
53386 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53387 };
53388
53389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53391 if (!SWIG_IsOK(res1)) {
53392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53393 }
53394 arg1 = reinterpret_cast< wxWindow * >(argp1);
53395 {
53396 arg2 = &temp2;
53397 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53398 }
53399 {
53400 arg3 = &temp3;
53401 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53402 }
53403 ecode4 = SWIG_AsVal_int(obj3, &val4);
53404 if (!SWIG_IsOK(ecode4)) {
53405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53406 }
53407 arg4 = static_cast< int >(val4);
53408 ecode5 = SWIG_AsVal_int(obj4, &val5);
53409 if (!SWIG_IsOK(ecode5)) {
53410 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53411 }
53412 arg5 = static_cast< int >(val5);
53413 if (obj5) {
53414 arg6 = obj5;
53415 }
53416 {
53417 PyThreadState* __tstate = wxPyBeginAllowThreads();
53418 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53419 wxPyEndAllowThreads(__tstate);
53420 if (PyErr_Occurred()) SWIG_fail;
53421 }
53422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53423 return resultobj;
53424 fail:
53425 return NULL;
53426 }
53427
53428
53429 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53430 PyObject *resultobj = 0;
53431 wxSizer *arg1 = (wxSizer *) 0 ;
53432 wxGBPosition *arg2 = 0 ;
53433 wxGBSpan *arg3 = 0 ;
53434 int arg4 ;
53435 int arg5 ;
53436 PyObject *arg6 = (PyObject *) NULL ;
53437 wxGBSizerItem *result = 0 ;
53438 int res1 = 0 ;
53439 wxGBPosition temp2 ;
53440 wxGBSpan temp3 ;
53441 int val4 ;
53442 int ecode4 = 0 ;
53443 int val5 ;
53444 int ecode5 = 0 ;
53445 PyObject * obj0 = 0 ;
53446 PyObject * obj1 = 0 ;
53447 PyObject * obj2 = 0 ;
53448 PyObject * obj3 = 0 ;
53449 PyObject * obj4 = 0 ;
53450 PyObject * obj5 = 0 ;
53451 char * kwnames[] = {
53452 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53453 };
53454
53455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53456 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53457 if (!SWIG_IsOK(res1)) {
53458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53459 }
53460 {
53461 arg2 = &temp2;
53462 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53463 }
53464 {
53465 arg3 = &temp3;
53466 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53467 }
53468 ecode4 = SWIG_AsVal_int(obj3, &val4);
53469 if (!SWIG_IsOK(ecode4)) {
53470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53471 }
53472 arg4 = static_cast< int >(val4);
53473 ecode5 = SWIG_AsVal_int(obj4, &val5);
53474 if (!SWIG_IsOK(ecode5)) {
53475 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53476 }
53477 arg5 = static_cast< int >(val5);
53478 if (obj5) {
53479 arg6 = obj5;
53480 }
53481 {
53482 PyThreadState* __tstate = wxPyBeginAllowThreads();
53483 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53484 wxPyEndAllowThreads(__tstate);
53485 if (PyErr_Occurred()) SWIG_fail;
53486 }
53487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53488 return resultobj;
53489 fail:
53490 return NULL;
53491 }
53492
53493
53494 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53495 PyObject *resultobj = 0;
53496 int arg1 ;
53497 int arg2 ;
53498 wxGBPosition *arg3 = 0 ;
53499 wxGBSpan *arg4 = 0 ;
53500 int arg5 ;
53501 int arg6 ;
53502 PyObject *arg7 = (PyObject *) NULL ;
53503 wxGBSizerItem *result = 0 ;
53504 int val1 ;
53505 int ecode1 = 0 ;
53506 int val2 ;
53507 int ecode2 = 0 ;
53508 wxGBPosition temp3 ;
53509 wxGBSpan temp4 ;
53510 int val5 ;
53511 int ecode5 = 0 ;
53512 int val6 ;
53513 int ecode6 = 0 ;
53514 PyObject * obj0 = 0 ;
53515 PyObject * obj1 = 0 ;
53516 PyObject * obj2 = 0 ;
53517 PyObject * obj3 = 0 ;
53518 PyObject * obj4 = 0 ;
53519 PyObject * obj5 = 0 ;
53520 PyObject * obj6 = 0 ;
53521 char * kwnames[] = {
53522 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53523 };
53524
53525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53526 ecode1 = SWIG_AsVal_int(obj0, &val1);
53527 if (!SWIG_IsOK(ecode1)) {
53528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53529 }
53530 arg1 = static_cast< int >(val1);
53531 ecode2 = SWIG_AsVal_int(obj1, &val2);
53532 if (!SWIG_IsOK(ecode2)) {
53533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53534 }
53535 arg2 = static_cast< int >(val2);
53536 {
53537 arg3 = &temp3;
53538 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53539 }
53540 {
53541 arg4 = &temp4;
53542 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53543 }
53544 ecode5 = SWIG_AsVal_int(obj4, &val5);
53545 if (!SWIG_IsOK(ecode5)) {
53546 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53547 }
53548 arg5 = static_cast< int >(val5);
53549 ecode6 = SWIG_AsVal_int(obj5, &val6);
53550 if (!SWIG_IsOK(ecode6)) {
53551 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53552 }
53553 arg6 = static_cast< int >(val6);
53554 if (obj6) {
53555 arg7 = obj6;
53556 }
53557 {
53558 PyThreadState* __tstate = wxPyBeginAllowThreads();
53559 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53560 wxPyEndAllowThreads(__tstate);
53561 if (PyErr_Occurred()) SWIG_fail;
53562 }
53563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53564 return resultobj;
53565 fail:
53566 return NULL;
53567 }
53568
53569
53570 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53571 PyObject *resultobj = 0;
53572 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53573 wxGBPosition result;
53574 void *argp1 = 0 ;
53575 int res1 = 0 ;
53576 PyObject *swig_obj[1] ;
53577
53578 if (!args) SWIG_fail;
53579 swig_obj[0] = args;
53580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53581 if (!SWIG_IsOK(res1)) {
53582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53583 }
53584 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53585 {
53586 PyThreadState* __tstate = wxPyBeginAllowThreads();
53587 result = ((wxGBSizerItem const *)arg1)->GetPos();
53588 wxPyEndAllowThreads(__tstate);
53589 if (PyErr_Occurred()) SWIG_fail;
53590 }
53591 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53592 return resultobj;
53593 fail:
53594 return NULL;
53595 }
53596
53597
53598 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53599 PyObject *resultobj = 0;
53600 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53601 wxGBSpan result;
53602 void *argp1 = 0 ;
53603 int res1 = 0 ;
53604 PyObject *swig_obj[1] ;
53605
53606 if (!args) SWIG_fail;
53607 swig_obj[0] = args;
53608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53609 if (!SWIG_IsOK(res1)) {
53610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53611 }
53612 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53613 {
53614 PyThreadState* __tstate = wxPyBeginAllowThreads();
53615 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53616 wxPyEndAllowThreads(__tstate);
53617 if (PyErr_Occurred()) SWIG_fail;
53618 }
53619 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53620 return resultobj;
53621 fail:
53622 return NULL;
53623 }
53624
53625
53626 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53627 PyObject *resultobj = 0;
53628 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53629 wxGBPosition *arg2 = 0 ;
53630 bool result;
53631 void *argp1 = 0 ;
53632 int res1 = 0 ;
53633 wxGBPosition temp2 ;
53634 PyObject * obj0 = 0 ;
53635 PyObject * obj1 = 0 ;
53636 char * kwnames[] = {
53637 (char *) "self",(char *) "pos", NULL
53638 };
53639
53640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53642 if (!SWIG_IsOK(res1)) {
53643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53644 }
53645 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53646 {
53647 arg2 = &temp2;
53648 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53649 }
53650 {
53651 PyThreadState* __tstate = wxPyBeginAllowThreads();
53652 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53653 wxPyEndAllowThreads(__tstate);
53654 if (PyErr_Occurred()) SWIG_fail;
53655 }
53656 {
53657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53658 }
53659 return resultobj;
53660 fail:
53661 return NULL;
53662 }
53663
53664
53665 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53666 PyObject *resultobj = 0;
53667 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53668 wxGBSpan *arg2 = 0 ;
53669 bool result;
53670 void *argp1 = 0 ;
53671 int res1 = 0 ;
53672 wxGBSpan temp2 ;
53673 PyObject * obj0 = 0 ;
53674 PyObject * obj1 = 0 ;
53675 char * kwnames[] = {
53676 (char *) "self",(char *) "span", NULL
53677 };
53678
53679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53681 if (!SWIG_IsOK(res1)) {
53682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53683 }
53684 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53685 {
53686 arg2 = &temp2;
53687 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53688 }
53689 {
53690 PyThreadState* __tstate = wxPyBeginAllowThreads();
53691 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53692 wxPyEndAllowThreads(__tstate);
53693 if (PyErr_Occurred()) SWIG_fail;
53694 }
53695 {
53696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53697 }
53698 return resultobj;
53699 fail:
53700 return NULL;
53701 }
53702
53703
53704 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53705 PyObject *resultobj = 0;
53706 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53707 wxGBSizerItem *arg2 = 0 ;
53708 bool result;
53709 void *argp1 = 0 ;
53710 int res1 = 0 ;
53711 void *argp2 = 0 ;
53712 int res2 = 0 ;
53713 PyObject * obj0 = 0 ;
53714 PyObject * obj1 = 0 ;
53715 char * kwnames[] = {
53716 (char *) "self",(char *) "other", NULL
53717 };
53718
53719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53721 if (!SWIG_IsOK(res1)) {
53722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53723 }
53724 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53726 if (!SWIG_IsOK(res2)) {
53727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53728 }
53729 if (!argp2) {
53730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53731 }
53732 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53733 {
53734 PyThreadState* __tstate = wxPyBeginAllowThreads();
53735 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53736 wxPyEndAllowThreads(__tstate);
53737 if (PyErr_Occurred()) SWIG_fail;
53738 }
53739 {
53740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53741 }
53742 return resultobj;
53743 fail:
53744 return NULL;
53745 }
53746
53747
53748 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53749 PyObject *resultobj = 0;
53750 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53751 wxGBPosition *arg2 = 0 ;
53752 wxGBSpan *arg3 = 0 ;
53753 bool result;
53754 void *argp1 = 0 ;
53755 int res1 = 0 ;
53756 wxGBPosition temp2 ;
53757 wxGBSpan temp3 ;
53758 PyObject * obj0 = 0 ;
53759 PyObject * obj1 = 0 ;
53760 PyObject * obj2 = 0 ;
53761 char * kwnames[] = {
53762 (char *) "self",(char *) "pos",(char *) "span", NULL
53763 };
53764
53765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53767 if (!SWIG_IsOK(res1)) {
53768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53769 }
53770 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53771 {
53772 arg2 = &temp2;
53773 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53774 }
53775 {
53776 arg3 = &temp3;
53777 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53778 }
53779 {
53780 PyThreadState* __tstate = wxPyBeginAllowThreads();
53781 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53782 wxPyEndAllowThreads(__tstate);
53783 if (PyErr_Occurred()) SWIG_fail;
53784 }
53785 {
53786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53787 }
53788 return resultobj;
53789 fail:
53790 return NULL;
53791 }
53792
53793
53794 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53795 PyObject *resultobj = 0;
53796 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53797 wxGBPosition result;
53798 void *argp1 = 0 ;
53799 int res1 = 0 ;
53800 PyObject *swig_obj[1] ;
53801
53802 if (!args) SWIG_fail;
53803 swig_obj[0] = args;
53804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53805 if (!SWIG_IsOK(res1)) {
53806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53807 }
53808 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53809 {
53810 PyThreadState* __tstate = wxPyBeginAllowThreads();
53811 result = wxGBSizerItem_GetEndPos(arg1);
53812 wxPyEndAllowThreads(__tstate);
53813 if (PyErr_Occurred()) SWIG_fail;
53814 }
53815 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53816 return resultobj;
53817 fail:
53818 return NULL;
53819 }
53820
53821
53822 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53823 PyObject *resultobj = 0;
53824 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53825 wxGridBagSizer *result = 0 ;
53826 void *argp1 = 0 ;
53827 int res1 = 0 ;
53828 PyObject *swig_obj[1] ;
53829
53830 if (!args) SWIG_fail;
53831 swig_obj[0] = args;
53832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53833 if (!SWIG_IsOK(res1)) {
53834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53835 }
53836 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53837 {
53838 PyThreadState* __tstate = wxPyBeginAllowThreads();
53839 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53840 wxPyEndAllowThreads(__tstate);
53841 if (PyErr_Occurred()) SWIG_fail;
53842 }
53843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53844 return resultobj;
53845 fail:
53846 return NULL;
53847 }
53848
53849
53850 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53851 PyObject *resultobj = 0;
53852 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53853 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53854 void *argp1 = 0 ;
53855 int res1 = 0 ;
53856 void *argp2 = 0 ;
53857 int res2 = 0 ;
53858 PyObject * obj0 = 0 ;
53859 PyObject * obj1 = 0 ;
53860 char * kwnames[] = {
53861 (char *) "self",(char *) "sizer", NULL
53862 };
53863
53864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53866 if (!SWIG_IsOK(res1)) {
53867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53868 }
53869 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53871 if (!SWIG_IsOK(res2)) {
53872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53873 }
53874 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53875 {
53876 PyThreadState* __tstate = wxPyBeginAllowThreads();
53877 (arg1)->SetGBSizer(arg2);
53878 wxPyEndAllowThreads(__tstate);
53879 if (PyErr_Occurred()) SWIG_fail;
53880 }
53881 resultobj = SWIG_Py_Void();
53882 return resultobj;
53883 fail:
53884 return NULL;
53885 }
53886
53887
53888 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53889 PyObject *obj;
53890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53891 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53892 return SWIG_Py_Void();
53893 }
53894
53895 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53896 return SWIG_Python_InitShadowInstance(args);
53897 }
53898
53899 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53900 PyObject *resultobj = 0;
53901 int arg1 = (int) 0 ;
53902 int arg2 = (int) 0 ;
53903 wxGridBagSizer *result = 0 ;
53904 int val1 ;
53905 int ecode1 = 0 ;
53906 int val2 ;
53907 int ecode2 = 0 ;
53908 PyObject * obj0 = 0 ;
53909 PyObject * obj1 = 0 ;
53910 char * kwnames[] = {
53911 (char *) "vgap",(char *) "hgap", NULL
53912 };
53913
53914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53915 if (obj0) {
53916 ecode1 = SWIG_AsVal_int(obj0, &val1);
53917 if (!SWIG_IsOK(ecode1)) {
53918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53919 }
53920 arg1 = static_cast< int >(val1);
53921 }
53922 if (obj1) {
53923 ecode2 = SWIG_AsVal_int(obj1, &val2);
53924 if (!SWIG_IsOK(ecode2)) {
53925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53926 }
53927 arg2 = static_cast< int >(val2);
53928 }
53929 {
53930 PyThreadState* __tstate = wxPyBeginAllowThreads();
53931 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53932 wxPyEndAllowThreads(__tstate);
53933 if (PyErr_Occurred()) SWIG_fail;
53934 }
53935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53936 return resultobj;
53937 fail:
53938 return NULL;
53939 }
53940
53941
53942 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53943 PyObject *resultobj = 0;
53944 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53945 PyObject *arg2 = (PyObject *) 0 ;
53946 wxGBPosition *arg3 = 0 ;
53947 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53948 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53949 int arg5 = (int) 0 ;
53950 int arg6 = (int) 0 ;
53951 PyObject *arg7 = (PyObject *) NULL ;
53952 wxGBSizerItem *result = 0 ;
53953 void *argp1 = 0 ;
53954 int res1 = 0 ;
53955 wxGBPosition temp3 ;
53956 wxGBSpan temp4 ;
53957 int val5 ;
53958 int ecode5 = 0 ;
53959 int val6 ;
53960 int ecode6 = 0 ;
53961 PyObject * obj0 = 0 ;
53962 PyObject * obj1 = 0 ;
53963 PyObject * obj2 = 0 ;
53964 PyObject * obj3 = 0 ;
53965 PyObject * obj4 = 0 ;
53966 PyObject * obj5 = 0 ;
53967 PyObject * obj6 = 0 ;
53968 char * kwnames[] = {
53969 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53970 };
53971
53972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53974 if (!SWIG_IsOK(res1)) {
53975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53976 }
53977 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53978 arg2 = obj1;
53979 {
53980 arg3 = &temp3;
53981 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53982 }
53983 if (obj3) {
53984 {
53985 arg4 = &temp4;
53986 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53987 }
53988 }
53989 if (obj4) {
53990 ecode5 = SWIG_AsVal_int(obj4, &val5);
53991 if (!SWIG_IsOK(ecode5)) {
53992 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53993 }
53994 arg5 = static_cast< int >(val5);
53995 }
53996 if (obj5) {
53997 ecode6 = SWIG_AsVal_int(obj5, &val6);
53998 if (!SWIG_IsOK(ecode6)) {
53999 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
54000 }
54001 arg6 = static_cast< int >(val6);
54002 }
54003 if (obj6) {
54004 arg7 = obj6;
54005 }
54006 {
54007 PyThreadState* __tstate = wxPyBeginAllowThreads();
54008 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54009 wxPyEndAllowThreads(__tstate);
54010 if (PyErr_Occurred()) SWIG_fail;
54011 }
54012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54013 return resultobj;
54014 fail:
54015 return NULL;
54016 }
54017
54018
54019 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54020 PyObject *resultobj = 0;
54021 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54022 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54023 wxGBSizerItem *result = 0 ;
54024 void *argp1 = 0 ;
54025 int res1 = 0 ;
54026 int res2 = 0 ;
54027 PyObject * obj0 = 0 ;
54028 PyObject * obj1 = 0 ;
54029 char * kwnames[] = {
54030 (char *) "self",(char *) "item", NULL
54031 };
54032
54033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54035 if (!SWIG_IsOK(res1)) {
54036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54037 }
54038 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54039 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54040 if (!SWIG_IsOK(res2)) {
54041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54042 }
54043 {
54044 PyThreadState* __tstate = wxPyBeginAllowThreads();
54045 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54046 wxPyEndAllowThreads(__tstate);
54047 if (PyErr_Occurred()) SWIG_fail;
54048 }
54049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54050 return resultobj;
54051 fail:
54052 return NULL;
54053 }
54054
54055
54056 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54057 PyObject *resultobj = 0;
54058 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54059 int arg2 ;
54060 int arg3 ;
54061 wxSize result;
54062 void *argp1 = 0 ;
54063 int res1 = 0 ;
54064 int val2 ;
54065 int ecode2 = 0 ;
54066 int val3 ;
54067 int ecode3 = 0 ;
54068 PyObject * obj0 = 0 ;
54069 PyObject * obj1 = 0 ;
54070 PyObject * obj2 = 0 ;
54071 char * kwnames[] = {
54072 (char *) "self",(char *) "row",(char *) "col", NULL
54073 };
54074
54075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54077 if (!SWIG_IsOK(res1)) {
54078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54079 }
54080 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54081 ecode2 = SWIG_AsVal_int(obj1, &val2);
54082 if (!SWIG_IsOK(ecode2)) {
54083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54084 }
54085 arg2 = static_cast< int >(val2);
54086 ecode3 = SWIG_AsVal_int(obj2, &val3);
54087 if (!SWIG_IsOK(ecode3)) {
54088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54089 }
54090 arg3 = static_cast< int >(val3);
54091 {
54092 PyThreadState* __tstate = wxPyBeginAllowThreads();
54093 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54094 wxPyEndAllowThreads(__tstate);
54095 if (PyErr_Occurred()) SWIG_fail;
54096 }
54097 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54098 return resultobj;
54099 fail:
54100 return NULL;
54101 }
54102
54103
54104 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54105 PyObject *resultobj = 0;
54106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54107 wxSize result;
54108 void *argp1 = 0 ;
54109 int res1 = 0 ;
54110 PyObject *swig_obj[1] ;
54111
54112 if (!args) SWIG_fail;
54113 swig_obj[0] = args;
54114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54115 if (!SWIG_IsOK(res1)) {
54116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54117 }
54118 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54119 {
54120 PyThreadState* __tstate = wxPyBeginAllowThreads();
54121 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54122 wxPyEndAllowThreads(__tstate);
54123 if (PyErr_Occurred()) SWIG_fail;
54124 }
54125 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54126 return resultobj;
54127 fail:
54128 return NULL;
54129 }
54130
54131
54132 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54133 PyObject *resultobj = 0;
54134 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54135 wxSize *arg2 = 0 ;
54136 void *argp1 = 0 ;
54137 int res1 = 0 ;
54138 wxSize temp2 ;
54139 PyObject * obj0 = 0 ;
54140 PyObject * obj1 = 0 ;
54141 char * kwnames[] = {
54142 (char *) "self",(char *) "sz", NULL
54143 };
54144
54145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54147 if (!SWIG_IsOK(res1)) {
54148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54149 }
54150 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54151 {
54152 arg2 = &temp2;
54153 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54154 }
54155 {
54156 PyThreadState* __tstate = wxPyBeginAllowThreads();
54157 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54158 wxPyEndAllowThreads(__tstate);
54159 if (PyErr_Occurred()) SWIG_fail;
54160 }
54161 resultobj = SWIG_Py_Void();
54162 return resultobj;
54163 fail:
54164 return NULL;
54165 }
54166
54167
54168 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54169 PyObject *resultobj = 0;
54170 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54171 wxWindow *arg2 = (wxWindow *) 0 ;
54172 wxGBPosition result;
54173 void *argp1 = 0 ;
54174 int res1 = 0 ;
54175 void *argp2 = 0 ;
54176 int res2 = 0 ;
54177
54178 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54180 if (!SWIG_IsOK(res1)) {
54181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54182 }
54183 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54184 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54185 if (!SWIG_IsOK(res2)) {
54186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54187 }
54188 arg2 = reinterpret_cast< wxWindow * >(argp2);
54189 {
54190 PyThreadState* __tstate = wxPyBeginAllowThreads();
54191 result = (arg1)->GetItemPosition(arg2);
54192 wxPyEndAllowThreads(__tstate);
54193 if (PyErr_Occurred()) SWIG_fail;
54194 }
54195 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54196 return resultobj;
54197 fail:
54198 return NULL;
54199 }
54200
54201
54202 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54203 PyObject *resultobj = 0;
54204 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54205 wxSizer *arg2 = (wxSizer *) 0 ;
54206 wxGBPosition result;
54207 void *argp1 = 0 ;
54208 int res1 = 0 ;
54209 void *argp2 = 0 ;
54210 int res2 = 0 ;
54211
54212 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54214 if (!SWIG_IsOK(res1)) {
54215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54216 }
54217 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54218 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54219 if (!SWIG_IsOK(res2)) {
54220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54221 }
54222 arg2 = reinterpret_cast< wxSizer * >(argp2);
54223 {
54224 PyThreadState* __tstate = wxPyBeginAllowThreads();
54225 result = (arg1)->GetItemPosition(arg2);
54226 wxPyEndAllowThreads(__tstate);
54227 if (PyErr_Occurred()) SWIG_fail;
54228 }
54229 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54230 return resultobj;
54231 fail:
54232 return NULL;
54233 }
54234
54235
54236 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54237 PyObject *resultobj = 0;
54238 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54239 size_t arg2 ;
54240 wxGBPosition result;
54241 void *argp1 = 0 ;
54242 int res1 = 0 ;
54243 size_t val2 ;
54244 int ecode2 = 0 ;
54245
54246 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54248 if (!SWIG_IsOK(res1)) {
54249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54250 }
54251 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54252 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54253 if (!SWIG_IsOK(ecode2)) {
54254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54255 }
54256 arg2 = static_cast< size_t >(val2);
54257 {
54258 PyThreadState* __tstate = wxPyBeginAllowThreads();
54259 result = (arg1)->GetItemPosition(arg2);
54260 wxPyEndAllowThreads(__tstate);
54261 if (PyErr_Occurred()) SWIG_fail;
54262 }
54263 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54264 return resultobj;
54265 fail:
54266 return NULL;
54267 }
54268
54269
54270 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54271 int argc;
54272 PyObject *argv[3];
54273
54274 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54275 --argc;
54276 if (argc == 2) {
54277 int _v = 0;
54278 {
54279 void *vptr = 0;
54280 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54281 _v = SWIG_CheckState(res);
54282 }
54283 if (!_v) goto check_1;
54284 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54285 }
54286 check_1:
54287
54288 if (argc == 2) {
54289 int _v = 0;
54290 {
54291 void *vptr = 0;
54292 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54293 _v = SWIG_CheckState(res);
54294 }
54295 if (!_v) goto check_2;
54296 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54297 }
54298 check_2:
54299
54300 if (argc == 2) {
54301 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54302 }
54303
54304 fail:
54305 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54306 return NULL;
54307 }
54308
54309
54310 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54311 PyObject *resultobj = 0;
54312 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54313 wxWindow *arg2 = (wxWindow *) 0 ;
54314 wxGBPosition *arg3 = 0 ;
54315 bool result;
54316 void *argp1 = 0 ;
54317 int res1 = 0 ;
54318 void *argp2 = 0 ;
54319 int res2 = 0 ;
54320 wxGBPosition temp3 ;
54321
54322 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54324 if (!SWIG_IsOK(res1)) {
54325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54326 }
54327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54328 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54329 if (!SWIG_IsOK(res2)) {
54330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54331 }
54332 arg2 = reinterpret_cast< wxWindow * >(argp2);
54333 {
54334 arg3 = &temp3;
54335 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54336 }
54337 {
54338 PyThreadState* __tstate = wxPyBeginAllowThreads();
54339 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54340 wxPyEndAllowThreads(__tstate);
54341 if (PyErr_Occurred()) SWIG_fail;
54342 }
54343 {
54344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54345 }
54346 return resultobj;
54347 fail:
54348 return NULL;
54349 }
54350
54351
54352 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54353 PyObject *resultobj = 0;
54354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54355 wxSizer *arg2 = (wxSizer *) 0 ;
54356 wxGBPosition *arg3 = 0 ;
54357 bool result;
54358 void *argp1 = 0 ;
54359 int res1 = 0 ;
54360 void *argp2 = 0 ;
54361 int res2 = 0 ;
54362 wxGBPosition temp3 ;
54363
54364 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54366 if (!SWIG_IsOK(res1)) {
54367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54368 }
54369 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54370 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54371 if (!SWIG_IsOK(res2)) {
54372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54373 }
54374 arg2 = reinterpret_cast< wxSizer * >(argp2);
54375 {
54376 arg3 = &temp3;
54377 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54378 }
54379 {
54380 PyThreadState* __tstate = wxPyBeginAllowThreads();
54381 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54382 wxPyEndAllowThreads(__tstate);
54383 if (PyErr_Occurred()) SWIG_fail;
54384 }
54385 {
54386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54387 }
54388 return resultobj;
54389 fail:
54390 return NULL;
54391 }
54392
54393
54394 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54395 PyObject *resultobj = 0;
54396 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54397 size_t arg2 ;
54398 wxGBPosition *arg3 = 0 ;
54399 bool result;
54400 void *argp1 = 0 ;
54401 int res1 = 0 ;
54402 size_t val2 ;
54403 int ecode2 = 0 ;
54404 wxGBPosition temp3 ;
54405
54406 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54408 if (!SWIG_IsOK(res1)) {
54409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54410 }
54411 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54412 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54413 if (!SWIG_IsOK(ecode2)) {
54414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54415 }
54416 arg2 = static_cast< size_t >(val2);
54417 {
54418 arg3 = &temp3;
54419 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54420 }
54421 {
54422 PyThreadState* __tstate = wxPyBeginAllowThreads();
54423 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54424 wxPyEndAllowThreads(__tstate);
54425 if (PyErr_Occurred()) SWIG_fail;
54426 }
54427 {
54428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54429 }
54430 return resultobj;
54431 fail:
54432 return NULL;
54433 }
54434
54435
54436 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54437 int argc;
54438 PyObject *argv[4];
54439
54440 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54441 --argc;
54442 if (argc == 3) {
54443 int _v = 0;
54444 {
54445 void *vptr = 0;
54446 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54447 _v = SWIG_CheckState(res);
54448 }
54449 if (!_v) goto check_1;
54450 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54451 }
54452 check_1:
54453
54454 if (argc == 3) {
54455 int _v = 0;
54456 {
54457 void *vptr = 0;
54458 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54459 _v = SWIG_CheckState(res);
54460 }
54461 if (!_v) goto check_2;
54462 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54463 }
54464 check_2:
54465
54466 if (argc == 3) {
54467 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54468 }
54469
54470 fail:
54471 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54472 return NULL;
54473 }
54474
54475
54476 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54477 PyObject *resultobj = 0;
54478 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54479 wxWindow *arg2 = (wxWindow *) 0 ;
54480 wxGBSpan result;
54481 void *argp1 = 0 ;
54482 int res1 = 0 ;
54483 void *argp2 = 0 ;
54484 int res2 = 0 ;
54485
54486 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54488 if (!SWIG_IsOK(res1)) {
54489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54490 }
54491 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54492 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54493 if (!SWIG_IsOK(res2)) {
54494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54495 }
54496 arg2 = reinterpret_cast< wxWindow * >(argp2);
54497 {
54498 PyThreadState* __tstate = wxPyBeginAllowThreads();
54499 result = (arg1)->GetItemSpan(arg2);
54500 wxPyEndAllowThreads(__tstate);
54501 if (PyErr_Occurred()) SWIG_fail;
54502 }
54503 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54504 return resultobj;
54505 fail:
54506 return NULL;
54507 }
54508
54509
54510 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54511 PyObject *resultobj = 0;
54512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54513 wxSizer *arg2 = (wxSizer *) 0 ;
54514 wxGBSpan result;
54515 void *argp1 = 0 ;
54516 int res1 = 0 ;
54517 void *argp2 = 0 ;
54518 int res2 = 0 ;
54519
54520 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54522 if (!SWIG_IsOK(res1)) {
54523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54524 }
54525 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54526 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54527 if (!SWIG_IsOK(res2)) {
54528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54529 }
54530 arg2 = reinterpret_cast< wxSizer * >(argp2);
54531 {
54532 PyThreadState* __tstate = wxPyBeginAllowThreads();
54533 result = (arg1)->GetItemSpan(arg2);
54534 wxPyEndAllowThreads(__tstate);
54535 if (PyErr_Occurred()) SWIG_fail;
54536 }
54537 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54538 return resultobj;
54539 fail:
54540 return NULL;
54541 }
54542
54543
54544 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54545 PyObject *resultobj = 0;
54546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54547 size_t arg2 ;
54548 wxGBSpan result;
54549 void *argp1 = 0 ;
54550 int res1 = 0 ;
54551 size_t val2 ;
54552 int ecode2 = 0 ;
54553
54554 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54556 if (!SWIG_IsOK(res1)) {
54557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54558 }
54559 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54560 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54561 if (!SWIG_IsOK(ecode2)) {
54562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54563 }
54564 arg2 = static_cast< size_t >(val2);
54565 {
54566 PyThreadState* __tstate = wxPyBeginAllowThreads();
54567 result = (arg1)->GetItemSpan(arg2);
54568 wxPyEndAllowThreads(__tstate);
54569 if (PyErr_Occurred()) SWIG_fail;
54570 }
54571 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54572 return resultobj;
54573 fail:
54574 return NULL;
54575 }
54576
54577
54578 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54579 int argc;
54580 PyObject *argv[3];
54581
54582 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54583 --argc;
54584 if (argc == 2) {
54585 int _v = 0;
54586 {
54587 void *vptr = 0;
54588 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54589 _v = SWIG_CheckState(res);
54590 }
54591 if (!_v) goto check_1;
54592 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54593 }
54594 check_1:
54595
54596 if (argc == 2) {
54597 int _v = 0;
54598 {
54599 void *vptr = 0;
54600 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54601 _v = SWIG_CheckState(res);
54602 }
54603 if (!_v) goto check_2;
54604 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54605 }
54606 check_2:
54607
54608 if (argc == 2) {
54609 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54610 }
54611
54612 fail:
54613 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54614 return NULL;
54615 }
54616
54617
54618 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54619 PyObject *resultobj = 0;
54620 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54621 wxWindow *arg2 = (wxWindow *) 0 ;
54622 wxGBSpan *arg3 = 0 ;
54623 bool result;
54624 void *argp1 = 0 ;
54625 int res1 = 0 ;
54626 void *argp2 = 0 ;
54627 int res2 = 0 ;
54628 wxGBSpan temp3 ;
54629
54630 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54632 if (!SWIG_IsOK(res1)) {
54633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54634 }
54635 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54636 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54637 if (!SWIG_IsOK(res2)) {
54638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54639 }
54640 arg2 = reinterpret_cast< wxWindow * >(argp2);
54641 {
54642 arg3 = &temp3;
54643 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54644 }
54645 {
54646 PyThreadState* __tstate = wxPyBeginAllowThreads();
54647 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54648 wxPyEndAllowThreads(__tstate);
54649 if (PyErr_Occurred()) SWIG_fail;
54650 }
54651 {
54652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54653 }
54654 return resultobj;
54655 fail:
54656 return NULL;
54657 }
54658
54659
54660 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54661 PyObject *resultobj = 0;
54662 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54663 wxSizer *arg2 = (wxSizer *) 0 ;
54664 wxGBSpan *arg3 = 0 ;
54665 bool result;
54666 void *argp1 = 0 ;
54667 int res1 = 0 ;
54668 void *argp2 = 0 ;
54669 int res2 = 0 ;
54670 wxGBSpan temp3 ;
54671
54672 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54674 if (!SWIG_IsOK(res1)) {
54675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54676 }
54677 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54678 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54679 if (!SWIG_IsOK(res2)) {
54680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54681 }
54682 arg2 = reinterpret_cast< wxSizer * >(argp2);
54683 {
54684 arg3 = &temp3;
54685 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54686 }
54687 {
54688 PyThreadState* __tstate = wxPyBeginAllowThreads();
54689 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54690 wxPyEndAllowThreads(__tstate);
54691 if (PyErr_Occurred()) SWIG_fail;
54692 }
54693 {
54694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54695 }
54696 return resultobj;
54697 fail:
54698 return NULL;
54699 }
54700
54701
54702 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54703 PyObject *resultobj = 0;
54704 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54705 size_t arg2 ;
54706 wxGBSpan *arg3 = 0 ;
54707 bool result;
54708 void *argp1 = 0 ;
54709 int res1 = 0 ;
54710 size_t val2 ;
54711 int ecode2 = 0 ;
54712 wxGBSpan temp3 ;
54713
54714 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54716 if (!SWIG_IsOK(res1)) {
54717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54718 }
54719 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54720 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54721 if (!SWIG_IsOK(ecode2)) {
54722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54723 }
54724 arg2 = static_cast< size_t >(val2);
54725 {
54726 arg3 = &temp3;
54727 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54728 }
54729 {
54730 PyThreadState* __tstate = wxPyBeginAllowThreads();
54731 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54732 wxPyEndAllowThreads(__tstate);
54733 if (PyErr_Occurred()) SWIG_fail;
54734 }
54735 {
54736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54737 }
54738 return resultobj;
54739 fail:
54740 return NULL;
54741 }
54742
54743
54744 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54745 int argc;
54746 PyObject *argv[4];
54747
54748 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54749 --argc;
54750 if (argc == 3) {
54751 int _v = 0;
54752 {
54753 void *vptr = 0;
54754 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54755 _v = SWIG_CheckState(res);
54756 }
54757 if (!_v) goto check_1;
54758 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54759 }
54760 check_1:
54761
54762 if (argc == 3) {
54763 int _v = 0;
54764 {
54765 void *vptr = 0;
54766 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54767 _v = SWIG_CheckState(res);
54768 }
54769 if (!_v) goto check_2;
54770 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54771 }
54772 check_2:
54773
54774 if (argc == 3) {
54775 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54776 }
54777
54778 fail:
54779 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54780 return NULL;
54781 }
54782
54783
54784 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54785 PyObject *resultobj = 0;
54786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54787 wxWindow *arg2 = (wxWindow *) 0 ;
54788 wxGBSizerItem *result = 0 ;
54789 void *argp1 = 0 ;
54790 int res1 = 0 ;
54791 void *argp2 = 0 ;
54792 int res2 = 0 ;
54793
54794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54796 if (!SWIG_IsOK(res1)) {
54797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54798 }
54799 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54800 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54801 if (!SWIG_IsOK(res2)) {
54802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54803 }
54804 arg2 = reinterpret_cast< wxWindow * >(argp2);
54805 {
54806 PyThreadState* __tstate = wxPyBeginAllowThreads();
54807 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54808 wxPyEndAllowThreads(__tstate);
54809 if (PyErr_Occurred()) SWIG_fail;
54810 }
54811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54812 return resultobj;
54813 fail:
54814 return NULL;
54815 }
54816
54817
54818 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54819 PyObject *resultobj = 0;
54820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54821 wxSizer *arg2 = (wxSizer *) 0 ;
54822 wxGBSizerItem *result = 0 ;
54823 void *argp1 = 0 ;
54824 int res1 = 0 ;
54825 void *argp2 = 0 ;
54826 int res2 = 0 ;
54827
54828 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54830 if (!SWIG_IsOK(res1)) {
54831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54832 }
54833 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54834 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54835 if (!SWIG_IsOK(res2)) {
54836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54837 }
54838 arg2 = reinterpret_cast< wxSizer * >(argp2);
54839 {
54840 PyThreadState* __tstate = wxPyBeginAllowThreads();
54841 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54842 wxPyEndAllowThreads(__tstate);
54843 if (PyErr_Occurred()) SWIG_fail;
54844 }
54845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54846 return resultobj;
54847 fail:
54848 return NULL;
54849 }
54850
54851
54852 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54853 int argc;
54854 PyObject *argv[3];
54855
54856 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54857 --argc;
54858 if (argc == 2) {
54859 int _v = 0;
54860 {
54861 void *vptr = 0;
54862 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54863 _v = SWIG_CheckState(res);
54864 }
54865 if (!_v) goto check_1;
54866 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54867 }
54868 check_1:
54869
54870 if (argc == 2) {
54871 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54872 }
54873
54874 fail:
54875 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54876 return NULL;
54877 }
54878
54879
54880 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54881 PyObject *resultobj = 0;
54882 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54883 wxGBPosition *arg2 = 0 ;
54884 wxGBSizerItem *result = 0 ;
54885 void *argp1 = 0 ;
54886 int res1 = 0 ;
54887 wxGBPosition temp2 ;
54888 PyObject * obj0 = 0 ;
54889 PyObject * obj1 = 0 ;
54890 char * kwnames[] = {
54891 (char *) "self",(char *) "pos", NULL
54892 };
54893
54894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54896 if (!SWIG_IsOK(res1)) {
54897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54898 }
54899 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54900 {
54901 arg2 = &temp2;
54902 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54903 }
54904 {
54905 PyThreadState* __tstate = wxPyBeginAllowThreads();
54906 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54907 wxPyEndAllowThreads(__tstate);
54908 if (PyErr_Occurred()) SWIG_fail;
54909 }
54910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54911 return resultobj;
54912 fail:
54913 return NULL;
54914 }
54915
54916
54917 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54918 PyObject *resultobj = 0;
54919 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54920 wxPoint *arg2 = 0 ;
54921 wxGBSizerItem *result = 0 ;
54922 void *argp1 = 0 ;
54923 int res1 = 0 ;
54924 wxPoint temp2 ;
54925 PyObject * obj0 = 0 ;
54926 PyObject * obj1 = 0 ;
54927 char * kwnames[] = {
54928 (char *) "self",(char *) "pt", NULL
54929 };
54930
54931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54933 if (!SWIG_IsOK(res1)) {
54934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54935 }
54936 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54937 {
54938 arg2 = &temp2;
54939 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54940 }
54941 {
54942 PyThreadState* __tstate = wxPyBeginAllowThreads();
54943 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54944 wxPyEndAllowThreads(__tstate);
54945 if (PyErr_Occurred()) SWIG_fail;
54946 }
54947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54948 return resultobj;
54949 fail:
54950 return NULL;
54951 }
54952
54953
54954 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54955 PyObject *resultobj = 0;
54956 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54957 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54958 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54959 bool result;
54960 void *argp1 = 0 ;
54961 int res1 = 0 ;
54962 void *argp2 = 0 ;
54963 int res2 = 0 ;
54964 void *argp3 = 0 ;
54965 int res3 = 0 ;
54966 PyObject * obj0 = 0 ;
54967 PyObject * obj1 = 0 ;
54968 PyObject * obj2 = 0 ;
54969 char * kwnames[] = {
54970 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54971 };
54972
54973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54975 if (!SWIG_IsOK(res1)) {
54976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54977 }
54978 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54980 if (!SWIG_IsOK(res2)) {
54981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54982 }
54983 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54984 if (obj2) {
54985 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54986 if (!SWIG_IsOK(res3)) {
54987 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54988 }
54989 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54990 }
54991 {
54992 PyThreadState* __tstate = wxPyBeginAllowThreads();
54993 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54994 wxPyEndAllowThreads(__tstate);
54995 if (PyErr_Occurred()) SWIG_fail;
54996 }
54997 {
54998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54999 }
55000 return resultobj;
55001 fail:
55002 return NULL;
55003 }
55004
55005
55006 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55007 PyObject *resultobj = 0;
55008 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55009 wxGBPosition *arg2 = 0 ;
55010 wxGBSpan *arg3 = 0 ;
55011 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55012 bool result;
55013 void *argp1 = 0 ;
55014 int res1 = 0 ;
55015 wxGBPosition temp2 ;
55016 wxGBSpan temp3 ;
55017 void *argp4 = 0 ;
55018 int res4 = 0 ;
55019 PyObject * obj0 = 0 ;
55020 PyObject * obj1 = 0 ;
55021 PyObject * obj2 = 0 ;
55022 PyObject * obj3 = 0 ;
55023 char * kwnames[] = {
55024 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55025 };
55026
55027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55029 if (!SWIG_IsOK(res1)) {
55030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55031 }
55032 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55033 {
55034 arg2 = &temp2;
55035 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55036 }
55037 {
55038 arg3 = &temp3;
55039 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55040 }
55041 if (obj3) {
55042 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55043 if (!SWIG_IsOK(res4)) {
55044 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55045 }
55046 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55047 }
55048 {
55049 PyThreadState* __tstate = wxPyBeginAllowThreads();
55050 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55051 wxPyEndAllowThreads(__tstate);
55052 if (PyErr_Occurred()) SWIG_fail;
55053 }
55054 {
55055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55056 }
55057 return resultobj;
55058 fail:
55059 return NULL;
55060 }
55061
55062
55063 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55064 PyObject *obj;
55065 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55066 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55067 return SWIG_Py_Void();
55068 }
55069
55070 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55071 return SWIG_Python_InitShadowInstance(args);
55072 }
55073
55074 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55075 PyObject *resultobj = 0;
55076 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55077 wxRelationship arg2 ;
55078 wxWindow *arg3 = (wxWindow *) 0 ;
55079 wxEdge arg4 ;
55080 int arg5 = (int) 0 ;
55081 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55082 void *argp1 = 0 ;
55083 int res1 = 0 ;
55084 int val2 ;
55085 int ecode2 = 0 ;
55086 void *argp3 = 0 ;
55087 int res3 = 0 ;
55088 int val4 ;
55089 int ecode4 = 0 ;
55090 int val5 ;
55091 int ecode5 = 0 ;
55092 int val6 ;
55093 int ecode6 = 0 ;
55094 PyObject * obj0 = 0 ;
55095 PyObject * obj1 = 0 ;
55096 PyObject * obj2 = 0 ;
55097 PyObject * obj3 = 0 ;
55098 PyObject * obj4 = 0 ;
55099 PyObject * obj5 = 0 ;
55100 char * kwnames[] = {
55101 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55102 };
55103
55104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55106 if (!SWIG_IsOK(res1)) {
55107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55108 }
55109 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55110 ecode2 = SWIG_AsVal_int(obj1, &val2);
55111 if (!SWIG_IsOK(ecode2)) {
55112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55113 }
55114 arg2 = static_cast< wxRelationship >(val2);
55115 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55116 if (!SWIG_IsOK(res3)) {
55117 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55118 }
55119 arg3 = reinterpret_cast< wxWindow * >(argp3);
55120 ecode4 = SWIG_AsVal_int(obj3, &val4);
55121 if (!SWIG_IsOK(ecode4)) {
55122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55123 }
55124 arg4 = static_cast< wxEdge >(val4);
55125 if (obj4) {
55126 ecode5 = SWIG_AsVal_int(obj4, &val5);
55127 if (!SWIG_IsOK(ecode5)) {
55128 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55129 }
55130 arg5 = static_cast< int >(val5);
55131 }
55132 if (obj5) {
55133 ecode6 = SWIG_AsVal_int(obj5, &val6);
55134 if (!SWIG_IsOK(ecode6)) {
55135 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55136 }
55137 arg6 = static_cast< int >(val6);
55138 }
55139 {
55140 PyThreadState* __tstate = wxPyBeginAllowThreads();
55141 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55142 wxPyEndAllowThreads(__tstate);
55143 if (PyErr_Occurred()) SWIG_fail;
55144 }
55145 resultobj = SWIG_Py_Void();
55146 return resultobj;
55147 fail:
55148 return NULL;
55149 }
55150
55151
55152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55153 PyObject *resultobj = 0;
55154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55155 wxWindow *arg2 = (wxWindow *) 0 ;
55156 int arg3 = (int) 0 ;
55157 void *argp1 = 0 ;
55158 int res1 = 0 ;
55159 void *argp2 = 0 ;
55160 int res2 = 0 ;
55161 int val3 ;
55162 int ecode3 = 0 ;
55163 PyObject * obj0 = 0 ;
55164 PyObject * obj1 = 0 ;
55165 PyObject * obj2 = 0 ;
55166 char * kwnames[] = {
55167 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55168 };
55169
55170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55172 if (!SWIG_IsOK(res1)) {
55173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55174 }
55175 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55177 if (!SWIG_IsOK(res2)) {
55178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55179 }
55180 arg2 = reinterpret_cast< wxWindow * >(argp2);
55181 if (obj2) {
55182 ecode3 = SWIG_AsVal_int(obj2, &val3);
55183 if (!SWIG_IsOK(ecode3)) {
55184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55185 }
55186 arg3 = static_cast< int >(val3);
55187 }
55188 {
55189 PyThreadState* __tstate = wxPyBeginAllowThreads();
55190 (arg1)->LeftOf(arg2,arg3);
55191 wxPyEndAllowThreads(__tstate);
55192 if (PyErr_Occurred()) SWIG_fail;
55193 }
55194 resultobj = SWIG_Py_Void();
55195 return resultobj;
55196 fail:
55197 return NULL;
55198 }
55199
55200
55201 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55202 PyObject *resultobj = 0;
55203 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55204 wxWindow *arg2 = (wxWindow *) 0 ;
55205 int arg3 = (int) 0 ;
55206 void *argp1 = 0 ;
55207 int res1 = 0 ;
55208 void *argp2 = 0 ;
55209 int res2 = 0 ;
55210 int val3 ;
55211 int ecode3 = 0 ;
55212 PyObject * obj0 = 0 ;
55213 PyObject * obj1 = 0 ;
55214 PyObject * obj2 = 0 ;
55215 char * kwnames[] = {
55216 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55217 };
55218
55219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55221 if (!SWIG_IsOK(res1)) {
55222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55223 }
55224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55226 if (!SWIG_IsOK(res2)) {
55227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55228 }
55229 arg2 = reinterpret_cast< wxWindow * >(argp2);
55230 if (obj2) {
55231 ecode3 = SWIG_AsVal_int(obj2, &val3);
55232 if (!SWIG_IsOK(ecode3)) {
55233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55234 }
55235 arg3 = static_cast< int >(val3);
55236 }
55237 {
55238 PyThreadState* __tstate = wxPyBeginAllowThreads();
55239 (arg1)->RightOf(arg2,arg3);
55240 wxPyEndAllowThreads(__tstate);
55241 if (PyErr_Occurred()) SWIG_fail;
55242 }
55243 resultobj = SWIG_Py_Void();
55244 return resultobj;
55245 fail:
55246 return NULL;
55247 }
55248
55249
55250 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55251 PyObject *resultobj = 0;
55252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55253 wxWindow *arg2 = (wxWindow *) 0 ;
55254 int arg3 = (int) 0 ;
55255 void *argp1 = 0 ;
55256 int res1 = 0 ;
55257 void *argp2 = 0 ;
55258 int res2 = 0 ;
55259 int val3 ;
55260 int ecode3 = 0 ;
55261 PyObject * obj0 = 0 ;
55262 PyObject * obj1 = 0 ;
55263 PyObject * obj2 = 0 ;
55264 char * kwnames[] = {
55265 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55266 };
55267
55268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55270 if (!SWIG_IsOK(res1)) {
55271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55272 }
55273 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55275 if (!SWIG_IsOK(res2)) {
55276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55277 }
55278 arg2 = reinterpret_cast< wxWindow * >(argp2);
55279 if (obj2) {
55280 ecode3 = SWIG_AsVal_int(obj2, &val3);
55281 if (!SWIG_IsOK(ecode3)) {
55282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55283 }
55284 arg3 = static_cast< int >(val3);
55285 }
55286 {
55287 PyThreadState* __tstate = wxPyBeginAllowThreads();
55288 (arg1)->Above(arg2,arg3);
55289 wxPyEndAllowThreads(__tstate);
55290 if (PyErr_Occurred()) SWIG_fail;
55291 }
55292 resultobj = SWIG_Py_Void();
55293 return resultobj;
55294 fail:
55295 return NULL;
55296 }
55297
55298
55299 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55300 PyObject *resultobj = 0;
55301 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55302 wxWindow *arg2 = (wxWindow *) 0 ;
55303 int arg3 = (int) 0 ;
55304 void *argp1 = 0 ;
55305 int res1 = 0 ;
55306 void *argp2 = 0 ;
55307 int res2 = 0 ;
55308 int val3 ;
55309 int ecode3 = 0 ;
55310 PyObject * obj0 = 0 ;
55311 PyObject * obj1 = 0 ;
55312 PyObject * obj2 = 0 ;
55313 char * kwnames[] = {
55314 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55315 };
55316
55317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55319 if (!SWIG_IsOK(res1)) {
55320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55321 }
55322 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55324 if (!SWIG_IsOK(res2)) {
55325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55326 }
55327 arg2 = reinterpret_cast< wxWindow * >(argp2);
55328 if (obj2) {
55329 ecode3 = SWIG_AsVal_int(obj2, &val3);
55330 if (!SWIG_IsOK(ecode3)) {
55331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55332 }
55333 arg3 = static_cast< int >(val3);
55334 }
55335 {
55336 PyThreadState* __tstate = wxPyBeginAllowThreads();
55337 (arg1)->Below(arg2,arg3);
55338 wxPyEndAllowThreads(__tstate);
55339 if (PyErr_Occurred()) SWIG_fail;
55340 }
55341 resultobj = SWIG_Py_Void();
55342 return resultobj;
55343 fail:
55344 return NULL;
55345 }
55346
55347
55348 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55349 PyObject *resultobj = 0;
55350 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55351 wxWindow *arg2 = (wxWindow *) 0 ;
55352 wxEdge arg3 ;
55353 int arg4 = (int) 0 ;
55354 void *argp1 = 0 ;
55355 int res1 = 0 ;
55356 void *argp2 = 0 ;
55357 int res2 = 0 ;
55358 int val3 ;
55359 int ecode3 = 0 ;
55360 int val4 ;
55361 int ecode4 = 0 ;
55362 PyObject * obj0 = 0 ;
55363 PyObject * obj1 = 0 ;
55364 PyObject * obj2 = 0 ;
55365 PyObject * obj3 = 0 ;
55366 char * kwnames[] = {
55367 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55368 };
55369
55370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55372 if (!SWIG_IsOK(res1)) {
55373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55374 }
55375 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55377 if (!SWIG_IsOK(res2)) {
55378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55379 }
55380 arg2 = reinterpret_cast< wxWindow * >(argp2);
55381 ecode3 = SWIG_AsVal_int(obj2, &val3);
55382 if (!SWIG_IsOK(ecode3)) {
55383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55384 }
55385 arg3 = static_cast< wxEdge >(val3);
55386 if (obj3) {
55387 ecode4 = SWIG_AsVal_int(obj3, &val4);
55388 if (!SWIG_IsOK(ecode4)) {
55389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55390 }
55391 arg4 = static_cast< int >(val4);
55392 }
55393 {
55394 PyThreadState* __tstate = wxPyBeginAllowThreads();
55395 (arg1)->SameAs(arg2,arg3,arg4);
55396 wxPyEndAllowThreads(__tstate);
55397 if (PyErr_Occurred()) SWIG_fail;
55398 }
55399 resultobj = SWIG_Py_Void();
55400 return resultobj;
55401 fail:
55402 return NULL;
55403 }
55404
55405
55406 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55407 PyObject *resultobj = 0;
55408 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55409 wxWindow *arg2 = (wxWindow *) 0 ;
55410 wxEdge arg3 ;
55411 int arg4 ;
55412 void *argp1 = 0 ;
55413 int res1 = 0 ;
55414 void *argp2 = 0 ;
55415 int res2 = 0 ;
55416 int val3 ;
55417 int ecode3 = 0 ;
55418 int val4 ;
55419 int ecode4 = 0 ;
55420 PyObject * obj0 = 0 ;
55421 PyObject * obj1 = 0 ;
55422 PyObject * obj2 = 0 ;
55423 PyObject * obj3 = 0 ;
55424 char * kwnames[] = {
55425 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55426 };
55427
55428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55430 if (!SWIG_IsOK(res1)) {
55431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55432 }
55433 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55435 if (!SWIG_IsOK(res2)) {
55436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55437 }
55438 arg2 = reinterpret_cast< wxWindow * >(argp2);
55439 ecode3 = SWIG_AsVal_int(obj2, &val3);
55440 if (!SWIG_IsOK(ecode3)) {
55441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55442 }
55443 arg3 = static_cast< wxEdge >(val3);
55444 ecode4 = SWIG_AsVal_int(obj3, &val4);
55445 if (!SWIG_IsOK(ecode4)) {
55446 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55447 }
55448 arg4 = static_cast< int >(val4);
55449 {
55450 PyThreadState* __tstate = wxPyBeginAllowThreads();
55451 (arg1)->PercentOf(arg2,arg3,arg4);
55452 wxPyEndAllowThreads(__tstate);
55453 if (PyErr_Occurred()) SWIG_fail;
55454 }
55455 resultobj = SWIG_Py_Void();
55456 return resultobj;
55457 fail:
55458 return NULL;
55459 }
55460
55461
55462 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55463 PyObject *resultobj = 0;
55464 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55465 int arg2 ;
55466 void *argp1 = 0 ;
55467 int res1 = 0 ;
55468 int val2 ;
55469 int ecode2 = 0 ;
55470 PyObject * obj0 = 0 ;
55471 PyObject * obj1 = 0 ;
55472 char * kwnames[] = {
55473 (char *) "self",(char *) "val", NULL
55474 };
55475
55476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55478 if (!SWIG_IsOK(res1)) {
55479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55480 }
55481 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55482 ecode2 = SWIG_AsVal_int(obj1, &val2);
55483 if (!SWIG_IsOK(ecode2)) {
55484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55485 }
55486 arg2 = static_cast< int >(val2);
55487 {
55488 PyThreadState* __tstate = wxPyBeginAllowThreads();
55489 (arg1)->Absolute(arg2);
55490 wxPyEndAllowThreads(__tstate);
55491 if (PyErr_Occurred()) SWIG_fail;
55492 }
55493 resultobj = SWIG_Py_Void();
55494 return resultobj;
55495 fail:
55496 return NULL;
55497 }
55498
55499
55500 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55501 PyObject *resultobj = 0;
55502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55503 void *argp1 = 0 ;
55504 int res1 = 0 ;
55505 PyObject *swig_obj[1] ;
55506
55507 if (!args) SWIG_fail;
55508 swig_obj[0] = args;
55509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55510 if (!SWIG_IsOK(res1)) {
55511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55512 }
55513 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55514 {
55515 PyThreadState* __tstate = wxPyBeginAllowThreads();
55516 (arg1)->Unconstrained();
55517 wxPyEndAllowThreads(__tstate);
55518 if (PyErr_Occurred()) SWIG_fail;
55519 }
55520 resultobj = SWIG_Py_Void();
55521 return resultobj;
55522 fail:
55523 return NULL;
55524 }
55525
55526
55527 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55528 PyObject *resultobj = 0;
55529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55530 void *argp1 = 0 ;
55531 int res1 = 0 ;
55532 PyObject *swig_obj[1] ;
55533
55534 if (!args) SWIG_fail;
55535 swig_obj[0] = args;
55536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55537 if (!SWIG_IsOK(res1)) {
55538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55539 }
55540 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55541 {
55542 PyThreadState* __tstate = wxPyBeginAllowThreads();
55543 (arg1)->AsIs();
55544 wxPyEndAllowThreads(__tstate);
55545 if (PyErr_Occurred()) SWIG_fail;
55546 }
55547 resultobj = SWIG_Py_Void();
55548 return resultobj;
55549 fail:
55550 return NULL;
55551 }
55552
55553
55554 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55555 PyObject *resultobj = 0;
55556 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55557 wxWindow *result = 0 ;
55558 void *argp1 = 0 ;
55559 int res1 = 0 ;
55560 PyObject *swig_obj[1] ;
55561
55562 if (!args) SWIG_fail;
55563 swig_obj[0] = args;
55564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55565 if (!SWIG_IsOK(res1)) {
55566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55567 }
55568 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55569 {
55570 PyThreadState* __tstate = wxPyBeginAllowThreads();
55571 result = (wxWindow *)(arg1)->GetOtherWindow();
55572 wxPyEndAllowThreads(__tstate);
55573 if (PyErr_Occurred()) SWIG_fail;
55574 }
55575 {
55576 resultobj = wxPyMake_wxObject(result, 0);
55577 }
55578 return resultobj;
55579 fail:
55580 return NULL;
55581 }
55582
55583
55584 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55585 PyObject *resultobj = 0;
55586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55587 wxEdge result;
55588 void *argp1 = 0 ;
55589 int res1 = 0 ;
55590 PyObject *swig_obj[1] ;
55591
55592 if (!args) SWIG_fail;
55593 swig_obj[0] = args;
55594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55595 if (!SWIG_IsOK(res1)) {
55596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55597 }
55598 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55599 {
55600 PyThreadState* __tstate = wxPyBeginAllowThreads();
55601 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55602 wxPyEndAllowThreads(__tstate);
55603 if (PyErr_Occurred()) SWIG_fail;
55604 }
55605 resultobj = SWIG_From_int(static_cast< int >(result));
55606 return resultobj;
55607 fail:
55608 return NULL;
55609 }
55610
55611
55612 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55613 PyObject *resultobj = 0;
55614 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55615 wxEdge arg2 ;
55616 void *argp1 = 0 ;
55617 int res1 = 0 ;
55618 int val2 ;
55619 int ecode2 = 0 ;
55620 PyObject * obj0 = 0 ;
55621 PyObject * obj1 = 0 ;
55622 char * kwnames[] = {
55623 (char *) "self",(char *) "which", NULL
55624 };
55625
55626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55628 if (!SWIG_IsOK(res1)) {
55629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55630 }
55631 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55632 ecode2 = SWIG_AsVal_int(obj1, &val2);
55633 if (!SWIG_IsOK(ecode2)) {
55634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55635 }
55636 arg2 = static_cast< wxEdge >(val2);
55637 {
55638 PyThreadState* __tstate = wxPyBeginAllowThreads();
55639 (arg1)->SetEdge(arg2);
55640 wxPyEndAllowThreads(__tstate);
55641 if (PyErr_Occurred()) SWIG_fail;
55642 }
55643 resultobj = SWIG_Py_Void();
55644 return resultobj;
55645 fail:
55646 return NULL;
55647 }
55648
55649
55650 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55651 PyObject *resultobj = 0;
55652 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55653 int arg2 ;
55654 void *argp1 = 0 ;
55655 int res1 = 0 ;
55656 int val2 ;
55657 int ecode2 = 0 ;
55658 PyObject * obj0 = 0 ;
55659 PyObject * obj1 = 0 ;
55660 char * kwnames[] = {
55661 (char *) "self",(char *) "v", NULL
55662 };
55663
55664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55666 if (!SWIG_IsOK(res1)) {
55667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55668 }
55669 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55670 ecode2 = SWIG_AsVal_int(obj1, &val2);
55671 if (!SWIG_IsOK(ecode2)) {
55672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55673 }
55674 arg2 = static_cast< int >(val2);
55675 {
55676 PyThreadState* __tstate = wxPyBeginAllowThreads();
55677 (arg1)->SetValue(arg2);
55678 wxPyEndAllowThreads(__tstate);
55679 if (PyErr_Occurred()) SWIG_fail;
55680 }
55681 resultobj = SWIG_Py_Void();
55682 return resultobj;
55683 fail:
55684 return NULL;
55685 }
55686
55687
55688 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55689 PyObject *resultobj = 0;
55690 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55691 int result;
55692 void *argp1 = 0 ;
55693 int res1 = 0 ;
55694 PyObject *swig_obj[1] ;
55695
55696 if (!args) SWIG_fail;
55697 swig_obj[0] = args;
55698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55699 if (!SWIG_IsOK(res1)) {
55700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55701 }
55702 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55703 {
55704 PyThreadState* __tstate = wxPyBeginAllowThreads();
55705 result = (int)(arg1)->GetMargin();
55706 wxPyEndAllowThreads(__tstate);
55707 if (PyErr_Occurred()) SWIG_fail;
55708 }
55709 resultobj = SWIG_From_int(static_cast< int >(result));
55710 return resultobj;
55711 fail:
55712 return NULL;
55713 }
55714
55715
55716 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55717 PyObject *resultobj = 0;
55718 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55719 int arg2 ;
55720 void *argp1 = 0 ;
55721 int res1 = 0 ;
55722 int val2 ;
55723 int ecode2 = 0 ;
55724 PyObject * obj0 = 0 ;
55725 PyObject * obj1 = 0 ;
55726 char * kwnames[] = {
55727 (char *) "self",(char *) "m", NULL
55728 };
55729
55730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55732 if (!SWIG_IsOK(res1)) {
55733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55734 }
55735 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55736 ecode2 = SWIG_AsVal_int(obj1, &val2);
55737 if (!SWIG_IsOK(ecode2)) {
55738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55739 }
55740 arg2 = static_cast< int >(val2);
55741 {
55742 PyThreadState* __tstate = wxPyBeginAllowThreads();
55743 (arg1)->SetMargin(arg2);
55744 wxPyEndAllowThreads(__tstate);
55745 if (PyErr_Occurred()) SWIG_fail;
55746 }
55747 resultobj = SWIG_Py_Void();
55748 return resultobj;
55749 fail:
55750 return NULL;
55751 }
55752
55753
55754 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55755 PyObject *resultobj = 0;
55756 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55757 int result;
55758 void *argp1 = 0 ;
55759 int res1 = 0 ;
55760 PyObject *swig_obj[1] ;
55761
55762 if (!args) SWIG_fail;
55763 swig_obj[0] = args;
55764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55765 if (!SWIG_IsOK(res1)) {
55766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55767 }
55768 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55769 {
55770 PyThreadState* __tstate = wxPyBeginAllowThreads();
55771 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55772 wxPyEndAllowThreads(__tstate);
55773 if (PyErr_Occurred()) SWIG_fail;
55774 }
55775 resultobj = SWIG_From_int(static_cast< int >(result));
55776 return resultobj;
55777 fail:
55778 return NULL;
55779 }
55780
55781
55782 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55783 PyObject *resultobj = 0;
55784 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55785 int result;
55786 void *argp1 = 0 ;
55787 int res1 = 0 ;
55788 PyObject *swig_obj[1] ;
55789
55790 if (!args) SWIG_fail;
55791 swig_obj[0] = args;
55792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55793 if (!SWIG_IsOK(res1)) {
55794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55795 }
55796 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55797 {
55798 PyThreadState* __tstate = wxPyBeginAllowThreads();
55799 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55800 wxPyEndAllowThreads(__tstate);
55801 if (PyErr_Occurred()) SWIG_fail;
55802 }
55803 resultobj = SWIG_From_int(static_cast< int >(result));
55804 return resultobj;
55805 fail:
55806 return NULL;
55807 }
55808
55809
55810 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55811 PyObject *resultobj = 0;
55812 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55813 int result;
55814 void *argp1 = 0 ;
55815 int res1 = 0 ;
55816 PyObject *swig_obj[1] ;
55817
55818 if (!args) SWIG_fail;
55819 swig_obj[0] = args;
55820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55821 if (!SWIG_IsOK(res1)) {
55822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55823 }
55824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55825 {
55826 PyThreadState* __tstate = wxPyBeginAllowThreads();
55827 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55828 wxPyEndAllowThreads(__tstate);
55829 if (PyErr_Occurred()) SWIG_fail;
55830 }
55831 resultobj = SWIG_From_int(static_cast< int >(result));
55832 return resultobj;
55833 fail:
55834 return NULL;
55835 }
55836
55837
55838 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55839 PyObject *resultobj = 0;
55840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55841 bool result;
55842 void *argp1 = 0 ;
55843 int res1 = 0 ;
55844 PyObject *swig_obj[1] ;
55845
55846 if (!args) SWIG_fail;
55847 swig_obj[0] = args;
55848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55849 if (!SWIG_IsOK(res1)) {
55850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55851 }
55852 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55853 {
55854 PyThreadState* __tstate = wxPyBeginAllowThreads();
55855 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55856 wxPyEndAllowThreads(__tstate);
55857 if (PyErr_Occurred()) SWIG_fail;
55858 }
55859 {
55860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55861 }
55862 return resultobj;
55863 fail:
55864 return NULL;
55865 }
55866
55867
55868 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55869 PyObject *resultobj = 0;
55870 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55871 bool arg2 ;
55872 void *argp1 = 0 ;
55873 int res1 = 0 ;
55874 bool val2 ;
55875 int ecode2 = 0 ;
55876 PyObject * obj0 = 0 ;
55877 PyObject * obj1 = 0 ;
55878 char * kwnames[] = {
55879 (char *) "self",(char *) "d", NULL
55880 };
55881
55882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55884 if (!SWIG_IsOK(res1)) {
55885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55886 }
55887 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55889 if (!SWIG_IsOK(ecode2)) {
55890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55891 }
55892 arg2 = static_cast< bool >(val2);
55893 {
55894 PyThreadState* __tstate = wxPyBeginAllowThreads();
55895 (arg1)->SetDone(arg2);
55896 wxPyEndAllowThreads(__tstate);
55897 if (PyErr_Occurred()) SWIG_fail;
55898 }
55899 resultobj = SWIG_Py_Void();
55900 return resultobj;
55901 fail:
55902 return NULL;
55903 }
55904
55905
55906 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55907 PyObject *resultobj = 0;
55908 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55909 wxRelationship result;
55910 void *argp1 = 0 ;
55911 int res1 = 0 ;
55912 PyObject *swig_obj[1] ;
55913
55914 if (!args) SWIG_fail;
55915 swig_obj[0] = args;
55916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55917 if (!SWIG_IsOK(res1)) {
55918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55919 }
55920 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55921 {
55922 PyThreadState* __tstate = wxPyBeginAllowThreads();
55923 result = (wxRelationship)(arg1)->GetRelationship();
55924 wxPyEndAllowThreads(__tstate);
55925 if (PyErr_Occurred()) SWIG_fail;
55926 }
55927 resultobj = SWIG_From_int(static_cast< int >(result));
55928 return resultobj;
55929 fail:
55930 return NULL;
55931 }
55932
55933
55934 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55935 PyObject *resultobj = 0;
55936 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55937 wxRelationship arg2 ;
55938 void *argp1 = 0 ;
55939 int res1 = 0 ;
55940 int val2 ;
55941 int ecode2 = 0 ;
55942 PyObject * obj0 = 0 ;
55943 PyObject * obj1 = 0 ;
55944 char * kwnames[] = {
55945 (char *) "self",(char *) "r", NULL
55946 };
55947
55948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55950 if (!SWIG_IsOK(res1)) {
55951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55952 }
55953 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55954 ecode2 = SWIG_AsVal_int(obj1, &val2);
55955 if (!SWIG_IsOK(ecode2)) {
55956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55957 }
55958 arg2 = static_cast< wxRelationship >(val2);
55959 {
55960 PyThreadState* __tstate = wxPyBeginAllowThreads();
55961 (arg1)->SetRelationship(arg2);
55962 wxPyEndAllowThreads(__tstate);
55963 if (PyErr_Occurred()) SWIG_fail;
55964 }
55965 resultobj = SWIG_Py_Void();
55966 return resultobj;
55967 fail:
55968 return NULL;
55969 }
55970
55971
55972 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55973 PyObject *resultobj = 0;
55974 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55975 wxWindow *arg2 = (wxWindow *) 0 ;
55976 bool result;
55977 void *argp1 = 0 ;
55978 int res1 = 0 ;
55979 void *argp2 = 0 ;
55980 int res2 = 0 ;
55981 PyObject * obj0 = 0 ;
55982 PyObject * obj1 = 0 ;
55983 char * kwnames[] = {
55984 (char *) "self",(char *) "otherW", NULL
55985 };
55986
55987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55989 if (!SWIG_IsOK(res1)) {
55990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55991 }
55992 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55994 if (!SWIG_IsOK(res2)) {
55995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55996 }
55997 arg2 = reinterpret_cast< wxWindow * >(argp2);
55998 {
55999 PyThreadState* __tstate = wxPyBeginAllowThreads();
56000 result = (bool)(arg1)->ResetIfWin(arg2);
56001 wxPyEndAllowThreads(__tstate);
56002 if (PyErr_Occurred()) SWIG_fail;
56003 }
56004 {
56005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56006 }
56007 return resultobj;
56008 fail:
56009 return NULL;
56010 }
56011
56012
56013 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56014 PyObject *resultobj = 0;
56015 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56016 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56017 wxWindow *arg3 = (wxWindow *) 0 ;
56018 bool result;
56019 void *argp1 = 0 ;
56020 int res1 = 0 ;
56021 void *argp2 = 0 ;
56022 int res2 = 0 ;
56023 void *argp3 = 0 ;
56024 int res3 = 0 ;
56025 PyObject * obj0 = 0 ;
56026 PyObject * obj1 = 0 ;
56027 PyObject * obj2 = 0 ;
56028 char * kwnames[] = {
56029 (char *) "self",(char *) "constraints",(char *) "win", NULL
56030 };
56031
56032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56034 if (!SWIG_IsOK(res1)) {
56035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56036 }
56037 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56039 if (!SWIG_IsOK(res2)) {
56040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56041 }
56042 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56043 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56044 if (!SWIG_IsOK(res3)) {
56045 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56046 }
56047 arg3 = reinterpret_cast< wxWindow * >(argp3);
56048 {
56049 PyThreadState* __tstate = wxPyBeginAllowThreads();
56050 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56051 wxPyEndAllowThreads(__tstate);
56052 if (PyErr_Occurred()) SWIG_fail;
56053 }
56054 {
56055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56056 }
56057 return resultobj;
56058 fail:
56059 return NULL;
56060 }
56061
56062
56063 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56064 PyObject *resultobj = 0;
56065 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56066 wxEdge arg2 ;
56067 wxWindow *arg3 = (wxWindow *) 0 ;
56068 wxWindow *arg4 = (wxWindow *) 0 ;
56069 int result;
56070 void *argp1 = 0 ;
56071 int res1 = 0 ;
56072 int val2 ;
56073 int ecode2 = 0 ;
56074 void *argp3 = 0 ;
56075 int res3 = 0 ;
56076 void *argp4 = 0 ;
56077 int res4 = 0 ;
56078 PyObject * obj0 = 0 ;
56079 PyObject * obj1 = 0 ;
56080 PyObject * obj2 = 0 ;
56081 PyObject * obj3 = 0 ;
56082 char * kwnames[] = {
56083 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56084 };
56085
56086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56088 if (!SWIG_IsOK(res1)) {
56089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56090 }
56091 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56092 ecode2 = SWIG_AsVal_int(obj1, &val2);
56093 if (!SWIG_IsOK(ecode2)) {
56094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56095 }
56096 arg2 = static_cast< wxEdge >(val2);
56097 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56098 if (!SWIG_IsOK(res3)) {
56099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56100 }
56101 arg3 = reinterpret_cast< wxWindow * >(argp3);
56102 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56103 if (!SWIG_IsOK(res4)) {
56104 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56105 }
56106 arg4 = reinterpret_cast< wxWindow * >(argp4);
56107 {
56108 PyThreadState* __tstate = wxPyBeginAllowThreads();
56109 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56110 wxPyEndAllowThreads(__tstate);
56111 if (PyErr_Occurred()) SWIG_fail;
56112 }
56113 resultobj = SWIG_From_int(static_cast< int >(result));
56114 return resultobj;
56115 fail:
56116 return NULL;
56117 }
56118
56119
56120 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56121 PyObject *obj;
56122 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56123 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56124 return SWIG_Py_Void();
56125 }
56126
56127 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56128 PyObject *resultobj = 0;
56129 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56130 wxIndividualLayoutConstraint *result = 0 ;
56131 void *argp1 = 0 ;
56132 int res1 = 0 ;
56133 PyObject *swig_obj[1] ;
56134
56135 if (!args) SWIG_fail;
56136 swig_obj[0] = args;
56137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56138 if (!SWIG_IsOK(res1)) {
56139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56140 }
56141 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56142 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56144 return resultobj;
56145 fail:
56146 return NULL;
56147 }
56148
56149
56150 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56151 PyObject *resultobj = 0;
56152 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56153 wxIndividualLayoutConstraint *result = 0 ;
56154 void *argp1 = 0 ;
56155 int res1 = 0 ;
56156 PyObject *swig_obj[1] ;
56157
56158 if (!args) SWIG_fail;
56159 swig_obj[0] = args;
56160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56161 if (!SWIG_IsOK(res1)) {
56162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56163 }
56164 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56165 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56167 return resultobj;
56168 fail:
56169 return NULL;
56170 }
56171
56172
56173 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56174 PyObject *resultobj = 0;
56175 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56176 wxIndividualLayoutConstraint *result = 0 ;
56177 void *argp1 = 0 ;
56178 int res1 = 0 ;
56179 PyObject *swig_obj[1] ;
56180
56181 if (!args) SWIG_fail;
56182 swig_obj[0] = args;
56183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56184 if (!SWIG_IsOK(res1)) {
56185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56186 }
56187 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56188 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56190 return resultobj;
56191 fail:
56192 return NULL;
56193 }
56194
56195
56196 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56197 PyObject *resultobj = 0;
56198 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56199 wxIndividualLayoutConstraint *result = 0 ;
56200 void *argp1 = 0 ;
56201 int res1 = 0 ;
56202 PyObject *swig_obj[1] ;
56203
56204 if (!args) SWIG_fail;
56205 swig_obj[0] = args;
56206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56207 if (!SWIG_IsOK(res1)) {
56208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56209 }
56210 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56211 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56213 return resultobj;
56214 fail:
56215 return NULL;
56216 }
56217
56218
56219 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56220 PyObject *resultobj = 0;
56221 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56222 wxIndividualLayoutConstraint *result = 0 ;
56223 void *argp1 = 0 ;
56224 int res1 = 0 ;
56225 PyObject *swig_obj[1] ;
56226
56227 if (!args) SWIG_fail;
56228 swig_obj[0] = args;
56229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56230 if (!SWIG_IsOK(res1)) {
56231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56232 }
56233 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56234 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56236 return resultobj;
56237 fail:
56238 return NULL;
56239 }
56240
56241
56242 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56243 PyObject *resultobj = 0;
56244 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56245 wxIndividualLayoutConstraint *result = 0 ;
56246 void *argp1 = 0 ;
56247 int res1 = 0 ;
56248 PyObject *swig_obj[1] ;
56249
56250 if (!args) SWIG_fail;
56251 swig_obj[0] = args;
56252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56253 if (!SWIG_IsOK(res1)) {
56254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56255 }
56256 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56257 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56259 return resultobj;
56260 fail:
56261 return NULL;
56262 }
56263
56264
56265 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56266 PyObject *resultobj = 0;
56267 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56268 wxIndividualLayoutConstraint *result = 0 ;
56269 void *argp1 = 0 ;
56270 int res1 = 0 ;
56271 PyObject *swig_obj[1] ;
56272
56273 if (!args) SWIG_fail;
56274 swig_obj[0] = args;
56275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56276 if (!SWIG_IsOK(res1)) {
56277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56278 }
56279 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56280 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56282 return resultobj;
56283 fail:
56284 return NULL;
56285 }
56286
56287
56288 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56289 PyObject *resultobj = 0;
56290 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56291 wxIndividualLayoutConstraint *result = 0 ;
56292 void *argp1 = 0 ;
56293 int res1 = 0 ;
56294 PyObject *swig_obj[1] ;
56295
56296 if (!args) SWIG_fail;
56297 swig_obj[0] = args;
56298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56299 if (!SWIG_IsOK(res1)) {
56300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56301 }
56302 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56303 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56305 return resultobj;
56306 fail:
56307 return NULL;
56308 }
56309
56310
56311 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56312 PyObject *resultobj = 0;
56313 wxLayoutConstraints *result = 0 ;
56314
56315 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56316 {
56317 PyThreadState* __tstate = wxPyBeginAllowThreads();
56318 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56319 wxPyEndAllowThreads(__tstate);
56320 if (PyErr_Occurred()) SWIG_fail;
56321 }
56322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56323 return resultobj;
56324 fail:
56325 return NULL;
56326 }
56327
56328
56329 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56330 PyObject *resultobj = 0;
56331 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56332 void *argp1 = 0 ;
56333 int res1 = 0 ;
56334 PyObject *swig_obj[1] ;
56335
56336 if (!args) SWIG_fail;
56337 swig_obj[0] = args;
56338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56339 if (!SWIG_IsOK(res1)) {
56340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56341 }
56342 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56343 {
56344 PyThreadState* __tstate = wxPyBeginAllowThreads();
56345 delete arg1;
56346
56347 wxPyEndAllowThreads(__tstate);
56348 if (PyErr_Occurred()) SWIG_fail;
56349 }
56350 resultobj = SWIG_Py_Void();
56351 return resultobj;
56352 fail:
56353 return NULL;
56354 }
56355
56356
56357 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56358 PyObject *resultobj = 0;
56359 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56360 wxWindow *arg2 = (wxWindow *) 0 ;
56361 int *arg3 = (int *) 0 ;
56362 bool result;
56363 void *argp1 = 0 ;
56364 int res1 = 0 ;
56365 void *argp2 = 0 ;
56366 int res2 = 0 ;
56367 int temp3 ;
56368 int res3 = SWIG_TMPOBJ ;
56369 PyObject * obj0 = 0 ;
56370 PyObject * obj1 = 0 ;
56371 char * kwnames[] = {
56372 (char *) "self",(char *) "win", NULL
56373 };
56374
56375 arg3 = &temp3;
56376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56378 if (!SWIG_IsOK(res1)) {
56379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56380 }
56381 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56383 if (!SWIG_IsOK(res2)) {
56384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56385 }
56386 arg2 = reinterpret_cast< wxWindow * >(argp2);
56387 {
56388 PyThreadState* __tstate = wxPyBeginAllowThreads();
56389 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56390 wxPyEndAllowThreads(__tstate);
56391 if (PyErr_Occurred()) SWIG_fail;
56392 }
56393 {
56394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56395 }
56396 if (SWIG_IsTmpObj(res3)) {
56397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56398 } else {
56399 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56401 }
56402 return resultobj;
56403 fail:
56404 return NULL;
56405 }
56406
56407
56408 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56409 PyObject *resultobj = 0;
56410 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56411 bool result;
56412 void *argp1 = 0 ;
56413 int res1 = 0 ;
56414 PyObject *swig_obj[1] ;
56415
56416 if (!args) SWIG_fail;
56417 swig_obj[0] = args;
56418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56419 if (!SWIG_IsOK(res1)) {
56420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56421 }
56422 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56423 {
56424 PyThreadState* __tstate = wxPyBeginAllowThreads();
56425 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56426 wxPyEndAllowThreads(__tstate);
56427 if (PyErr_Occurred()) SWIG_fail;
56428 }
56429 {
56430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56431 }
56432 return resultobj;
56433 fail:
56434 return NULL;
56435 }
56436
56437
56438 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56439 PyObject *obj;
56440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56441 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56442 return SWIG_Py_Void();
56443 }
56444
56445 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56446 return SWIG_Python_InitShadowInstance(args);
56447 }
56448
56449 static PyMethodDef SwigMethods[] = {
56450 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56451 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56452 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56453 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56455 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56456 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56457 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56458 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56459 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56461 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56474 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56475 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56476 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56478 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56479 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56480 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56481 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56482 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56483 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56484 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56486 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56492 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56493 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56494 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56495 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56496 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56497 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56498 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56500 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56508 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56509 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56510 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56512 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56514 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56515 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56516 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56518 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56520 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56522 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56524 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56526 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56528 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56529 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56531 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56532 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56533 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56535 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56537 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56538 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56539 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56540 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56555 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56560 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56561 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56562 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56563 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56564 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56565 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56566 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56567 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56569 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56570 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56571 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56576 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56577 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56578 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56579 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56580 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56587 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56593 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56594 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56595 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56596 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56597 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56599 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56600 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56601 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56603 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56604 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56605 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56606 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56609 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56612 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56615 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56618 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56621 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56624 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56627 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56630 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56636 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56638 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56639 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56644 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56647 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56650 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56651 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56652 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56653 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56654 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56655 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56656 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56657 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56659 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56660 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56661 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56663 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56664 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56665 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56666 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56671 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56672 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56673 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56674 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56675 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56676 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56679 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56680 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56681 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56683 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56684 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56686 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56687 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56688 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56689 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56690 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56691 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56692 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56693 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56694 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56695 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56696 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56697 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56702 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56708 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56709 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56710 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56711 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56713 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56716 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56719 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56722 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56723 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56724 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56727 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56728 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56729 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56733 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56734 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56735 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56739 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56744 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56745 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56746 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56747 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56748 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56749 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56750 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56757 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56758 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56760 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56761 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56762 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56765 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56768 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56769 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56771 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56772 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56773 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56774 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56775 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56776 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56777 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56778 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56780 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56781 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56782 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56783 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56784 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56785 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56786 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56787 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56789 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56798 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56815 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56816 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56831 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56832 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56833 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56834 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56837 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56839 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56841 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56843 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56845 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56848 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56849 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56850 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56851 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56853 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56854 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56862 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56866 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56867 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56868 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56869 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56870 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56871 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56873 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56876 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56877 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56878 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56879 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56880 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56881 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56882 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56883 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56884 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56885 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56886 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56887 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56888 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56889 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56890 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56891 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56892 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56893 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56894 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56895 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56896 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56897 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56898 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56899 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56900 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56901 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56902 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56903 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56904 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56905 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56906 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56907 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56908 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56909 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56910 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56911 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56912 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56913 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56914 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56915 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56917 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56918 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56919 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56920 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56921 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56923 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56927 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56930 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56931 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56932 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56933 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56934 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56935 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56936 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56937 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56939 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56940 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56941 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56943 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56944 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56945 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56946 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56947 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56949 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56950 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56951 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56952 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56953 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56954 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56956 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56957 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56958 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56959 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56960 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56961 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56962 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56963 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56964 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56966 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56968 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56969 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56971 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56972 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56973 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56975 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56976 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56977 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56978 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56979 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56981 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56982 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56985 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56986 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56987 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56988 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56989 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56990 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56991 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56992 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56993 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56994 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56995 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56996 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56997 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56998 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56999 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
57000 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
57001 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
57002 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
57003 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
57004 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57005 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57006 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57007 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57008 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57009 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57010 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57011 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57012 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57013 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57014 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57015 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57016 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57017 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57018 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57019 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57020 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57021 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57022 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57023 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57024 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57025 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57026 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57027 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57028 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57029 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57030 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57031 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57032 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57033 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57034 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57035 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57036 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57037 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57038 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57039 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57040 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57041 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57042 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57043 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57044 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57045 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57046 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57047 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57048 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57049 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57050 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57051 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57052 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57053 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57054 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57055 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57056 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57057 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57058 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57059 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57060 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57062 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57063 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57064 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57065 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57066 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57067 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57068 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57069 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57070 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57071 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57072 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57073 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57074 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57075 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57076 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57077 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57078 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57079 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57080 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57081 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57082 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57083 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57084 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57085 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57086 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57087 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57088 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57089 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57090 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57091 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57092 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57093 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57094 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57095 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57096 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57097 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57098 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57099 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57100 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57101 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57102 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57105 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57106 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57107 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57110 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57111 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57112 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57113 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57114 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57115 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57117 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57118 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57119 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57120 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57121 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57122 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57123 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57124 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57125 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57126 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57127 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57128 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57129 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57130 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57131 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57132 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57134 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57135 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57136 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57137 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57139 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57140 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57141 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57142 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57143 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57144 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57145 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57146 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57147 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57148 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57150 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57151 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57152 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57153 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57154 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57156 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57157 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57158 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57159 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57160 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57161 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57162 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57163 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57165 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57166 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57167 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57168 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57169 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57170 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57171 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57172 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57173 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57174 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57175 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57176 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57177 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57178 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57179 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57180 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57181 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57182 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57183 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57184 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57185 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57186 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57187 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57188 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57190 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57194 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57195 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57196 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57197 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57198 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57199 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57200 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57201 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57202 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57203 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57204 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57205 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57206 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57207 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57208 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57209 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57210 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57211 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57212 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57213 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57215 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57216 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57217 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57218 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57220 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57221 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57222 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57223 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57224 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57225 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57226 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57227 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57229 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57230 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57231 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57232 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57233 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57234 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57235 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57236 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57237 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57238 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57239 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57241 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57242 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57243 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57244 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57245 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57247 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57248 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57249 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57251 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57253 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57255 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57256 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57258 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57259 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57260 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57261 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57262 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57263 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57264 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57265 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57266 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57267 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57268 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57269 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57270 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57271 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57273 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57275 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57276 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57277 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57278 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57280 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57281 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57282 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57284 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57285 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57286 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57287 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57289 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57290 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57291 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57292 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57293 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57294 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57295 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57296 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57297 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57298 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57299 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57301 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57303 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57305 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57306 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57307 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57309 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57310 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57311 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57312 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57313 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57314 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57315 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57316 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57319 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57320 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57321 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57322 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57323 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57324 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57325 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57326 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57327 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57328 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57329 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57330 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57331 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57332 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57334 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57335 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57336 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57337 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57339 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57340 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57341 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57342 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57344 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57345 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57347 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57348 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57349 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57351 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57354 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57355 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57356 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57357 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57358 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57359 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57360 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57361 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57363 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57364 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57365 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57366 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57367 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57368 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57369 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57370 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57371 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57372 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57373 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57374 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57375 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57376 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57377 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57379 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57382 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57383 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57384 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57386 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57388 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57390 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57392 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57393 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57396 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57406 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57407 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57408 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57410 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57411 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57412 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57413 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57414 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57415 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57416 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57417 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57418 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57419 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57420 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57421 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57422 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57423 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57424 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57425 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57427 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57430 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57431 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57434 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57436 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57437 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57440 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57441 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57442 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57443 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57446 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57447 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
57448 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57449 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57451 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57453 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57454 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57455 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57456 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57458 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57460 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57461 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57463 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57466 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57467 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57468 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57469 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57470 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57471 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57475 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57476 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57477 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57478 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57485 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57490 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57491 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57492 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57493 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57494 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57495 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57497 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57507 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57508 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57509 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57510 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57513 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57514 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57515 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57516 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57517 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57519 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57520 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57521 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57525 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57531 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57532 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57533 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57534 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57536 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57537 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57539 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57542 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57544 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57545 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57546 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57555 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57559 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57560 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57562 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57573 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57574 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57575 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57576 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57580 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57583 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57585 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57588 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57590 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57591 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57593 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57594 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57596 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57597 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57598 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57599 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57601 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57602 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57607 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57608 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57609 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57611 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57612 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57613 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57615 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57617 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57618 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57619 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57621 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57622 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57625 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57633 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57640 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57643 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57648 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57651 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57652 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57665 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57667 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57669 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57670 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57672 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57674 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57675 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57677 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57678 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57679 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57683 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57702 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57703 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57705 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57706 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57708 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57709 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57710 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57712 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57713 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57716 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57717 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57719 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57720 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57722 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57725 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57726 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57728 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57730 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57732 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57733 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57735 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57736 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57739 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57740 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57741 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57743 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57745 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57748 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57750 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57751 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57752 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57754 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57755 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57756 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57758 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57760 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57761 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57764 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57765 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57769 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57773 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57774 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57776 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57780 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57782 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57784 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57785 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57786 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57787 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57791 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57792 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57793 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57794 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57796 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57797 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57802 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57803 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57804 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57805 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57806 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57808 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57810 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57812 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57813 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57815 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57817 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57820 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57821 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57822 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57824 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57825 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57826 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57839 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57845 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57846 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57847 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57848 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57849 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57850 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57856 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57857 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57861 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57862 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57864 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57865 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57867 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57869 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57870 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57872 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57873 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57874 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57875 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57880 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57881 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57882 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57883 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57884 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57885 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57892 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57894 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57895 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57896 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57897 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57898 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57899 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57901 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57905 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57906 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57907 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57908 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57909 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57910 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57911 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57913 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57914 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57915 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57921 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57922 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57923 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57925 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57926 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57927 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57933 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57934 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57935 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57936 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57937 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57941 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57942 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57947 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57948 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57950 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57951 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57956 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57958 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57959 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57960 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57961 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57962 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57967 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57968 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57977 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57978 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57979 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57980 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57983 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57985 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57986 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57987 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57988 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57989 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57990 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57995 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57996 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57997 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57998 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57999 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
58000 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
58001 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
58002 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
58003 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
58004 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
58005 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58006 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
58007 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58008 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58009 { NULL, NULL, 0, NULL }
58010 };
58011
58012
58013 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58014
58015 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58016 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58017 }
58018 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58019 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58020 }
58021 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58022 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58023 }
58024 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58025 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58026 }
58027 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58028 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58029 }
58030 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58031 return (void *)((wxSizer *) ((wxGridSizer *) x));
58032 }
58033 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58034 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58035 }
58036 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58037 return (void *)((wxSizer *) ((wxPySizer *) x));
58038 }
58039 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58040 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58041 }
58042 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58043 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58044 }
58045 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58046 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58047 }
58048 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58049 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58050 }
58051 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58052 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58053 }
58054 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58055 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58056 }
58057 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58058 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58059 }
58060 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58061 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58062 }
58063 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58065 }
58066 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58068 }
58069 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58071 }
58072 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58074 }
58075 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) ((wxPyEvent *) x));
58077 }
58078 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58080 }
58081 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58083 }
58084 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58086 }
58087 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58089 }
58090 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58092 }
58093 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58095 }
58096 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58098 }
58099 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58100 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58101 }
58102 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58103 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58104 }
58105 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58106 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58107 }
58108 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58109 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58110 }
58111 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58112 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58113 }
58114 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58115 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58116 }
58117 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58118 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58119 }
58120 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58121 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58122 }
58123 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58124 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58125 }
58126 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58127 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58128 }
58129 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58130 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58131 }
58132 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58133 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58134 }
58135 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58136 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58137 }
58138 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58139 return (void *)((wxEvent *) ((wxShowEvent *) x));
58140 }
58141 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58142 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58143 }
58144 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58145 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58146 }
58147 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58148 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58149 }
58150 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58151 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58152 }
58153 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58154 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58155 }
58156 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58157 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58158 }
58159 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58160 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58161 }
58162 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58163 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58164 }
58165 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58166 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58167 }
58168 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58169 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58170 }
58171 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58172 return (void *)((wxControl *) ((wxControlWithItems *) x));
58173 }
58174 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58175 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58176 }
58177 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58178 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58179 }
58180 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58181 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58182 }
58183 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58184 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58185 }
58186 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58187 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58188 }
58189 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58190 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58191 }
58192 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58193 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58194 }
58195 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58196 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58197 }
58198 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58199 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58200 }
58201 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58202 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58203 }
58204 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58205 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58206 }
58207 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58208 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58209 }
58210 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58211 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58212 }
58213 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58214 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58215 }
58216 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58217 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58218 }
58219 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58220 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58221 }
58222 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58223 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58224 }
58225 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58226 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58227 }
58228 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58229 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58230 }
58231 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58232 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58233 }
58234 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58235 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58236 }
58237 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58238 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58239 }
58240 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58241 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58242 }
58243 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58244 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58245 }
58246 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58247 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58248 }
58249 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58250 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58251 }
58252 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58253 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58254 }
58255 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58256 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58257 }
58258 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58259 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58260 }
58261 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58262 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58263 }
58264 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58265 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58266 }
58267 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58268 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58269 }
58270 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58271 return (void *)((wxObject *) ((wxSizerItem *) x));
58272 }
58273 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58274 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58275 }
58276 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58277 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58278 }
58279 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58280 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58281 }
58282 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58284 }
58285 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58287 }
58288 static void *_p_wxSizerTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) ((wxSizer *) x));
58290 }
58291 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58293 }
58294 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58296 }
58297 static void *_p_wxEventTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) ((wxEvent *) x));
58299 }
58300 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58302 }
58303 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58305 }
58306 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58308 }
58309 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58311 }
58312 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58314 }
58315 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58317 }
58318 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58320 }
58321 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58323 }
58324 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58326 }
58327 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58329 }
58330 static void *_p_wxControlTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58332 }
58333 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58335 }
58336 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) ((wxFSFile *) x));
58338 }
58339 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58341 }
58342 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58344 }
58345 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58347 }
58348 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58350 }
58351 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) ((wxMenuItem *) x));
58353 }
58354 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58356 }
58357 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58359 }
58360 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58362 }
58363 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58365 }
58366 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58368 }
58369 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58371 }
58372 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58374 }
58375 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58377 }
58378 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58380 }
58381 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58383 }
58384 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58386 }
58387 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58389 }
58390 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58392 }
58393 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58395 }
58396 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58398 }
58399 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58401 }
58402 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58404 }
58405 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58407 }
58408 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58410 }
58411 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) ((wxImageHandler *) x));
58413 }
58414 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58416 }
58417 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58419 }
58420 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58422 }
58423 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) ((wxEvtHandler *) x));
58425 }
58426 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58428 }
58429 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58431 }
58432 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58434 }
58435 static void *_p_wxImageTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) ((wxImage *) x));
58437 }
58438 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58440 }
58441 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58443 }
58444 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58446 }
58447 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58449 }
58450 static void *_p_wxWindowTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58452 }
58453 static void *_p_wxMenuTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58455 }
58456 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58458 }
58459 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) ((wxFileSystem *) x));
58461 }
58462 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58464 }
58465 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58467 }
58468 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58470 }
58471 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58473 }
58474 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58476 }
58477 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58478 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58479 }
58480 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58481 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58482 }
58483 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58484 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58485 }
58486 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58487 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58488 }
58489 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58490 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58491 }
58492 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58493 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58494 }
58495 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58496 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58497 }
58498 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58499 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58500 }
58501 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58502 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58503 }
58504 static void *_p_wxControlTo_p_wxWindow(void *x) {
58505 return (void *)((wxWindow *) ((wxControl *) x));
58506 }
58507 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58508 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58509 }
58510 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58511 return (void *)((wxWindow *) ((wxMenuBar *) x));
58512 }
58513 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58514 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58515 }
58516 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58517 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58518 }
58519 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58520 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58521 }
58522 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58523 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58524 }
58525 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58526 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58527 }
58528 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58529 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58530 }
58531 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58532 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58533 }
58534 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58535 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58536 }
58537 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58538 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58539 }
58540 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58541 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58542 }
58543 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58544 return (void *)((wxValidator *) ((wxPyValidator *) x));
58545 }
58546 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58548 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};
58549 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58654 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58655 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58656 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58657 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58658 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58659 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58660 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58661 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58662 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58663 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58664 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58665 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58666 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58667 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58668 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58669 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58670 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58671 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58672 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58673 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58674 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58675 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58676 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58677 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58678 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58679 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58680 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58681
58682 static swig_type_info *swig_type_initial[] = {
58683 &_swigt__p_buffer,
58684 &_swigt__p_char,
58685 &_swigt__p_form_ops_t,
58686 &_swigt__p_int,
58687 &_swigt__p_long,
58688 &_swigt__p_unsigned_char,
58689 &_swigt__p_unsigned_int,
58690 &_swigt__p_unsigned_long,
58691 &_swigt__p_wxANIHandler,
58692 &_swigt__p_wxAcceleratorEntry,
58693 &_swigt__p_wxAcceleratorTable,
58694 &_swigt__p_wxActivateEvent,
58695 &_swigt__p_wxAppTraits,
58696 &_swigt__p_wxArrayString,
58697 &_swigt__p_wxBMPHandler,
58698 &_swigt__p_wxBitmap,
58699 &_swigt__p_wxBoxSizer,
58700 &_swigt__p_wxButton,
58701 &_swigt__p_wxCURHandler,
58702 &_swigt__p_wxCaret,
58703 &_swigt__p_wxChildFocusEvent,
58704 &_swigt__p_wxClipboardTextEvent,
58705 &_swigt__p_wxCloseEvent,
58706 &_swigt__p_wxColour,
58707 &_swigt__p_wxCommandEvent,
58708 &_swigt__p_wxContextMenuEvent,
58709 &_swigt__p_wxControl,
58710 &_swigt__p_wxControlWithItems,
58711 &_swigt__p_wxCursor,
58712 &_swigt__p_wxDC,
58713 &_swigt__p_wxDateEvent,
58714 &_swigt__p_wxDateTime,
58715 &_swigt__p_wxDisplayChangedEvent,
58716 &_swigt__p_wxDouble,
58717 &_swigt__p_wxDropFilesEvent,
58718 &_swigt__p_wxDuplexMode,
58719 &_swigt__p_wxEraseEvent,
58720 &_swigt__p_wxEvent,
58721 &_swigt__p_wxEventLoop,
58722 &_swigt__p_wxEventLoopActivator,
58723 &_swigt__p_wxEvtHandler,
58724 &_swigt__p_wxFSFile,
58725 &_swigt__p_wxFileSystem,
58726 &_swigt__p_wxFileSystemHandler,
58727 &_swigt__p_wxFlexGridSizer,
58728 &_swigt__p_wxFocusEvent,
58729 &_swigt__p_wxFont,
58730 &_swigt__p_wxFrame,
58731 &_swigt__p_wxGBPosition,
58732 &_swigt__p_wxGBSizerItem,
58733 &_swigt__p_wxGBSpan,
58734 &_swigt__p_wxGIFHandler,
58735 &_swigt__p_wxGridBagSizer,
58736 &_swigt__p_wxGridSizer,
58737 &_swigt__p_wxHelpEvent__Origin,
58738 &_swigt__p_wxICOHandler,
58739 &_swigt__p_wxIconizeEvent,
58740 &_swigt__p_wxIdleEvent,
58741 &_swigt__p_wxImage,
58742 &_swigt__p_wxImageHandler,
58743 &_swigt__p_wxImageHistogram,
58744 &_swigt__p_wxImage_HSVValue,
58745 &_swigt__p_wxImage_RGBValue,
58746 &_swigt__p_wxIndividualLayoutConstraint,
58747 &_swigt__p_wxInitDialogEvent,
58748 &_swigt__p_wxInputStream,
58749 &_swigt__p_wxInternetFSHandler,
58750 &_swigt__p_wxItemContainer,
58751 &_swigt__p_wxJPEGHandler,
58752 &_swigt__p_wxKeyEvent,
58753 &_swigt__p_wxLayoutConstraints,
58754 &_swigt__p_wxMaximizeEvent,
58755 &_swigt__p_wxMemoryFSHandler,
58756 &_swigt__p_wxMenu,
58757 &_swigt__p_wxMenuBar,
58758 &_swigt__p_wxMenuBarBase,
58759 &_swigt__p_wxMenuEvent,
58760 &_swigt__p_wxMenuItem,
58761 &_swigt__p_wxMouseCaptureChangedEvent,
58762 &_swigt__p_wxMouseCaptureLostEvent,
58763 &_swigt__p_wxMouseEvent,
58764 &_swigt__p_wxMoveEvent,
58765 &_swigt__p_wxNavigationKeyEvent,
58766 &_swigt__p_wxNcPaintEvent,
58767 &_swigt__p_wxNotifyEvent,
58768 &_swigt__p_wxObject,
58769 &_swigt__p_wxOutputStream,
58770 &_swigt__p_wxPCXHandler,
58771 &_swigt__p_wxPNGHandler,
58772 &_swigt__p_wxPNMHandler,
58773 &_swigt__p_wxPaintEvent,
58774 &_swigt__p_wxPaletteChangedEvent,
58775 &_swigt__p_wxPaperSize,
58776 &_swigt__p_wxPoint,
58777 &_swigt__p_wxPoint2D,
58778 &_swigt__p_wxPropagateOnce,
58779 &_swigt__p_wxPropagationDisabler,
58780 &_swigt__p_wxPyApp,
58781 &_swigt__p_wxPyCommandEvent,
58782 &_swigt__p_wxPyDropTarget,
58783 &_swigt__p_wxPyEvent,
58784 &_swigt__p_wxPyFileSystemHandler,
58785 &_swigt__p_wxPyImageHandler,
58786 &_swigt__p_wxPyInputStream,
58787 &_swigt__p_wxPySizer,
58788 &_swigt__p_wxPyValidator,
58789 &_swigt__p_wxQuantize,
58790 &_swigt__p_wxQueryNewPaletteEvent,
58791 &_swigt__p_wxRealPoint,
58792 &_swigt__p_wxRect,
58793 &_swigt__p_wxRect2D,
58794 &_swigt__p_wxRegion,
58795 &_swigt__p_wxScrollEvent,
58796 &_swigt__p_wxScrollWinEvent,
58797 &_swigt__p_wxSetCursorEvent,
58798 &_swigt__p_wxShowEvent,
58799 &_swigt__p_wxSize,
58800 &_swigt__p_wxSizeEvent,
58801 &_swigt__p_wxSizer,
58802 &_swigt__p_wxSizerItem,
58803 &_swigt__p_wxStaticBox,
58804 &_swigt__p_wxStaticBoxSizer,
58805 &_swigt__p_wxStdDialogButtonSizer,
58806 &_swigt__p_wxSysColourChangedEvent,
58807 &_swigt__p_wxTGAHandler,
58808 &_swigt__p_wxTIFFHandler,
58809 &_swigt__p_wxToolTip,
58810 &_swigt__p_wxUpdateUIEvent,
58811 &_swigt__p_wxValidator,
58812 &_swigt__p_wxVisualAttributes,
58813 &_swigt__p_wxWindow,
58814 &_swigt__p_wxWindowCreateEvent,
58815 &_swigt__p_wxWindowDestroyEvent,
58816 &_swigt__p_wxXPMHandler,
58817 &_swigt__p_wxZipFSHandler,
58818 };
58819
58820 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58834 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}};
58835 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58836 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}};
58837 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58838 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}};
58839 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58844 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}};
58845 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58846 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}};
58847 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58853 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58855 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58857 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}};
58858 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58863 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}};
58864 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}};
58865 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58873 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}};
58874 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58875 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}};
58876 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58879 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}};
58880 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58887 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}};
58888 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58896 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58897 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58898 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58905 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
58906 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58912 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58913 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58914 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58921 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58922 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58923 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58924 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58928 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58929 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58930 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58931 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58932 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58933 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58934 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58935 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58936 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58937 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58938 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}};
58939 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}};
58940 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58941 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58942 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58943 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58944 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58945 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58946 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58947 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58948 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}};
58949 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58950 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}};
58951 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58952 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58953 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58954 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58955
58956 static swig_cast_info *swig_cast_initial[] = {
58957 _swigc__p_buffer,
58958 _swigc__p_char,
58959 _swigc__p_form_ops_t,
58960 _swigc__p_int,
58961 _swigc__p_long,
58962 _swigc__p_unsigned_char,
58963 _swigc__p_unsigned_int,
58964 _swigc__p_unsigned_long,
58965 _swigc__p_wxANIHandler,
58966 _swigc__p_wxAcceleratorEntry,
58967 _swigc__p_wxAcceleratorTable,
58968 _swigc__p_wxActivateEvent,
58969 _swigc__p_wxAppTraits,
58970 _swigc__p_wxArrayString,
58971 _swigc__p_wxBMPHandler,
58972 _swigc__p_wxBitmap,
58973 _swigc__p_wxBoxSizer,
58974 _swigc__p_wxButton,
58975 _swigc__p_wxCURHandler,
58976 _swigc__p_wxCaret,
58977 _swigc__p_wxChildFocusEvent,
58978 _swigc__p_wxClipboardTextEvent,
58979 _swigc__p_wxCloseEvent,
58980 _swigc__p_wxColour,
58981 _swigc__p_wxCommandEvent,
58982 _swigc__p_wxContextMenuEvent,
58983 _swigc__p_wxControl,
58984 _swigc__p_wxControlWithItems,
58985 _swigc__p_wxCursor,
58986 _swigc__p_wxDC,
58987 _swigc__p_wxDateEvent,
58988 _swigc__p_wxDateTime,
58989 _swigc__p_wxDisplayChangedEvent,
58990 _swigc__p_wxDouble,
58991 _swigc__p_wxDropFilesEvent,
58992 _swigc__p_wxDuplexMode,
58993 _swigc__p_wxEraseEvent,
58994 _swigc__p_wxEvent,
58995 _swigc__p_wxEventLoop,
58996 _swigc__p_wxEventLoopActivator,
58997 _swigc__p_wxEvtHandler,
58998 _swigc__p_wxFSFile,
58999 _swigc__p_wxFileSystem,
59000 _swigc__p_wxFileSystemHandler,
59001 _swigc__p_wxFlexGridSizer,
59002 _swigc__p_wxFocusEvent,
59003 _swigc__p_wxFont,
59004 _swigc__p_wxFrame,
59005 _swigc__p_wxGBPosition,
59006 _swigc__p_wxGBSizerItem,
59007 _swigc__p_wxGBSpan,
59008 _swigc__p_wxGIFHandler,
59009 _swigc__p_wxGridBagSizer,
59010 _swigc__p_wxGridSizer,
59011 _swigc__p_wxHelpEvent__Origin,
59012 _swigc__p_wxICOHandler,
59013 _swigc__p_wxIconizeEvent,
59014 _swigc__p_wxIdleEvent,
59015 _swigc__p_wxImage,
59016 _swigc__p_wxImageHandler,
59017 _swigc__p_wxImageHistogram,
59018 _swigc__p_wxImage_HSVValue,
59019 _swigc__p_wxImage_RGBValue,
59020 _swigc__p_wxIndividualLayoutConstraint,
59021 _swigc__p_wxInitDialogEvent,
59022 _swigc__p_wxInputStream,
59023 _swigc__p_wxInternetFSHandler,
59024 _swigc__p_wxItemContainer,
59025 _swigc__p_wxJPEGHandler,
59026 _swigc__p_wxKeyEvent,
59027 _swigc__p_wxLayoutConstraints,
59028 _swigc__p_wxMaximizeEvent,
59029 _swigc__p_wxMemoryFSHandler,
59030 _swigc__p_wxMenu,
59031 _swigc__p_wxMenuBar,
59032 _swigc__p_wxMenuBarBase,
59033 _swigc__p_wxMenuEvent,
59034 _swigc__p_wxMenuItem,
59035 _swigc__p_wxMouseCaptureChangedEvent,
59036 _swigc__p_wxMouseCaptureLostEvent,
59037 _swigc__p_wxMouseEvent,
59038 _swigc__p_wxMoveEvent,
59039 _swigc__p_wxNavigationKeyEvent,
59040 _swigc__p_wxNcPaintEvent,
59041 _swigc__p_wxNotifyEvent,
59042 _swigc__p_wxObject,
59043 _swigc__p_wxOutputStream,
59044 _swigc__p_wxPCXHandler,
59045 _swigc__p_wxPNGHandler,
59046 _swigc__p_wxPNMHandler,
59047 _swigc__p_wxPaintEvent,
59048 _swigc__p_wxPaletteChangedEvent,
59049 _swigc__p_wxPaperSize,
59050 _swigc__p_wxPoint,
59051 _swigc__p_wxPoint2D,
59052 _swigc__p_wxPropagateOnce,
59053 _swigc__p_wxPropagationDisabler,
59054 _swigc__p_wxPyApp,
59055 _swigc__p_wxPyCommandEvent,
59056 _swigc__p_wxPyDropTarget,
59057 _swigc__p_wxPyEvent,
59058 _swigc__p_wxPyFileSystemHandler,
59059 _swigc__p_wxPyImageHandler,
59060 _swigc__p_wxPyInputStream,
59061 _swigc__p_wxPySizer,
59062 _swigc__p_wxPyValidator,
59063 _swigc__p_wxQuantize,
59064 _swigc__p_wxQueryNewPaletteEvent,
59065 _swigc__p_wxRealPoint,
59066 _swigc__p_wxRect,
59067 _swigc__p_wxRect2D,
59068 _swigc__p_wxRegion,
59069 _swigc__p_wxScrollEvent,
59070 _swigc__p_wxScrollWinEvent,
59071 _swigc__p_wxSetCursorEvent,
59072 _swigc__p_wxShowEvent,
59073 _swigc__p_wxSize,
59074 _swigc__p_wxSizeEvent,
59075 _swigc__p_wxSizer,
59076 _swigc__p_wxSizerItem,
59077 _swigc__p_wxStaticBox,
59078 _swigc__p_wxStaticBoxSizer,
59079 _swigc__p_wxStdDialogButtonSizer,
59080 _swigc__p_wxSysColourChangedEvent,
59081 _swigc__p_wxTGAHandler,
59082 _swigc__p_wxTIFFHandler,
59083 _swigc__p_wxToolTip,
59084 _swigc__p_wxUpdateUIEvent,
59085 _swigc__p_wxValidator,
59086 _swigc__p_wxVisualAttributes,
59087 _swigc__p_wxWindow,
59088 _swigc__p_wxWindowCreateEvent,
59089 _swigc__p_wxWindowDestroyEvent,
59090 _swigc__p_wxXPMHandler,
59091 _swigc__p_wxZipFSHandler,
59092 };
59093
59094
59095 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59096
59097 static swig_const_info swig_const_table[] = {
59098 {0, 0, 0, 0.0, 0, 0}};
59099
59100 #ifdef __cplusplus
59101 }
59102 #endif
59103 /* -----------------------------------------------------------------------------
59104 * Type initialization:
59105 * This problem is tough by the requirement that no dynamic
59106 * memory is used. Also, since swig_type_info structures store pointers to
59107 * swig_cast_info structures and swig_cast_info structures store pointers back
59108 * to swig_type_info structures, we need some lookup code at initialization.
59109 * The idea is that swig generates all the structures that are needed.
59110 * The runtime then collects these partially filled structures.
59111 * The SWIG_InitializeModule function takes these initial arrays out of
59112 * swig_module, and does all the lookup, filling in the swig_module.types
59113 * array with the correct data and linking the correct swig_cast_info
59114 * structures together.
59115 *
59116 * The generated swig_type_info structures are assigned staticly to an initial
59117 * array. We just loop though that array, and handle each type individually.
59118 * First we lookup if this type has been already loaded, and if so, use the
59119 * loaded structure instead of the generated one. Then we have to fill in the
59120 * cast linked list. The cast data is initially stored in something like a
59121 * two-dimensional array. Each row corresponds to a type (there are the same
59122 * number of rows as there are in the swig_type_initial array). Each entry in
59123 * a column is one of the swig_cast_info structures for that type.
59124 * The cast_initial array is actually an array of arrays, because each row has
59125 * a variable number of columns. So to actually build the cast linked list,
59126 * we find the array of casts associated with the type, and loop through it
59127 * adding the casts to the list. The one last trick we need to do is making
59128 * sure the type pointer in the swig_cast_info struct is correct.
59129 *
59130 * First off, we lookup the cast->type name to see if it is already loaded.
59131 * There are three cases to handle:
59132 * 1) If the cast->type has already been loaded AND the type we are adding
59133 * casting info to has not been loaded (it is in this module), THEN we
59134 * replace the cast->type pointer with the type pointer that has already
59135 * been loaded.
59136 * 2) If BOTH types (the one we are adding casting info to, and the
59137 * cast->type) are loaded, THEN the cast info has already been loaded by
59138 * the previous module so we just ignore it.
59139 * 3) Finally, if cast->type has not already been loaded, then we add that
59140 * swig_cast_info to the linked list (because the cast->type) pointer will
59141 * be correct.
59142 * ----------------------------------------------------------------------------- */
59143
59144 #ifdef __cplusplus
59145 extern "C" {
59146 #if 0
59147 } /* c-mode */
59148 #endif
59149 #endif
59150
59151 #if 0
59152 #define SWIGRUNTIME_DEBUG
59153 #endif
59154
59155 SWIGRUNTIME void
59156 SWIG_InitializeModule(void *clientdata) {
59157 size_t i;
59158 swig_module_info *module_head;
59159 static int init_run = 0;
59160
59161 clientdata = clientdata;
59162
59163 if (init_run) return;
59164 init_run = 1;
59165
59166 /* Initialize the swig_module */
59167 swig_module.type_initial = swig_type_initial;
59168 swig_module.cast_initial = swig_cast_initial;
59169
59170 /* Try and load any already created modules */
59171 module_head = SWIG_GetModule(clientdata);
59172 if (module_head) {
59173 swig_module.next = module_head->next;
59174 module_head->next = &swig_module;
59175 } else {
59176 /* This is the first module loaded */
59177 swig_module.next = &swig_module;
59178 SWIG_SetModule(clientdata, &swig_module);
59179 }
59180
59181 /* Now work on filling in swig_module.types */
59182 #ifdef SWIGRUNTIME_DEBUG
59183 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59184 #endif
59185 for (i = 0; i < swig_module.size; ++i) {
59186 swig_type_info *type = 0;
59187 swig_type_info *ret;
59188 swig_cast_info *cast;
59189
59190 #ifdef SWIGRUNTIME_DEBUG
59191 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59192 #endif
59193
59194 /* if there is another module already loaded */
59195 if (swig_module.next != &swig_module) {
59196 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59197 }
59198 if (type) {
59199 /* Overwrite clientdata field */
59200 #ifdef SWIGRUNTIME_DEBUG
59201 printf("SWIG_InitializeModule: found type %s\n", type->name);
59202 #endif
59203 if (swig_module.type_initial[i]->clientdata) {
59204 type->clientdata = swig_module.type_initial[i]->clientdata;
59205 #ifdef SWIGRUNTIME_DEBUG
59206 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59207 #endif
59208 }
59209 } else {
59210 type = swig_module.type_initial[i];
59211 }
59212
59213 /* Insert casting types */
59214 cast = swig_module.cast_initial[i];
59215 while (cast->type) {
59216 /* Don't need to add information already in the list */
59217 ret = 0;
59218 #ifdef SWIGRUNTIME_DEBUG
59219 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59220 #endif
59221 if (swig_module.next != &swig_module) {
59222 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59223 #ifdef SWIGRUNTIME_DEBUG
59224 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59225 #endif
59226 }
59227 if (ret) {
59228 if (type == swig_module.type_initial[i]) {
59229 #ifdef SWIGRUNTIME_DEBUG
59230 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59231 #endif
59232 cast->type = ret;
59233 ret = 0;
59234 } else {
59235 /* Check for casting already in the list */
59236 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59237 #ifdef SWIGRUNTIME_DEBUG
59238 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59239 #endif
59240 if (!ocast) ret = 0;
59241 }
59242 }
59243
59244 if (!ret) {
59245 #ifdef SWIGRUNTIME_DEBUG
59246 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59247 #endif
59248 if (type->cast) {
59249 type->cast->prev = cast;
59250 cast->next = type->cast;
59251 }
59252 type->cast = cast;
59253 }
59254 cast++;
59255 }
59256 /* Set entry in modules->types array equal to the type */
59257 swig_module.types[i] = type;
59258 }
59259 swig_module.types[i] = 0;
59260
59261 #ifdef SWIGRUNTIME_DEBUG
59262 printf("**** SWIG_InitializeModule: Cast List ******\n");
59263 for (i = 0; i < swig_module.size; ++i) {
59264 int j = 0;
59265 swig_cast_info *cast = swig_module.cast_initial[i];
59266 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59267 while (cast->type) {
59268 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59269 cast++;
59270 ++j;
59271 }
59272 printf("---- Total casts: %d\n",j);
59273 }
59274 printf("**** SWIG_InitializeModule: Cast List ******\n");
59275 #endif
59276 }
59277
59278 /* This function will propagate the clientdata field of type to
59279 * any new swig_type_info structures that have been added into the list
59280 * of equivalent types. It is like calling
59281 * SWIG_TypeClientData(type, clientdata) a second time.
59282 */
59283 SWIGRUNTIME void
59284 SWIG_PropagateClientData(void) {
59285 size_t i;
59286 swig_cast_info *equiv;
59287 static int init_run = 0;
59288
59289 if (init_run) return;
59290 init_run = 1;
59291
59292 for (i = 0; i < swig_module.size; i++) {
59293 if (swig_module.types[i]->clientdata) {
59294 equiv = swig_module.types[i]->cast;
59295 while (equiv) {
59296 if (!equiv->converter) {
59297 if (equiv->type && !equiv->type->clientdata)
59298 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59299 }
59300 equiv = equiv->next;
59301 }
59302 }
59303 }
59304 }
59305
59306 #ifdef __cplusplus
59307 #if 0
59308 {
59309 /* c-mode */
59310 #endif
59311 }
59312 #endif
59313
59314
59315
59316 #ifdef __cplusplus
59317 extern "C" {
59318 #endif
59319
59320 /* Python-specific SWIG API */
59321 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59322 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59323 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59324
59325 /* -----------------------------------------------------------------------------
59326 * global variable support code.
59327 * ----------------------------------------------------------------------------- */
59328
59329 typedef struct swig_globalvar {
59330 char *name; /* Name of global variable */
59331 PyObject *(*get_attr)(void); /* Return the current value */
59332 int (*set_attr)(PyObject *); /* Set the value */
59333 struct swig_globalvar *next;
59334 } swig_globalvar;
59335
59336 typedef struct swig_varlinkobject {
59337 PyObject_HEAD
59338 swig_globalvar *vars;
59339 } swig_varlinkobject;
59340
59341 SWIGINTERN PyObject *
59342 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59343 return PyString_FromString("<Swig global variables>");
59344 }
59345
59346 SWIGINTERN PyObject *
59347 swig_varlink_str(swig_varlinkobject *v) {
59348 PyObject *str = PyString_FromString("(");
59349 swig_globalvar *var;
59350 for (var = v->vars; var; var=var->next) {
59351 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59352 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59353 }
59354 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59355 return str;
59356 }
59357
59358 SWIGINTERN int
59359 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59360 PyObject *str = swig_varlink_str(v);
59361 fprintf(fp,"Swig global variables ");
59362 fprintf(fp,"%s\n", PyString_AsString(str));
59363 Py_DECREF(str);
59364 return 0;
59365 }
59366
59367 SWIGINTERN void
59368 swig_varlink_dealloc(swig_varlinkobject *v) {
59369 swig_globalvar *var = v->vars;
59370 while (var) {
59371 swig_globalvar *n = var->next;
59372 free(var->name);
59373 free(var);
59374 var = n;
59375 }
59376 }
59377
59378 SWIGINTERN PyObject *
59379 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59380 PyObject *res = NULL;
59381 swig_globalvar *var = v->vars;
59382 while (var) {
59383 if (strcmp(var->name,n) == 0) {
59384 res = (*var->get_attr)();
59385 break;
59386 }
59387 var = var->next;
59388 }
59389 if (res == NULL && !PyErr_Occurred()) {
59390 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59391 }
59392 return res;
59393 }
59394
59395 SWIGINTERN int
59396 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59397 int res = 1;
59398 swig_globalvar *var = v->vars;
59399 while (var) {
59400 if (strcmp(var->name,n) == 0) {
59401 res = (*var->set_attr)(p);
59402 break;
59403 }
59404 var = var->next;
59405 }
59406 if (res == 1 && !PyErr_Occurred()) {
59407 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59408 }
59409 return res;
59410 }
59411
59412 SWIGINTERN PyTypeObject*
59413 swig_varlink_type(void) {
59414 static char varlink__doc__[] = "Swig var link object";
59415 static PyTypeObject varlink_type;
59416 static int type_init = 0;
59417 if (!type_init) {
59418 const PyTypeObject tmp
59419 = {
59420 PyObject_HEAD_INIT(NULL)
59421 0, /* Number of items in variable part (ob_size) */
59422 (char *)"swigvarlink", /* Type name (tp_name) */
59423 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59424 0, /* Itemsize (tp_itemsize) */
59425 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59426 (printfunc) swig_varlink_print, /* Print (tp_print) */
59427 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59428 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59429 0, /* tp_compare */
59430 (reprfunc) swig_varlink_repr, /* tp_repr */
59431 0, /* tp_as_number */
59432 0, /* tp_as_sequence */
59433 0, /* tp_as_mapping */
59434 0, /* tp_hash */
59435 0, /* tp_call */
59436 (reprfunc)swig_varlink_str, /* tp_str */
59437 0, /* tp_getattro */
59438 0, /* tp_setattro */
59439 0, /* tp_as_buffer */
59440 0, /* tp_flags */
59441 varlink__doc__, /* tp_doc */
59442 0, /* tp_traverse */
59443 0, /* tp_clear */
59444 0, /* tp_richcompare */
59445 0, /* tp_weaklistoffset */
59446 #if PY_VERSION_HEX >= 0x02020000
59447 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59448 #endif
59449 #if PY_VERSION_HEX >= 0x02030000
59450 0, /* tp_del */
59451 #endif
59452 #ifdef COUNT_ALLOCS
59453 0,0,0,0 /* tp_alloc -> tp_next */
59454 #endif
59455 };
59456 varlink_type = tmp;
59457 varlink_type.ob_type = &PyType_Type;
59458 type_init = 1;
59459 }
59460 return &varlink_type;
59461 }
59462
59463 /* Create a variable linking object for use later */
59464 SWIGINTERN PyObject *
59465 SWIG_Python_newvarlink(void) {
59466 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59467 if (result) {
59468 result->vars = 0;
59469 }
59470 return ((PyObject*) result);
59471 }
59472
59473 SWIGINTERN void
59474 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59475 swig_varlinkobject *v = (swig_varlinkobject *) p;
59476 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59477 if (gv) {
59478 size_t size = strlen(name)+1;
59479 gv->name = (char *)malloc(size);
59480 if (gv->name) {
59481 strncpy(gv->name,name,size);
59482 gv->get_attr = get_attr;
59483 gv->set_attr = set_attr;
59484 gv->next = v->vars;
59485 }
59486 }
59487 v->vars = gv;
59488 }
59489
59490 SWIGINTERN PyObject *
59491 SWIG_globals() {
59492 static PyObject *_SWIG_globals = 0;
59493 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59494 return _SWIG_globals;
59495 }
59496
59497 /* -----------------------------------------------------------------------------
59498 * constants/methods manipulation
59499 * ----------------------------------------------------------------------------- */
59500
59501 /* Install Constants */
59502 SWIGINTERN void
59503 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59504 PyObject *obj = 0;
59505 size_t i;
59506 for (i = 0; constants[i].type; ++i) {
59507 switch(constants[i].type) {
59508 case SWIG_PY_POINTER:
59509 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59510 break;
59511 case SWIG_PY_BINARY:
59512 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59513 break;
59514 default:
59515 obj = 0;
59516 break;
59517 }
59518 if (obj) {
59519 PyDict_SetItemString(d, constants[i].name, obj);
59520 Py_DECREF(obj);
59521 }
59522 }
59523 }
59524
59525 /* -----------------------------------------------------------------------------*/
59526 /* Fix SwigMethods to carry the callback ptrs when needed */
59527 /* -----------------------------------------------------------------------------*/
59528
59529 SWIGINTERN void
59530 SWIG_Python_FixMethods(PyMethodDef *methods,
59531 swig_const_info *const_table,
59532 swig_type_info **types,
59533 swig_type_info **types_initial) {
59534 size_t i;
59535 for (i = 0; methods[i].ml_name; ++i) {
59536 const char *c = methods[i].ml_doc;
59537 if (c && (c = strstr(c, "swig_ptr: "))) {
59538 int j;
59539 swig_const_info *ci = 0;
59540 const char *name = c + 10;
59541 for (j = 0; const_table[j].type; ++j) {
59542 if (strncmp(const_table[j].name, name,
59543 strlen(const_table[j].name)) == 0) {
59544 ci = &(const_table[j]);
59545 break;
59546 }
59547 }
59548 if (ci) {
59549 size_t shift = (ci->ptype) - types;
59550 swig_type_info *ty = types_initial[shift];
59551 size_t ldoc = (c - methods[i].ml_doc);
59552 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59553 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59554 if (ndoc) {
59555 char *buff = ndoc;
59556 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59557 if (ptr) {
59558 strncpy(buff, methods[i].ml_doc, ldoc);
59559 buff += ldoc;
59560 strncpy(buff, "swig_ptr: ", 10);
59561 buff += 10;
59562 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59563 methods[i].ml_doc = ndoc;
59564 }
59565 }
59566 }
59567 }
59568 }
59569 }
59570
59571 #ifdef __cplusplus
59572 }
59573 #endif
59574
59575 /* -----------------------------------------------------------------------------*
59576 * Partial Init method
59577 * -----------------------------------------------------------------------------*/
59578
59579 #ifdef __cplusplus
59580 extern "C"
59581 #endif
59582 SWIGEXPORT void SWIG_init(void) {
59583 PyObject *m, *d;
59584
59585 /* Fix SwigMethods to carry the callback ptrs when needed */
59586 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59587
59588 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59589 d = PyModule_GetDict(m);
59590
59591 SWIG_InitializeModule(0);
59592 SWIG_InstallConstants(d,swig_const_table);
59593
59594
59595
59596 #ifndef wxPyUSE_EXPORT
59597 // Make our API structure a CObject so other modules can import it
59598 // from this module.
59599 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59600 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59601 Py_XDECREF(cobj);
59602 #endif
59603
59604 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59605 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59606 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59607 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59608 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59609 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59610 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59611 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59612 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59613 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59614 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59615 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59616 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59617 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59618 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59619 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59620 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59621 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59622 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59623 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59624 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59625 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59626 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59627 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59628 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59629 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59630 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59631 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59632 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59633 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59634 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59635 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59636 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59637 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59638 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59639 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59640 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59641 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59642 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59643 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59644 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59645 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59646 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59647 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59648 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59649 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59650 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59651 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59652 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59653 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59654 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59655 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59656 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59657 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59658 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59659 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59660 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59661 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59662 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59663 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59664 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59665 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59666 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59667 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59668 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59669 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59670 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59671 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59672 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59673 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59674 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59675 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59676 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59677 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59678 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59679 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59680 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59681 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59682 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59683 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59684 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59685 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59686 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59687 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59688 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59689 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59690 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59691 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59692 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59693 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59694 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59695 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59696 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59697 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59698 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59699 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59700 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59701 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59702 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59703 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59704 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59705 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59706 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59707 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59708 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59709 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59710 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59711 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59712 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59713 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59714 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59715 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59716 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59717 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59718 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59719 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59720 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59721 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59722 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59723 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59724 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59725 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59726 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59727 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59728 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59729 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59730 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59731 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59732 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59733 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59734 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59735 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59736 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59737 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59738 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59739 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59740 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59741 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59742 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59743 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59744 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59745 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59746 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59747 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59748 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59749 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59750 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59751 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59752 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59753 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59754 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59755 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59756 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59757 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59758 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59759 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59760 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59761 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59762 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59763 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59764 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59765 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59766 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59767 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59768 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59769 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59770 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59771 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59772 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59773 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59774 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59775 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59776 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59777 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59778 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59779 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59780 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59781 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59782 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59783 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59784 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59785 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59786 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59787 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59788 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59789 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59790 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59791 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59792 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59793 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59794 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59795 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59796 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59797 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59798 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59799 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59800 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59801 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59802 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59803 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59804 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59805 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59806 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59807 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59808 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59809 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59810 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59811 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59812 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59813 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59814 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59815 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59816 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59817 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59818 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59819 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59820 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59821 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59822 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59823 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59824 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59825 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59826 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59827 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59828 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59829 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59830 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59831 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59832 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59833 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59834 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59835 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59836 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59837 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59838 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59839 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59840 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59841 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59842 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59843 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59844 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59845 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59846 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59847 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59848 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59849 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59850 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59851 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59852 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59853 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59854 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59855 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59856 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59857 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59858 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59859 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59860 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59861 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59862 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59863 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59864 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59865 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59866 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59867 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59868 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59869 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59870 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59871 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59872 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59873 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59874 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59875 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59876 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59877 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59878 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59879 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59880 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59881 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59882 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59883 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59884 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59885 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59886 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59887 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59888 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59889 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59890 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59891 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59892 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59893 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59894 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59895 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59896 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59897 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59898 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59899 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59900 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59901 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59902 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59903 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59904 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59905 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59906 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59907 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59908 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59909 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59910 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59911 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59912 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59913 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59914 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59915 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59916 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59917 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59918 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59919 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59920 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59921 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59922 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59923 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59924 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59925 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59926 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59927 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59928 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59929 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59930 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59931 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59932 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59933 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59934 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59935 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59936 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59937 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59938 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59939 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59940 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59941 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59942 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59943 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59944 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59945 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59946 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59947 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59948 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59949 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59950 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59951 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59952 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59953 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59955 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59956 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59957 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59958 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59959 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59960 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59961 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59962 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59963 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59964 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59965 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59966 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59967 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59968 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59969 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59970 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59971 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59972 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59973 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59974 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59975 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59976 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59977 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59978 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59979 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59980 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59981 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59982 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59983 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59984 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59985 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59986 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59987 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59988 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59989 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59990 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59991 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59992 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59993 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59994 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59995 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59996 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59997 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
60000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
60001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
60002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
60003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
60004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
60005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
60006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
60007 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60008 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60009 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60010 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60011 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60012 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60013 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60014 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60015 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60016 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60017 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60018 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60019 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60020 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60021 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60022 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60023 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60024 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60025 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60026 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60027 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60028 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60029 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60030 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60031 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60032 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60033 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60034 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60035 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60036 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60037 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60038 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60039 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60040 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60041 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60042 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60043 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60044 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60045 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60046 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60047 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60048 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60049 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60050 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60051 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60052 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60053 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60054 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60055 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60056 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60057 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60058 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60059 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60060 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60061 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60062 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60063 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60064 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60065 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60066 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60067 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60068 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60069 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60070 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60071 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60072 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60073 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60074 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60075 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60076 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60077 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60078 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60079 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60080 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60081 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60082 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60083 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60084 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60085 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60086 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60087 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60088 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60089 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60090 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60091 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60092 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60093 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60094 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60095 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60096 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60097 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60098 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60099 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60100 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60101 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60102 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60103 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60104 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60105 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60106 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60107 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60108 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60109 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60110 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60111 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60112 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60113 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60114 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60115 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60116 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60117 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60118 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60119 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60120 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60121 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60122 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60123 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60124 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60125 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60126 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60127 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60128 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60129 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60130 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60131 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60132 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60133 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60134 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60135 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60136 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60137 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60138 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60139 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60140 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60141 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60142 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60143 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60144 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60145 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60146 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60147 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60148 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60149 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60150 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60151 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60152 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60153 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60154 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60155 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60156 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60157 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60158 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60159 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60160 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60161 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60162 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60163 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60164 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60165 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60166 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60167 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60168 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60169 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60170 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60171 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60172 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60173 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60174 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60175 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60176 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60177 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60178 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60179 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60180 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60181 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60182 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60183 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60184 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60185 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60186 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60187 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60188 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60189 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60190 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60191 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60192 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60193 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60194 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60195 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60196 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60197 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60198 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60199 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60200 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60201 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60202 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60203 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60204 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60205 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60206 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60207 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60208 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60209 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60210 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60211 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60212 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60213 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60214 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60215 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60216 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60217 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60218 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60219 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60220 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60221 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60222 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60223 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60224 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60225 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60226 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60227 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60228 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60229 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60230 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60231 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60232 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60233 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60234 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60235 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60236 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60237 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60238 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60239 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60240 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60241 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60242 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60243 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60244 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60245 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60246 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60247 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60248 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60249 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60250 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60251 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60252 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60253 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60254 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60255 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60256 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60257 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60258 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60259 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60260 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60261 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60262 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60263 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60264 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60265 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60266 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60267 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60268 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60269
60270 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60271
60272
60273 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60274
60275 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60276 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60277 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60278 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60279 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60280 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60281 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60282 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60283 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60284 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60285 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60286 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60287 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60288 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60289 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60290 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60291 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60292 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60293 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60294 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60295 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60296 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60297 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60298 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60299 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60300 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60301 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60302 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60303 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60304 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60305 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60306 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60307 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60308 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60309 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60310 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60311 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60312 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60313 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60314 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60315 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60316 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60320 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60321 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60322 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60323 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60324 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60325 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60326 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60327 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60328 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60329 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60330 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60331 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60332 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60333 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60334 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60335 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60336 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60337 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60338 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60339 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60340 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60341 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60342 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60343 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60344 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60345 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60346 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60347 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60348 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60349 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60350 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60351 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60352 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60353 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60354 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60355 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60356 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60357 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60358 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60359 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60360 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60361 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60362 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60363 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60364 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60365 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60366 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60367 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60368 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60369 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60370 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60371 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60372 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60373 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60374 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60375 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60376 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60377 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60378 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60379 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60380 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60381 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60382 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60383 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60384 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60385 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60386 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60387 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60388 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60389 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60390 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60391 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60392 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60393 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60394 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60395 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60396 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60397 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60398 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60399 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60400 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60401 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60402 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60403 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60404 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60405 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60406 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60407 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60408 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60409 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60410 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60411 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60412 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60413 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60414 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60415 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60416 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60417 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60418 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60419 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60420 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60421 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60422 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60423 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60424 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60425 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60426 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60427 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60428 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60429 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60430 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60431 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60432 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60433 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60434 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60435 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60436 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60437 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60438 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60439 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60440 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60441 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60442 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60443 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60444 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60445 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60446 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60447 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60448 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60449 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60450 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60451 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60452 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60453 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60454 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60455 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60456 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60457 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60458 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60459 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60460 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60461 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60462 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60463 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60464 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60465 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60466 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60467 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60468 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60469 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60470 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60471 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60472 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60473 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60474 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60475 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60476 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60477 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60478 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60479 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60480 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60481 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60482 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60483 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60484 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60485 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60486 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60487 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60488 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60489
60490 // Initialize threading, some globals and such
60491 __wxPyPreStart(d);
60492
60493
60494 // Although these are defined in __version__ they need to be here too so
60495 // that an assert can be done to ensure that the wxPython and the wxWindows
60496 // versions match.
60497 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60498 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60499 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60500
60501 }
60502
wxWidgets (Impactor)